minor snap fixes

Author: sprocketc

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

@@ -12160,6 +12160,83 @@
                                                                                                         :worker {:op :keys,
                                                                                                                  :req {:tasks :map}},
                                                                                                         :pen-mode :boolean}}}}},
+                                                                   selected-with-descendant-ids {:arities {1 {:args [{:op :keys,
+                                                                                                                      :opt {:system-fonts :vector,
+                                                                                                                            :copied-bounds :seqable,
+                                                                                                                            :active-document :any,
+                                                                                                                            :adjusted-pointer-offset :seqable,
+                                                                                                                            :re-pressed.core/keydown :map,
+                                                                                                                            :pivot-point :seqable,
+                                                                                                                            :copied-elements :seqable,
+                                                                                                                            :kd-tree :any,
+                                                                                                                            :pointer-offset :seqable,
+                                                                                                                            :nearest-neighbors :sequential,
+                                                                                                                            :event-time :number,
+                                                                                                                            :drag :boolean,
+                                                                                                                            :version :string,
+                                                                                                                            :nearest-neighbor {:op :keys,
+                                                                                                                                               :req {:point :seqable,
+                                                                                                                                                     :base-point :seqable,
+                                                                                                                                                     :dist-squared :number}},
+                                                                                                                            :dom-rect {:op :keys,
+                                                                                                                                       :req {:x :number,
+                                                                                                                                             :y :number,
+                                                                                                                                             :width :number,
+                                                                                                                                             :height :number,
+                                                                                                                                             :top :number,
+                                                                                                                                             :right :number,
+                                                                                                                                             :bottom :number,
+                                                                                                                                             :left :number}},
+                                                                                                                            :nearest-neighbor-offset :seqable,
+                                                                                                                            :clicked-element :any,
+                                                                                                                            :primary-tool :any},
+                                                                                                                      :req {:double-click-delta :any,
+                                                                                                                            :dialogs :vector,
+                                                                                                                            :repl-mode :keyword,
+                                                                                                                            :snap {:op :keys,
+                                                                                                                                   :req {:active :boolean,
+                                                                                                                                         :threshold :number,
+                                                                                                                                         :options :set}},
+                                                                                                                            :grid :boolean,
+                                                                                                                            :tool :any,
+                                                                                                                            :ruler {:op :keys,
+                                                                                                                                    :req {:visible :boolean,
+                                                                                                                                          :locked :boolean,
+                                                                                                                                          :size :number}},
+                                                                                                                            :cursor :string,
+                                                                                                                            :pointer-pos :seqable,
+                                                                                                                            :state :keyword,
+                                                                                                                            :window {:op :keys,
+                                                                                                                                     :req {:maximized :boolean,
+                                                                                                                                           :minimized :boolean,
+                                                                                                                                           :fullscreen :boolean,
+                                                                                                                                           :focused :boolean}},
+                                                                                                                            :theme {:op :keys,
+                                                                                                                                    :opt {:native-mode :keyword},
+                                                                                                                                    :req {:mode :keyword}},
+                                                                                                                            :lang :any,
+                                                                                                                            :document-tabs :vector,
+                                                                                                                            :documents :map,
+                                                                                                                            :notifications :seqable,
+                                                                                                                            :recent :vector,
+                                                                                                                            :zoom-sensitivity :any,
+                                                                                                                            :debug-info :boolean,
+                                                                                                                            :adjusted-pointer-pos :seqable,
+                                                                                                                            :timeline {:op :keys,
+                                                                                                                                       :req {:time :number,
+                                                                                                                                             :speed :number,
+                                                                                                                                             :replay? :boolean,
+                                                                                                                                             :grid-snap? :boolean,
+                                                                                                                                             :guide-snap? :boolean,
+                                                                                                                                             :paused? :boolean}},
+                                                                                                                            :backdrop :boolean,
+                                                                                                                            :drag-threshold :number,
+                                                                                                                            :fx :vector,
+                                                                                                                            :panels :map,
+                                                                                                                            :worker {:op :keys,
+                                                                                                                                     :req {:tasks :map}},
+                                                                                                                            :pen-mode :boolean}}],
+                                                                                                              :ret :set}}},
                                                                    top-ancestor-ids {:arities {1 {:args [{:op :keys,
                                                                                                           :opt {:system-fonts :vector,
                                                                                                                 :copied-bounds :seqable,

src/renderer/document/handlers.cljs

@@ -107,7 +107,7 @@
                    (assoc :title (new-title db)))]
     (-> db
         (assoc-in [:documents id] document)
-        (assoc :active-document id)
+        (set-active id)
         (update :document-tabs #(vec/add % (inc active-index) id)))))
 
 (m/=> set-hovered-ids [:-> App [:set uuid?] App])

src/renderer/element/handlers.cljs

@@ -206,6 +206,11 @@
   [db]
   (set/difference (selected-ids db) (descendant-ids db)))
 
+(m/=> selected-with-descendant-ids [:-> App [:set uuid?]])
+(defn selected-with-descendant-ids
+  [db]
+  (set/union (selected-ids db) (descendant-ids db)))
+
 (m/=> top-selected-ancestors [:-> App [:sequential Element]])
 (defn top-selected-ancestors
   [db]

src/renderer/snap/events.cljs

@@ -26,7 +26,9 @@
    :after (fn [context]
             (let [db (rf/get-effect context :db)]
               (cond-> context
-                (not= (element.h/selected-ids db) (rf/get-coeffect context :selected-ids))
+                (and (:active-document db)
+                     (not= (element.h/selected-ids db)
+                           (rf/get-coeffect context :selected-ids)))
                 (rf/assoc-effect :db (h/update-tree db)))))))
 
 (rf/reg-global-interceptor auto-update-tree)

src/renderer/tool/impl/base/transform.cljs

@@ -1,6 +1,7 @@
 (ns renderer.tool.impl.base.transform
   (:require
    [clojure.core.matrix :as mat]
+   [clojure.set :as set]
    [malli.core :as m]
    [renderer.app.db :refer [App]]
    [renderer.app.effects :as-alias app.fx]
@@ -333,6 +334,8 @@
 
 (defmethod hierarchy/snapping-points :transform
   [db]
-  (let [elements (vals (element.h/entities db))
-        non-selected-visible (filter #(and (not (:selected %)) (:visible %)) elements)]
+  (let [non-selected-ids (set/difference (set (keys (element.h/entities db)))
+                                         (element.h/selected-with-descendant-ids db))
+        non-selected (select-keys (element.h/entities db) (vec non-selected-ids))
+        non-selected-visible (filter :visible (vals non-selected))]
     (element.h/snapping-points db non-selected-visible)))