add element labels

Author: sprocketc

.clj-kondo/metosin/malli-types-cljs/config.edn

@@ -1,36 +1,36 @@
 {:linters {:unresolved-symbol {:exclude [(malli.core/=>)]},
-           :type-mismatch {:namespaces {renderer.handle.views {circle-handle {:arities {:varargs {:args [{:op :keys,
-                                                                                                          :opt {:cursor :string,
-                                                                                                                :x :number,
-                                                                                                                :y :number,
-                                                                                                                :size :number,
-                                                                                                                :stroke-width :number,
-                                                                                                                :element :any},
-                                                                                                          :req {:id :keyword,
-                                                                                                                :action :keyword,
-                                                                                                                :type :any}}
-                                                                                                         {:op :rest,
-                                                                                                          :spec :any}],
-                                                                                                  :ret :any,
-                                                                                                  :min-arity 1}}},
-                                                               square-handle {:arities {:varargs {:args [{:op :keys,
-                                                                                                          :opt {:cursor :string,
-                                                                                                                :x :number,
-                                                                                                                :y :number,
-                                                                                                                :size :number,
-                                                                                                                :stroke-width :number,
-                                                                                                                :element :any},
-                                                                                                          :req {:id :keyword,
-                                                                                                                :action :keyword,
-                                                                                                                :type :any}}
-                                                                                                         {:op :rest,
-                                                                                                          :spec :any}],
-                                                                                                  :ret :any,
-                                                                                                  :min-arity 1}}},
+           :type-mismatch {:namespaces {renderer.handle.views {circle {:arities {:varargs {:args [{:op :keys,
+                                                                                                   :opt {:cursor :string,
+                                                                                                         :x :number,
+                                                                                                         :y :number,
+                                                                                                         :size :number,
+                                                                                                         :stroke-width :number,
+                                                                                                         :element :any},
+                                                                                                   :req {:id :keyword,
+                                                                                                         :action :keyword,
+                                                                                                         :type :any}}
+                                                                                                  {:op :rest,
+                                                                                                   :spec :any}],
+                                                                                           :ret :any,
+                                                                                           :min-arity 1}}},
+                                                               square {:arities {:varargs {:args [{:op :keys,
+                                                                                                   :opt {:cursor :string,
+                                                                                                         :x :number,
+                                                                                                         :y :number,
+                                                                                                         :size :number,
+                                                                                                         :stroke-width :number,
+                                                                                                         :element :any},
+                                                                                                   :req {:id :keyword,
+                                                                                                         :action :keyword,
+                                                                                                         :type :any}}
+                                                                                                  {:op :rest,
+                                                                                                   :spec :any}],
+                                                                                           :ret :any,
+                                                                                           :min-arity 1}}},
                                                                wrapping-bounding-box {:arities {1 {:args [:seqable],
                                                                                                    :ret :any}}},
                                                                min-bounds {:arities {1 {:args [:seqable], :ret :any}}},
-                                                               bounding-handles {:arities {1 {:args [:seqable],
+                                                               bounding-corners {:arities {1 {:args [:seqable],
                                                                                               :ret :any}}}},
                                         renderer.utils.element {snapping-points {:arities {2 {:args [{:op :keys,
                                                                                                       :opt {:children :vector,
@@ -268,7 +268,7 @@
                                                                                            :ret :vector}}},
                                                                   ->camel-case {:arities {1 {:args [:keyword],
                                                                                              :ret :keyword}}},
-                                                                  ->map {:arities {1 {:args [:map], :ret :map}}},
+                                                                  ->map {:arities {1 {:args [:any], :ret :map}}},
                                                                   defaults {:arities {1 {:args [:any], :ret :map}}}},
                                         renderer.app.handlers {set-state {:arities {2 {:args [:any :keyword], :ret :any}}},
                                                                set-cursor {:arities {2 {:args [:any :string], :ret :any}}},

src/renderer/element/impl/container/group.cljs

@@ -14,6 +14,7 @@
 (defmethod hierarchy/properties :g
   []
   {:icon "group"
+   :label "Group"
    :description "The <g> SVG element is a container used to group other
                  SVG elements."
    :attrs [:transform]})

src/renderer/element/impl/shape/rect.cljs

@@ -11,7 +11,7 @@
 (defmethod hierarchy/properties :rect
   []
   {:icon "rectangle"
-   :label "rectangle"
+   :label "Rectangle"
    :description "The <rect> element is a basic SVG shape that draws rectangles,
                  defined by their position, width, and height. The rectangles
                  may have their corners rounded."

src/renderer/tree/views.cljs

@@ -8,6 +8,7 @@
    [renderer.document.events :as-alias document.e]
    [renderer.document.subs :as-alias document.s]
    [renderer.element.events :as-alias element.e]
+   [renderer.element.hierarchy :as element.hierarchy]
    [renderer.element.subs :as-alias element.s]
    [renderer.element.views :as element.v]
    [renderer.frame.events :as-alias frame.e]
@@ -48,7 +49,8 @@
 (defn item-label
   [{:keys [id label visible tag]}]
   (ra/with-let [edit-mode? (ra/atom false)
-                tag-label (str/capitalize (name tag))]
+                properties (element.hierarchy/properties tag)
+                tag-label (or (:label properties) (str/capitalize (name tag)))]
     (if @edit-mode?
       [:input.list-item-input
        {:default-value label

src/renderer/utils/attribute.cljs

@@ -234,7 +234,7 @@
 (def ->camel-case-memo (memoize ->camel-case))
 
 (mx/defn ->map :- Attrs
-  [attrs :- Attrs]
+  [attrs]
   (let [deprecated-path [:__compat :status :deprecated]
         filtered-attrs (->> attrs
                             (filter #(not (get-in (val %) deprecated-path)))