✨ Add better workspace file indexing strategy

Improve file indexes initialization on workspace.

Instead of initialize indexes for all pages only initialize
indexes for the loaded page.

common/src/app/common/files/indices.cljc

@@ -6,14 +6,29 @@
 
 (ns app.common.files.indices
   (:require
+   [app.common.data :as d]
+   [app.common.data.macros :as dm]
    [app.common.files.helpers :as cfh]
    [app.common.uuid :as uuid]))
 
+(defn- generate-index
+  "An optimized algorithm for calculate parents index that walk from top
+  to down starting from a provided shape-id. Usefull when you want to
+  create an index for the whole objects or subpart of the tree."
+  [index objects shape-id parents]
+  (let [shape   (get objects shape-id)
+        index   (assoc index shape-id parents)
+        parents (cons shape-id parents)]
+    (reduce (fn [index shape-id]
+              (generate-index index objects shape-id parents))
+            index
+            (:shapes shape))))
+
 (defn generate-child-all-parents-index
   "Creates an index where the key is the shape id and the value is a set
   with all the parents"
   ([objects]
-   (generate-child-all-parents-index objects (vals objects)))
+   (generate-index {} objects uuid/zero []))
 
   ([objects shapes]
    (let [shape->entry
@@ -24,24 +39,25 @@
 (defn create-clip-index
   "Retrieves the mask information for an object"
   [objects parents-index]
-  (let [retrieve-clips
-        (fn [parents]
-          (let [lookup-object (fn [id] (get objects id))
-                get-clip-parents
+  (let [get-clip-parents
         (fn [shape]
+          (let [shape-id (dm/get-prop shape :id)]
             (cond-> []
-                    (or (and (= :frame (:type shape))
+              (or (and (cfh/frame-shape? shape)
                        (not (:show-content shape))
-                             (not= uuid/zero (:id shape)))
+                       (not= uuid/zero shape-id))
                   (cfh/bool-shape? shape))
               (conj shape)
 
               (:masked-group shape)
-                    (conj (get objects (->> shape :shapes first)))))]
+              (conj (get objects (->> shape :shapes first))))))
 
-            (into []
-                  (comp (map lookup-object)
+        xform
+        (comp (map (d/getf objects))
               (mapcat get-clip-parents))
-                  parents)))]
-    (-> parents-index
-        (update-vals retrieve-clips))))
+
+        populate-with-clips
+        (fn [parents]
+          (into [] xform parents))]
+
+    (d/update-vals parents-index populate-with-clips)))

frontend/src/app/main/data/changes.cljs

@@ -52,7 +52,7 @@
         (->> (rx/from changes)
              (rx/merge-map (fn [[page-id changes]]
                              (log/debug :hint "update-indexes" :page-id page-id :changes (count changes))
-                             (mw/ask! {:cmd :index/update-page-index
+                             (mw/ask! {:cmd :index/update
                                        :page-id page-id
                                        :changes changes})))
              (rx/catch (fn [cause]

frontend/src/app/main/data/workspace.cljs

@@ -21,7 +21,6 @@
    [app.common.types.component :as ctc]
    [app.common.types.fills :as types.fills]
    [app.common.types.shape :as cts]
-   [app.common.types.shape-tree :as ctst]
    [app.common.uuid :as uuid]
    [app.config :as cf]
    [app.main.data.changes :as dch]
@@ -70,7 +69,6 @@
    [app.main.features.pointer-map :as fpmap]
    [app.main.repo :as rp]
    [app.main.router :as rt]
-   [app.main.worker :as mw]
    [app.render-wasm :as wasm]
    [app.render-wasm.api :as api]
    [app.util.dom :as dom]
@@ -84,7 +82,7 @@
    [cuerdas.core :as str]
    [potok.v2.core :as ptk]))
 
-(log/set-level! :debug)
+(log/set-level! :trace)
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; Workspace Initialization
@@ -158,18 +156,9 @@
   (->> (fpmap/resolve-file file)
        (rx/map :data)
        (rx/map process-fills)
-       (rx/mapcat
-        (fn [{:keys [pages-index] :as data}]
-          (->> (rx/from (seq pages-index))
-               (rx/mapcat
-                (fn [[id page]]
-                  (let [page (update page :objects ctst/start-page-index)]
-                    (->> (mw/ask! {:cmd :index/initialize-page-index :page page})
-                         (rx/map (fn [_] [id page]))))))
-               (rx/reduce conj {})
-               (rx/map (fn [pages-index]
-                         (let [data (assoc data :pages-index pages-index)]
-                           (assoc file :data (d/removem (comp t/pointer? val) data))))))))))
+       (rx/map
+        (fn [data]
+          (assoc file :data (d/removem (comp t/pointer? val) data))))))
 
 (defn- check-libraries-synchronozation
   [file-id libraries]
@@ -280,6 +269,8 @@
   (ptk/reify ::fetch-bundle
     ptk/WatchEvent
     (watch [_ _ stream]
+      (log/debug :hint "fetch bundle" :file-id (dm/str file-id))
+
       (let [stopper-s (rx/filter (ptk/type? ::finalize-workspace) stream)]
         (->> (rx/zip (rp/cmd! :get-file {:id file-id :features features})
                      (get-file-object-thumbnails file-id))
@@ -288,6 +279,7 @@
               (fn [[file thumbnails]]
                 (->> (resolve-file file)
                      (rx/map (fn [file]
+                               (log/trace :hint "file resolved" :file-id file-id)
                                {:file file
                                 :file-id file-id
                                 :features features
@@ -357,6 +349,10 @@
                    (rx/map deref)
                    (rx/mapcat
                     (fn [{:keys [file]}]
+                      (log/debug :hint "bundle fetched"
+                                 :team-id (dm/str team-id)
+                                 :file-id (dm/str file-id))
+
                       (rx/of (dpj/initialize-project (:project-id file))
                              (dwn/initialize team-id file-id)
                              (dwsl/initialize-shape-layout)

frontend/src/app/main/data/workspace/drawing/common.cljs

@@ -83,7 +83,7 @@
               (rx/of (dwsh/add-shape shape {:no-select? (= tool :curve)}))
               (if (cfh/frame-shape? shape)
                 (rx/concat
-                 (->> (mw/ask! {:cmd :selection/query
+                 (->> (mw/ask! {:cmd :index/query-selection
                                 :page-id page-id
                                 :rect (:selrect shape)
                                 :include-frames? true

frontend/src/app/main/data/workspace/pages.cljs

@@ -15,6 +15,7 @@
    [app.common.types.components-list :as ctkl]
    [app.common.types.container :as ctn]
    [app.common.types.page :as ctp]
+   [app.common.types.shape-tree :as ctst]
    [app.common.uuid :as uuid]
    [app.config :as cf]
    [app.main.data.changes :as dch]
@@ -29,6 +30,7 @@
    [app.main.errors]
    [app.main.features :as features]
    [app.main.router :as rt]
+   [app.main.worker :as mw]
    [app.render-wasm.shape :as wasm.shape]
    [app.util.http :as http]
    [app.util.i18n :as i18n :refer [tr]]
@@ -56,16 +58,21 @@
                   (some? metadata)   (cf/resolve-file-media metadata)
                   (some? fill-image) (cf/resolve-file-media fill-image))))))
 
+(defn- get-page-cache
+  [state file-id page-id]
+  (dm/get-in state [:workspace-cache [file-id page-id]]))
 
 (defn- initialize-page*
   "Second phase of page initialization, once we know the page is
   available in the state"
-  [file-id page-id page]
+  [file-id page-id]
   (ptk/reify ::initialize-page*
     ptk/UpdateEvent
     (update [_ state]
-      ;; selection; when user abandon the current page, the selection is lost
-      (let [local (dm/get-in state [:workspace-cache [file-id page-id]] default-workspace-local)]
+      (let [state (dsh/update-page state file-id page-id #(update % :objects ctst/start-page-index))
+            page  (dsh/lookup-page state file-id page-id)
+            local (or (get-page-cache state file-id page-id) default-workspace-local)]
+
         (-> state
             (assoc :current-page-id page-id)
             (assoc :workspace-local (assoc local :selected (d/ordered-set)))
@@ -75,11 +82,16 @@
             (update :workspace-layout layout/load-layout-flags)
             (update :workspace-global layout/load-layout-state))))
 
-    ptk/EffectEvent
-    (effect [_ _ _]
-      (let [uris  (into #{} xf:collect-file-media (:objects page))]
+    ptk/WatchEvent
+    (watch [_ state _]
+      (let [page (dsh/lookup-page state file-id page-id)
+            uris (into #{} xf:collect-file-media (:objects page))]
+        (rx/merge
          (->> (rx/from uris)
-             (rx/subs! #(http/fetch-data-uri % false)))))))
+              (rx/map #(http/fetch-data-uri % false))
+              (rx/ignore))
+         (->> (mw/ask! {:cmd :index/initialize :page page})
+              (rx/ignore)))))))
 
 (defn initialize-page
   [file-id page-id]
@@ -89,9 +101,9 @@
   (ptk/reify ::initialize-page
     ptk/WatchEvent
     (watch [_ state _]
-      (if-let [page (dsh/lookup-page state file-id page-id)]
+      (if (dsh/lookup-page state file-id page-id)
         (rx/concat
-         (rx/of (initialize-page* file-id page-id page)
+         (rx/of (initialize-page* file-id page-id)
                 (dwth/watch-state-changes file-id page-id)
                 (dwl/watch-component-changes))
          (let [profile (:profile state)

frontend/src/app/main/data/workspace/selection.cljs

@@ -344,7 +344,7 @@
 
          (if (some? selrect)
            (->> (ask-worker
-                 {:cmd :selection/query
+                 {:cmd :index/query-selection
                   :page-id page-id
                   :rect selrect
                   :include-frames? true

frontend/src/app/main/snap.cljs

@@ -84,7 +84,7 @@
   (let [value (get point coord)
         vbox @refs/vbox
         ranges [[(- value (/ 0.5 zoom)) (+ value (/ 0.5 zoom))]]]
-    (->> (mw/ask! {:cmd :snaps/range-query
+    (->> (mw/ask! {:cmd :index/query-snap
                    :page-id page-id
                    :frame-id frame-id
                    :axis coord
@@ -101,7 +101,7 @@
                     (mapv #(vector (- % snap-accuracy)
                                    (+ % snap-accuracy))))
         vbox @refs/vbox]
-    (->> (mw/ask! {:cmd :snaps/range-query
+    (->> (mw/ask! {:cmd :index/query-snap
                    :page-id page-id
                    :frame-id frame-id
                    :axis coord
@@ -217,7 +217,7 @@
 
 (defn select-shapes-area
   [page-id frame-id selected objects area]
-  (->> (mw/ask! {:cmd :selection/query
+  (->> (mw/ask! {:cmd :index/query-selection
                  :page-id page-id
                  :frame-id frame-id
                  :include-frames? true

frontend/src/app/main/ui/workspace/viewport/hooks.cljs

@@ -194,7 +194,7 @@
              (if (mf/ref-val hover-disabled-ref)
                (rx/of nil)
                (->> (mw/ask-buffered!
-                     {:cmd :selection/query
+                     {:cmd :index/query-selection
                       :page-id page-id
                       :rect rect
                       :include-frames? true

frontend/src/app/worker.cljs

@@ -16,8 +16,6 @@
    [app.worker.import]
    [app.worker.index]
    [app.worker.messages :as wm]
-   [app.worker.selection]
-   [app.worker.snaps]
    [app.worker.thumbnails]
    [beicon.v2.core :as rx]
    [promesa.core :as p]))

frontend/src/app/worker/index.cljs

@@ -9,26 +9,69 @@
   (:require
    [app.common.data.macros :as dm]
    [app.common.files.changes :as ch]
+   [app.common.geom.rect :as grc]
+   [app.common.logging :as log]
+   [app.common.time :as ct]
    [app.worker.impl :as impl]
+   [app.worker.selection :as selection]
+   [app.worker.snap :as snap]
    [okulary.core :as l]))
 
+(log/set-level! :info)
+
 (defonce state (l/atom {:pages-index {}}))
 
-(defmethod impl/handler :index/initialize-page-index
+(defmethod impl/handler :index/initialize
   [{:keys [page] :as message}]
+  (let [tpoint (ct/tpoint-ms)]
+    (try
       (swap! state update :pages-index assoc (:id page) page)
-  (impl/handler (assoc message :cmd :selection/initialize-page-index))
-  (impl/handler (assoc message :cmd :snaps/initialize-page-index)))
+      (swap! state update ::selection selection/add-page page)
+      (swap! state update ::snap snap/add-page page)
 
-(defmethod impl/handler :index/update-page-index
+      (finally
+        (let [elapsed (tpoint)]
+          (log/dbg :hint "page indexed" :id (:id page) :elapsed elapsed ::log/sync? true))))
+    nil))
+
+(defmethod impl/handler :index/update
   [{:keys [page-id changes] :as message}]
-
+  (let [tpoint (ct/tpoint-ms)]
+    (try
       (let [old-page (dm/get-in @state [:pages-index page-id])
             new-page (-> state
                          (swap! ch/process-changes changes false)
-                     (dm/get-in [:pages-index page-id]))
-        message (assoc message
-                       :old-page old-page
-                       :new-page new-page)]
-    (impl/handler (assoc message :cmd :selection/update-page-index))
-    (impl/handler (assoc message :cmd :snaps/update-page-index))))
+                         (dm/get-in [:pages-index page-id]))]
+
+        (swap! state update ::snap snap/update-page old-page new-page)
+        (swap! state update ::selection selection/update-page old-page new-page))
+      (finally
+        (let [elapsed (tpoint)]
+          (log/dbg :hint "page index updated" :id page-id :elapsed elapsed ::log/sync? true))))
+    nil))
+
+;; FIXME: schema
+
+(defmethod impl/handler :index/query-snap
+  [{:keys [page-id frame-id axis ranges bounds] :as message}]
+  (if-let [index (get @state ::snap)]
+    (let [match-bounds?
+          (fn [[_ data]]
+            (some #(or (= :guide (:type %))
+                       (= :layout (:type %))
+                       (grc/contains-point? bounds (:pt %))) data))
+
+          xform
+          (comp (mapcat #(snap/query index page-id frame-id axis %))
+                (distinct)
+                (filter match-bounds?))]
+      (into [] xform ranges))
+    []))
+
+;; FIXME: schema
+
+(defmethod impl/handler :index/query-selection
+  [message]
+  (if-let [index (get @state ::selection)]
+    (selection/query index message)
+    []))

frontend/src/app/worker/selection.cljs

@@ -17,20 +17,18 @@
    [app.common.types.modifiers :as ctm]
    [app.common.uuid :as uuid]
    [app.util.quadtree :as qdt]
-   [app.worker.impl :as impl]
-   [clojure.set :as set]
-   [okulary.core :as l]))
+   [clojure.set :as set]))
 
-;; FIXME: performance shape & rect static props
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; IMPL
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 (def ^:const padding-percent 0.10)
 
-(defonce state (l/atom {}))
-
-(defn make-index-shape
-  [objects parents-index clip-parents-index]
-  (fn [index shape]
-    (let [{:keys [x y width height]}
+(defn- index-shape
+  "A reducing function that ads a shape to the index"
+  [objects parents-index clip-index index shape]
+  (let [bounds
         (cond
           (and ^boolean (cfh/text-shape? shape)
                ^boolean (some? (:position-data shape))
@@ -40,23 +38,41 @@
           :else
           (grc/points->rect (:points shape)))
 
-          shape-bound #js {:x x :y y :width width :height height}
+        bound
+        #js {:x (dm/get-prop bounds :x)
+             :y (dm/get-prop bounds :y)
+             :width (dm/get-prop bounds :width)
+             :height (dm/get-prop bounds :height)}
 
-          parents      (get parents-index (:id shape))
-          clip-parents (get clip-parents-index (:id shape))
+        shape-id
+        (dm/get-prop shape :id)
+
+        frame-id
+        (dm/get-prop shape :frame-id)
+
+        shape-type
+        (dm/get-prop shape :type)
+
+        parents
+        (get parents-index shape-id)
+
+        clip-parents
+        (get clip-index shape-id)
+
+        frame
+        (when (and (not= :frame shape-type)
+                   (not= frame-id uuid/zero))
+          (get objects frame-id))]
 
-          frame   (when (and (not= :frame (:type shape))
-                             (not= (:frame-id shape) uuid/zero))
-                    (get objects (:frame-id shape)))]
     (qdt/insert index
-                  (:id shape)
-                  shape-bound
+                shape-id
+                bound
                 (assoc shape
                        :frame frame
                        :clip-parents clip-parents
-                         :parents parents)))))
+                       :parents parents))))
 
-(defn objects-bounds
+(defn- objects-bounds
   "Calculates the bounds of the quadtree given a objects map."
   [objects]
   (-> objects
@@ -64,7 +80,7 @@
       vals
       gsh/shapes->rect))
 
-(defn add-padding-bounds
+(defn- add-padding-bounds
   "Adds a padding to the bounds defined as a percent in the constant `padding-percent`.
   For a value of 0.1 will add a 20% width increase (2 x padding)"
   [bounds]
@@ -81,41 +97,48 @@
 
 (defn- create-index
   [objects]
-  (let [shapes             (-> objects (dissoc uuid/zero) vals)
-        parents-index      (cfi/generate-child-all-parents-index objects)
-        clip-parents-index (cfi/create-clip-index objects parents-index)
-
+  (let [parents-index (cfi/generate-child-all-parents-index objects)
+        clip-index    (cfi/create-clip-index objects parents-index)
         root-shapes   (cfh/get-immediate-children objects uuid/zero)
         bounds        (-> root-shapes gsh/shapes->rect add-padding-bounds)
 
-        index-shape        (make-index-shape objects parents-index clip-parents-index)
-        initial-quadtree   (qdt/create (clj->js bounds))
-
-        index              (reduce index-shape initial-quadtree shapes)]
-
+        index         (reduce-kv #(index-shape objects parents-index clip-index %1 %3)
+                                 (qdt/create (clj->js bounds))
+                                 (dissoc objects uuid/zero))]
     {:index index :bounds bounds}))
 
+;; FIXME: optimize
 (defn- update-index
   [{index :index :as data} old-objects new-objects]
-  (let [changes? (fn [id]
+  (let [object-changed?
+        (fn [id]
           (not= (get old-objects id)
                 (get new-objects id)))
 
-        changed-ids (into #{}
+        changed-ids
+        (into #{}
               (comp (filter #(not= % uuid/zero))
-                                (filter changes?)
+                    (filter object-changed?)
                     (mapcat #(into [%] (cfh/get-children-ids new-objects %))))
+
               (set/union (set (keys old-objects))
                          (set (keys new-objects))))
 
-        shapes             (->> changed-ids (mapv #(get new-objects %)) (filterv (comp not nil?)))
-        parents-index      (cfi/generate-child-all-parents-index new-objects shapes)
-        clip-parents-index (cfi/create-clip-index new-objects parents-index)
+        shapes
+        (->> changed-ids
+             (map #(get new-objects %))
+             (filterv (comp not nil?)))
 
-        new-index (qdt/remove-all index changed-ids)
+        parents-index
+        (cfi/generate-child-all-parents-index new-objects shapes)
 
-        index-shape (make-index-shape new-objects parents-index clip-parents-index)
-        index (reduce index-shape new-index shapes)]
+        clip-index
+        (cfi/create-clip-index new-objects parents-index)
+
+        index
+        (reduce #(index-shape new-objects parents-index clip-index %1 %2)
+                (qdt/remove-all index changed-ids)
+                shapes)]
 
     (assoc data :index index)))
 
@@ -231,17 +254,20 @@
                 (map :id))
           result)))
 
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;; PUBLIC API
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
-(defmethod impl/handler :selection/initialize-page-index
-  [{:keys [page] :as message}]
-  (letfn [(add-page [state {:keys [id objects] :as page}]
-            (assoc state id (create-index objects)))]
-    (swap! state add-page page)
-    nil))
+(defn add-page
+  "Add a page index to the state"
+  [state {:keys [id objects] :as page}]
+  (assoc state id (create-index objects)))
 
-(defmethod impl/handler :selection/update-page-index
-  [{:keys [page-id old-page new-page] :as message}]
-  (swap! state update page-id
+(defn update-page
+  "Update page index on the state"
+  [state old-page new-page]
+  (let [page-id (get old-page :id)]
+    (update state page-id
             (fn [index]
               (let [old-objects (:objects old-page)
                     new-objects (:objects new-page)
@@ -254,12 +280,10 @@
                 (if (and (some? index)
                          (grc/contains-rect? old-bounds new-bounds))
                   (update-index index old-objects new-objects)
-               (create-index new-objects)))))
-  nil)
+                  (create-index new-objects)))))))
 
-(defmethod impl/handler :selection/query
-  [{:keys [page-id rect frame-id full-frame? include-frames? ignore-groups? clip-children? using-selrect?]
-    :or {full-frame? false include-frames? false clip-children? true using-selrect? false}
-    :as message}]
-  (when-let [index (get @state page-id)]
+(defn query
+  [index {:keys [page-id rect frame-id full-frame? include-frames? ignore-groups? clip-children? using-selrect?]
+          :or {full-frame? false include-frames? false clip-children? true using-selrect? false}}]
+  (when-let [index (get index page-id)]
     (query-index index rect frame-id full-frame? include-frames? ignore-groups? clip-children? using-selrect?)))

frontend/src/app/worker/snap.cljs

@@ -4,7 +4,7 @@
 ;;
 ;; Copyright (c) KALEIDOS INC
 
-(ns app.util.snap-data
+(ns app.worker.snap
   "Data structure that holds and retrieves the data to make the snaps.
    Internally is implemented with a balanced binary tree that queries by range.
    https://en.wikipedia.org/wiki/Range_tree"

frontend/src/app/worker/snaps.cljs

@@ -1,40 +0,0 @@
-;; This Source Code Form is subject to the terms of the Mozilla Public
-;; License, v. 2.0. If a copy of the MPL was not distributed with this
-;; file, You can obtain one at http://mozilla.org/MPL/2.0/.
-;;
-;; Copyright (c) KALEIDOS INC
-
-(ns app.worker.snaps
-  (:require
-   [app.common.geom.rect :as grc]
-   [app.util.snap-data :as sd]
-   [app.worker.impl :as impl]
-   [okulary.core :as l]))
-
-(defonce state (l/atom {}))
-
-;; Public API
-(defmethod impl/handler :snaps/initialize-page-index
-  [{:keys [page] :as message}]
-  (swap! state sd/add-page page)
-  nil)
-
-(defmethod impl/handler :snaps/update-page-index
-  [{:keys [old-page new-page] :as message}]
-  (swap! state sd/update-page old-page new-page)
-  nil)
-
-(defmethod impl/handler :snaps/range-query
-  [{:keys [page-id frame-id axis ranges bounds] :as message}]
-  (let [match-bounds?
-        (fn [[_ data]]
-          (some #(or (= :guide (:type %))
-                     (= :layout (:type %))
-                     (grc/contains-point? bounds (:pt %))) data))]
-    (->> (into []
-               (comp (mapcat #(sd/query @state page-id frame-id axis %))
-                     (distinct))
-               ranges)
-         (filter match-bounds?))))
-
-

frontend/test/frontend_tests/runner.cljs

@@ -18,7 +18,7 @@
    [frontend-tests.tokens.token-form-test]
    [frontend-tests.util-range-tree-test]
    [frontend-tests.util-simple-math-test]
-   [frontend-tests.util-snap-data-test]))
+   [frontend-tests.worker-snap-test]))
 
 (enable-console-print!)
 
@@ -30,6 +30,8 @@
 (defn init
   []
   (t/run-tests
+   'frontend-tests.basic-shapes-test
+   'frontend-tests.data.workspace-colors-test
    'frontend-tests.helpers-shapes-test
    'frontend-tests.logic.comp-remove-swap-slots-test
    'frontend-tests.logic.components-and-tokens
@@ -38,13 +40,11 @@
    'frontend-tests.logic.groups-test
    'frontend-tests.logic.pasting-in-containers-test
    'frontend-tests.plugins.context-shapes-test
-   'frontend-tests.util-range-tree-test
-   'frontend-tests.util-snap-data-test
-   'frontend-tests.util-simple-math-test
-   'frontend-tests.basic-shapes-test
-   'frontend-tests.data.workspace-colors-test
+   'frontend-tests.tokens.import-export-test
    'frontend-tests.tokens.logic.token-actions-test
    'frontend-tests.tokens.logic.token-data-test
-   'frontend-tests.tokens.import-export-test
    'frontend-tests.tokens.style-dictionary-test
-   'frontend-tests.tokens.token-form-test))
+   'frontend-tests.tokens.token-form-test
+   'frontend-tests.util-range-tree-test
+   'frontend-tests.util-simple-math-test
+   'frontend-tests.worker-snap-test))

frontend/test/frontend_tests/worker_snap_test.cljs

@@ -4,12 +4,12 @@
 ;;
 ;; Copyright (c) KALEIDOS INC
 
-(ns frontend-tests.util-snap-data-test
+(ns frontend-tests.worker-snap-test
   (:require
    [app.common.files.builder :as fb]
    [app.common.types.shape :as cts]
    [app.common.uuid :as uuid]
-   [app.util.snap-data :as sd]
+   [app.worker.snap :as snap]
    [cljs.pprint :refer [pprint]]
    [cljs.test :as t :include-macros true]))
 
@@ -21,9 +21,9 @@
     (fn []
       (uuid/custom 123456789 (swap! counter inc)))))
 
-(t/deftest test-create-index
+(t/deftest create-index
   (t/testing "Create empty data"
-    (let [data (sd/make-snap-data)]
+    (let [data (snap/make-snap-data)]
       (t/is (some? data))))
 
   (t/testing "Add empty page (only root-frame)"
@@ -32,8 +32,8 @@
                    (fb/add-page {:name "Page 1"})
                    (fb/get-current-page))
 
-          data (-> (sd/make-snap-data)
-                   (sd/add-page page))]
+          data (-> (snap/make-snap-data)
+                   (snap/add-page page))]
       (t/is (some? data))))
 
   (t/testing "Create simple shape on root"
@@ -48,10 +48,10 @@
                       :height 100}))
           page  (fb/get-current-page state)
 
-          data  (-> (sd/make-snap-data)
-                    (sd/add-page page))
+          data  (-> (snap/make-snap-data)
+                    (snap/add-page page))
 
-          result-x (sd/query data (:id page) uuid/zero :x [0 100])]
+          result-x (snap/query data (:id page) uuid/zero :x [0 100])]
 
       (t/is (some? data))
 
@@ -82,11 +82,11 @@
           page     (fb/get-current-page state)
 
           ;; frame-id (::fb/last-id file)
-          data (-> (sd/make-snap-data)
-                   (sd/add-page page))
+          data (-> (snap/make-snap-data)
+                   (snap/add-page page))
 
-          result-zero-x (sd/query data (:id page) uuid/zero :x [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])]
+          result-zero-x (snap/query data (:id page) uuid/zero :x [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])]
 
       (t/is (some? data))
       (t/is (= (count result-zero-x) 3))
@@ -116,11 +116,11 @@
 
             page     (fb/get-current-page state)
 
-            data (-> (sd/make-snap-data)
-                     (sd/add-page page))
+            data (-> (snap/make-snap-data)
+                     (snap/add-page page))
 
-            result-zero-x (sd/query data (:id page) uuid/zero :x [0 100])
-            result-frame-x (sd/query data (:id page) frame-id :x [0 100])]
+            result-zero-x (snap/query data (:id page) uuid/zero :x [0 100])
+            result-frame-x (snap/query data (:id page) frame-id :x [0 100])]
 
         (t/is (some? data))
         (t/is (= (count result-zero-x) 3))
@@ -137,13 +137,13 @@
           frame-id (::fb/last-id state)
           page     (fb/get-current-page state)
 
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
-          result-zero-x  (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-y  (sd/query data (:id page) uuid/zero :y [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])
-          result-frame-y (sd/query data (:id page) frame-id :y [0 100])]
+          result-zero-x  (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-y  (snap/query data (:id page) uuid/zero :y [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])
+          result-frame-y (snap/query data (:id page) frame-id :y [0 100])]
 
       (t/is (some? data))
       ;; We can snap in the root
@@ -168,13 +168,13 @@
 
           page     (fb/get-current-page state)
 
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
-          result-zero-x (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-y (sd/query data (:id page) uuid/zero :y [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])
-          result-frame-y (sd/query data (:id page) frame-id :y [0 100])]
+          result-zero-x (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-y (snap/query data (:id page) uuid/zero :y [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])
+          result-frame-y (snap/query data (:id page) frame-id :y [0 100])]
 
       (t/is (some? data))
       ;; We can snap in the root
@@ -185,7 +185,7 @@
       (t/is (= (count result-frame-x) 1))
       (t/is (= (count result-frame-y) 0)))))
 
-(t/deftest test-update-index
+(t/deftest update-index
   (t/testing "Create frame on root and then remove it."
     (let [state   (-> (fb/create-state)
                       (fb/add-file {:name "Test"})
@@ -200,17 +200,17 @@
           shape-id (::fb/last-id state)
           page     (fb/get-current-page state)
 
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
           state     (-> state
                         (fb/delete-shape shape-id))
 
           new-page (fb/get-current-page state)
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-x (sd/query data (:id page) uuid/zero :x [0 100])
-          result-y (sd/query data (:id page) uuid/zero :y [0 100])]
+          result-x (snap/query data (:id page) uuid/zero :x [0 100])
+          result-y (snap/query data (:id page) uuid/zero :y [0 100])]
 
       (t/is (some? data))
       (t/is (= (count result-x) 0))
@@ -231,16 +231,16 @@
           page     (fb/get-current-page state)
 
           ;; frame-id (::fb/last-id state)
-          data (-> (sd/make-snap-data)
-                   (sd/add-page page))
+          data (-> (snap/make-snap-data)
+                   (snap/add-page page))
 
           state (fb/delete-shape state shape-id)
 
           new-page (fb/get-current-page state)
-          data (sd/update-page data page new-page)
+          data (snap/update-page data page new-page)
 
-          result-x (sd/query data (:id page) uuid/zero :x [0 100])
-          result-y (sd/query data (:id page) uuid/zero :y [0 100])]
+          result-x (snap/query data (:id page) uuid/zero :x [0 100])
+          result-y (snap/query data (:id page) uuid/zero :y [0 100])]
 
       (t/is (some? data))
       (t/is (= (count result-x) 0))
@@ -263,16 +263,16 @@
           state    (fb/close-board state)
 
           page     (fb/get-current-page state)
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
           state    (fb/delete-shape state shape-id)
           new-page (fb/get-current-page state)
 
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-zero-x  (sd/query data (:id page) uuid/zero :x [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])]
+          result-zero-x  (snap/query data (:id page) uuid/zero :x [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])]
 
       (t/is (some? data))
       (t/is (= (count result-zero-x) 3))
@@ -291,18 +291,18 @@
 
           frame-id (::fb/last-id state)
           page     (fb/get-current-page state)
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
           new-page (-> (fb/delete-guide state guide-id)
                        (fb/get-current-page))
 
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-zero-x  (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-y  (sd/query data (:id page) uuid/zero :y [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])
-          result-frame-y (sd/query data (:id page) frame-id :y [0 100])]
+          result-zero-x  (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-y  (snap/query data (:id page) uuid/zero :y [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])
+          result-frame-y (snap/query data (:id page) frame-id :y [0 100])]
 
       (t/is (some? data))
       ;; We can snap in the root
@@ -325,17 +325,17 @@
           guide-id (::fb/last-id file)
 
           page     (fb/get-current-page file)
-          data (-> (sd/make-snap-data) (sd/add-page page))
+          data (-> (snap/make-snap-data) (snap/add-page page))
 
           new-page (-> (fb/delete-guide file guide-id)
                        (fb/get-current-page))
 
-          data (sd/update-page data page new-page)
+          data (snap/update-page data page new-page)
 
-          result-zero-x (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-y (sd/query data (:id page) uuid/zero :y [0 100])
-          result-frame-x (sd/query data (:id page) frame-id :x [0 100])
-          result-frame-y (sd/query data (:id page) frame-id :y [0 100])]
+          result-zero-x (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-y (snap/query data (:id page) uuid/zero :y [0 100])
+          result-frame-x (snap/query data (:id page) frame-id :x [0 100])
+          result-frame-y (snap/query data (:id page) frame-id :y [0 100])]
       (t/is (some? data))
       ;; We can snap in the root
       (t/is (= (count result-zero-x) 0))
@@ -358,8 +358,8 @@
 
           frame-id (::fb/last-id state)
           page     (fb/get-current-page state)
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
           state    (fb/update-shape state frame-id
                                     (fn [shape]
@@ -370,12 +370,12 @@
 
 
           new-page (fb/get-current-page state)
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-zero-x-1 (sd/query data (:id page) uuid/zero :x [0 100])
-          result-frame-x-1 (sd/query data (:id page) frame-id :x [0 100])
-          result-zero-x-2 (sd/query data (:id page) uuid/zero :x [200 300])
-          result-frame-x-2 (sd/query data (:id page) frame-id :x [200 300])]
+          result-zero-x-1 (snap/query data (:id page) uuid/zero :x [0 100])
+          result-frame-x-1 (snap/query data (:id page) frame-id :x [0 100])
+          result-zero-x-2 (snap/query data (:id page) uuid/zero :x [200 300])
+          result-frame-x-2 (snap/query data (:id page) frame-id :x [200 300])]
 
       (t/is (some? data))
       (t/is (= (count result-zero-x-1) 0))
@@ -396,8 +396,8 @@
 
           shape-id (::fb/last-id state)
           page     (fb/get-current-page state)
-          data     (-> (sd/make-snap-data)
-                       (sd/add-page page))
+          data     (-> (snap/make-snap-data)
+                       (snap/add-page page))
 
           state     (fb/update-shape state shape-id
                                      (fn [shape]
@@ -408,10 +408,10 @@
 
           new-page (fb/get-current-page state)
           ;; FIXME: update
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-zero-x-1 (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-x-2 (sd/query data (:id page) uuid/zero :x [200 300])]
+          result-zero-x-1 (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-x-2 (snap/query data (:id page) uuid/zero :x [200 300])]
 
       (t/is (some? data))
       (t/is (= (count result-zero-x-1) 0))
@@ -432,22 +432,22 @@
 
           frame-id (::fb/last-id state)
           page     (fb/get-current-page state)
-          data     (-> (sd/make-snap-data) (sd/add-page page))
+          data     (-> (snap/make-snap-data) (snap/add-page page))
 
           new-page (-> (fb/update-guide state (assoc guide :position 150))
                        (fb/get-current-page))
 
-          data     (sd/update-page data page new-page)
+          data     (snap/update-page data page new-page)
 
-          result-zero-x-1 (sd/query data (:id page) uuid/zero :x [0 100])
-          result-zero-y-1 (sd/query data (:id page) uuid/zero :y [0 100])
-          result-frame-x-1 (sd/query data (:id page) frame-id :x [0 100])
-          result-frame-y-1 (sd/query data (:id page) frame-id :y [0 100])
+          result-zero-x-1 (snap/query data (:id page) uuid/zero :x [0 100])
+          result-zero-y-1 (snap/query data (:id page) uuid/zero :y [0 100])
+          result-frame-x-1 (snap/query data (:id page) frame-id :x [0 100])
+          result-frame-y-1 (snap/query data (:id page) frame-id :y [0 100])
 
-          result-zero-x-2 (sd/query data (:id page) uuid/zero :x [0 200])
-          result-zero-y-2 (sd/query data (:id page) uuid/zero :y [0 200])
-          result-frame-x-2 (sd/query data (:id page) frame-id :x [0 200])
-          result-frame-y-2 (sd/query data (:id page) frame-id :y [0 200])]
+          result-zero-x-2 (snap/query data (:id page) uuid/zero :x [0 200])
+          result-zero-y-2 (snap/query data (:id page) uuid/zero :y [0 200])
+          result-frame-x-2 (snap/query data (:id page) frame-id :x [0 200])
+          result-frame-y-2 (snap/query data (:id page) frame-id :y [0 200])]
 
       (t/is (some? data))