diff --git a/common/src/app/common/geom/shapes/text.cljc b/common/src/app/common/geom/shapes/text.cljc index 1507621e6d..6f1bad5a8d 100644 --- a/common/src/app/common/geom/shapes/text.cljc +++ b/common/src/app/common/geom/shapes/text.cljc @@ -9,7 +9,23 @@ [app.common.data.macros :as dm] [app.common.geom.rect :as grc] [app.common.geom.shapes.common :as gco] - [app.common.geom.shapes.transforms :as gtr])) + [app.common.geom.shapes.transforms :as gtr] + [app.common.math :as mth] + [app.common.types.shape.layout :as ctl])) + +(defn text-size-drifted? + "True when a measured auto-grow size is off the stored one by more than + `tolerance` on an axis that grows (width for :auto-width, height for both + auto-grow types). An axis that fills its layout parent takes its size + from the layout, so it never drifts. Other grow types never drift." + [{:keys [grow-type width height] :as shape} new-width new-height tolerance] + (boolean + (or (and (= :auto-width grow-type) + (not (ctl/fill-width? shape)) + (not (mth/close? width new-width tolerance))) + (and (contains? #{:auto-width :auto-height} grow-type) + (not (ctl/fill-height? shape)) + (not (mth/close? height new-height tolerance)))))) (defn position-data->rect [{:keys [x y width height]}] diff --git a/common/test/common_tests/geom_shapes_text_test.cljc b/common/test/common_tests/geom_shapes_text_test.cljc index 7c1eef6bf3..7e768d13e1 100644 --- a/common/test/common_tests/geom_shapes_text_test.cljc +++ b/common/test/common_tests/geom_shapes_text_test.cljc @@ -74,3 +74,41 @@ shape {:points shape-points} pd [{:x 200 :y 200 :width 20 :height 10}]] (t/is (false? (gte/overlaps-position-data? shape pd)))))) + +(t/deftest text-size-drifted-ignores-sub-pixel-gaps + (t/is (not (gte/text-size-drifted? {:grow-type :auto-width :width 100 :height 17} 100.5 17.5 1))) + (t/is (not (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 17.5 1)))) + +(t/deftest text-size-drifted-checks-only-the-growing-axis + (t/is (not (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 140 17 1)) + "auto-height width comes from the box, not the text") + (t/is (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 34 1)) + (t/is (gte/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 67 17 1)) + (t/is (gte/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 44 34 1) + "auto-width grows in height too")) + +(t/deftest text-size-drifted-treats-exactly-the-tolerance-as-rounding + (t/is (not (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 18 1)) + "a 1px height gap is rounding at a 1px tolerance") + (t/is (not (gte/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 45 17 1)) + "a 1px width gap is rounding at a 1px tolerance") + (t/is (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 17.5 0.1) + "a finer tolerance catches a sub-pixel gap")) + +(t/deftest text-size-drifted-ignores-an-axis-that-fills-its-parent + (t/is (not (gte/text-size-drifted? {:grow-type :auto-height :width 100 :height 40 + :layout-item-v-sizing :fill} + 100 17 1)) + "a height set by the layout is not drift") + (t/is (not (gte/text-size-drifted? {:grow-type :auto-width :width 200 :height 17 + :layout-item-h-sizing :fill} + 44 17 1)) + "a width set by the layout is not drift") + (t/is (gte/text-size-drifted? {:grow-type :auto-width :width 200 :height 17 + :layout-item-h-sizing :fill} + 44 34 1) + "the axis that does not fill is still checked")) + +(t/deftest text-size-drifted-ignores-other-grow-types + (t/is (not (gte/text-size-drifted? {:grow-type :fixed :width 100 :height 17} 300 90 1))) + (t/is (not (gte/text-size-drifted? {:width 100 :height 17} 300 90 1)))) diff --git a/common/test/common_tests/logic/text_sync_test.cljc b/common/test/common_tests/logic/text_sync_test.cljc index e08a6e0610..b5f770db4a 100644 --- a/common/test/common_tests/logic/text_sync_test.cljc +++ b/common/test/common_tests/logic/text_sync_test.cljc @@ -882,7 +882,7 @@ (t/deftest sync-text-override-with-geometry-touched-keeps-width ;; Documents the #12721 gap: text+geometry touched receives font-size from - ;; main but keeps local width until frontend remasure. + ;; main but keeps local width until frontend re-measure. (let [;; ==== Setup file0 (-> (thf/sample-file :file1) (tho/add-frame-with-text :main-root :main-child "hello world") diff --git a/frontend/src/app/main/data/workspace/libraries.cljs b/frontend/src/app/main/data/workspace/libraries.cljs index 6967c57842..e8d1fbe908 100644 --- a/frontend/src/app/main/data/workspace/libraries.cljs +++ b/frontend/src/app/main/data/workspace/libraries.cljs @@ -1254,10 +1254,20 @@ (without-fills val)))))) operations))) +(defn- grow-type-after + "Grow type of text `shape` once `change` is applied." + [shape {:keys [operations]}] + (or (->> operations + (filter #(and (= :set (:type %)) (= :grow-type (:attr %)))) + (last) + :val) + (:grow-type shape))) + (defn- sync-auto-grow-text-ids-on-page - "Auto-grow text ids from sync redo-changes on `page-id` that can change - the text size, resolved against pre-commit `objects`. Off-page, non-text - and :fixed ids are excluded." + "Text ids from sync redo-changes on `page-id` that are auto-grow once the + change is applied and whose size the change can alter. Shapes come from + pre-commit `objects`; the grow type comes from the change when it sets + one. Off-page, non-text and ids :fixed after the change are excluded." [changes page-id objects] (into [] (comp @@ -1265,7 +1275,7 @@ (filter (fn [{:keys [id] :as change}] (when-let [shape (get objects id)] (and (cfh/text-shape? shape) - (not= :fixed (:grow-type shape)) + (not= :fixed (grow-type-after shape change)) (text-size-change? shape change))))) (map :id) (distinct)) @@ -1281,47 +1291,54 @@ (dissoc state :updating-library))))) (defn- sync-file-frontend-events - "Commit sync changes, schedule current-page auto-grow text remasure, then - layout. Remasure heals box size only; it does not clear a stale - :geometry-group flag. Keep per-page updated-frames layout and - thumbnail clears." + "Commit sync changes, schedule current-page auto-grow text re-measure, then + layout. Re-measure heals box size only; it does not clear a stale + :geometry-group flag. The re-measure commit carries + :skip-component-sync? so it does not start another sync; the resize + itself never marks :geometry-group (it uses :ignore-touched). Keep + per-page updated-frames layout and thumbnail clears. + An auto-grow text copy takes the main's width and height on each + geometry sync, also when its content is overridden: its size is derived, + not an override. The re-measure corrects it on the current page, and the + page-open check on other pages. Until then the viewer, exports and + thumbnails show the main's box." [file-id changes updated-frames undo-group current-page-id objects wasm?] - (let [remasure-ids (when (and wasm? (some? current-page-id)) - (sync-auto-grow-text-ids-on-page changes current-page-id objects)) + (let [remeasure-ids (when (and wasm? (some? current-page-id)) + (sync-auto-grow-text-ids-on-page changes current-page-id objects)) frames-by-page (group-by :page-id updated-frames) - ;; Remasure-only layout when the current page has texts to heal but + ;; Re-measure-only layout when the current page has texts to heal but ;; no synced frames entry (covers empty updated-frames too). - remasure-only-layout? (and (seq remasure-ids) - (nil? (get frames-by-page current-page-id)))] + remeasure-only-layout? (and (seq remeasure-ids) + (nil? (get frames-by-page current-page-id)))] (rx/concat (rx/of (set-updating-library false) (ntf/hide {:tag :sync-dialog})) (when (seq (:redo-changes changes)) (rx/of (dch/commit-changes changes))) - ;; Schedule remasure before layout (swap pattern: debounce ~40ms vs + ;; Schedule re-measure before layout (swap pattern: debounce ~40ms vs ;; layout buffer ~100ms). - (when (seq remasure-ids) - (rx/of (dwwt/resize-wasm-text-all remasure-ids + (when (seq remeasure-ids) + (rx/of (dwwt/resize-wasm-text-all remeasure-ids {:skip-component-sync? true :undo-group undo-group}))) (rx/merge - ;; Per-page layout for synced frames; merge remasure ids into the - ;; current page so hug sees the post-remasure box. + ;; Per-page layout for synced frames; merge re-measure ids into the + ;; current page so hug sees the post-re-measure box. (->> frames-by-page (map (fn [[page-id frames]] (let [ids (cond-> (mapv :id frames) (and (= page-id current-page-id) - (seq remasure-ids)) - (into remasure-ids))] + (seq remeasure-ids)) + (into remeasure-ids))] (ptk/data-event :layout/update {:page-id page-id :ids ids :undo-group undo-group})))) (rx/from)) - (when remasure-only-layout? + (when remeasure-only-layout? (rx/of (ptk/data-event :layout/update {:page-id current-page-id - :ids remasure-ids + :ids remeasure-ids :undo-group undo-group}))) (->> (rx/from updated-frames) (rx/mapcat @@ -1389,13 +1406,24 @@ ptk/WatchEvent (watch [it state stream] (when (and (some? file-id) (some? library-id)) ; Prevent race conditions while navigating out of the file - (log/info :msg "SYNC-FILE" - :file (debug-pretty-file file-id state) - :library (debug-pretty-file library-id state) - :asset-type asset-type - :asset-id asset-id - :undo-group undo-group) - (let [ldata (dsh/lookup-file-data state file-id) + (let [tx (dm/get-in state [:workspace-undo :transaction]) + ;; The sync commit and its text re-measure share one undo + ;; group. The layout pass does not get it (the layout + ;; buffer drops `:undo-group`); it joins the same undo + ;; entry because it commits with `:stack-undo? true`. + ;; Inside an undo transaction (color and typography edits) + ;; the group is the transaction's, so the edit and its sync + ;; undo and roll back together + undo-group (or undo-group (:undo-group tx) (:commit-group tx) (uuid/next)) + + _ (log/info :msg "SYNC-FILE" + :file (debug-pretty-file file-id state) + :library (debug-pretty-file library-id state) + :asset-type asset-type + :asset-id asset-id + :undo-group undo-group) + + ldata (dsh/lookup-file-data state file-id) libraries (dsh/lookup-libraries state) current-file-id (:current-file-id state) diff --git a/frontend/src/app/main/data/workspace/shape_layout.cljs b/frontend/src/app/main/data/workspace/shape_layout.cljs index 5c212cd7c1..9cfe1846f8 100644 --- a/frontend/src/app/main/data/workspace/shape_layout.cljs +++ b/frontend/src/app/main/data/workspace/shape_layout.cljs @@ -101,7 +101,7 @@ ;; Never call this directly but through the data-event `:layout/update` ;; Otherwise a lot of cycle dependencies could be generated (defn- update-layout-positions - [{:keys [page-id ids undo-group reflow-tasks save-undo?]}] + [{:keys [page-id ids undo-group reflow-tasks save-undo? skip-component-sync?]}] (ptk/reify ::update-layout-positions ptk/WatchEvent (watch [_ state stream] @@ -118,12 +118,14 @@ (rx/of (dwm/apply-wasm-modifiers modif-tree :stack-undo? true :save-undo? save-undo? + :skip-component-sync? skip-component-sync? :undo-group undo-group :ignore-touched true)) (rx/of (dwm/apply-modifiers {:page-id page-id :modifiers modif-tree :stack-undo? true :save-undo? save-undo? + :skip-component-sync? skip-component-sync? :ignore-touched true :undo-group undo-group})))) (rx/empty)) @@ -172,14 +174,20 @@ (rx/filter #(d/not-empty? %)) (rx/mapcat (fn [updates] - ;; Updates flagged `:save-undo? false` (automatic text size - ;; heals) are laid out apart, so their reflow records no undo. - (->> (group-by (juxt :page-id #(not (false? (:save-undo? %)))) updates) - (map (fn [[[page-id save-undo?] updates]] + ;; Updates flagged `:save-undo? false` and + ;; `:skip-component-sync?` (automatic text size heals) are + ;; laid out apart, so their reflow records no undo and does + ;; not change components. + (->> (group-by (juxt :page-id + #(not (false? (:save-undo? %))) + #(boolean (:skip-component-sync? %))) + updates) + (map (fn [[[page-id save-undo? skip-component-sync?] updates]] (let [ids (into #{} (mapcat :ids) updates)] (update-layout-positions {:page-id page-id :ids ids :save-undo? save-undo? + :skip-component-sync? skip-component-sync? :reflow-tasks (mapv ::reflow-task updates)}))))))) (rx/take-until stopper) ;; On workspace teardown clear everything still pending. diff --git a/frontend/src/app/main/data/workspace/texts.cljs b/frontend/src/app/main/data/workspace/texts.cljs index 2cd51138e9..5d1f0bc049 100644 --- a/frontend/src/app/main/data/workspace/texts.cljs +++ b/frontend/src/app/main/data/workspace/texts.cljs @@ -813,19 +813,6 @@ (defn not-changed? [old-dim new-dim] (> (mth/abs (- old-dim new-dim)) 0.1)) -(defn text-size-drifted? - "True when a measured auto-grow size is more than 1px off the stored one on - the axis that grows (width for :auto-width, height for both). Gaps up to - 1px come from rounding differences between renderers and browsers. An - axis that fills its layout parent takes its size from the layout, so it - never drifts." - [{:keys [grow-type width height] :as shape} new-width new-height] - (or (and (= :auto-width grow-type) - (not (ctl/fill-width? shape)) - (> (mth/abs (- width new-width)) 1)) - (and (not (ctl/fill-height? shape)) - (> (mth/abs (- height new-height)) 1)))) - (defn commit-resize-text [] (ptk/reify ::commit-resize-text @@ -886,7 +873,9 @@ (rx/empty)) (rx/of (ptk/data-event :layout/update {:ids ids})) (if (seq heal-ids) - (rx/of (ptk/data-event :layout/update {:ids heal-ids :save-undo? false})) + (rx/of (ptk/data-event :layout/update {:ids heal-ids + :save-undo? false + :skip-component-sync? true})) (rx/empty)) (rx/of (dwu/commit-undo-transaction undo-id))))))))) diff --git a/frontend/src/app/main/data/workspace/wasm_text.cljs b/frontend/src/app/main/data/workspace/wasm_text.cljs index 76f9551f8a..aa6adefaac 100644 --- a/frontend/src/app/main/data/workspace/wasm_text.cljs +++ b/frontend/src/app/main/data/workspace/wasm_text.cljs @@ -104,15 +104,16 @@ (defn- merge-resize-debounce-opts "Merge the options of a request into its batch. The batch records no undo - step only when every request in it asked for that, so a user resize that - lands in the same window keeps its undo entry." + step, or skips the component sync, only when every request in it asked + for that, so a user resize that lands in the same window keeps its undo + entry and still reaches the copies." [prev {:keys [undo-group undo-id skip-component-sync? save-undo?]}] - (-> (cond-> (or prev {}) - (some? undo-group) (assoc :undo-group undo-group) - (some? undo-id) (assoc :undo-id undo-id) - skip-component-sync? (assoc :skip-component-sync? true)) - (assoc :save-undo? (or (:save-undo? prev false) - (not (false? save-undo?)))))) + (let [prev (or prev {:skip-component-sync? true :save-undo? false})] + (cond-> (assoc prev + :skip-component-sync? (and (:skip-component-sync? prev) (boolean skip-component-sync?)) + :save-undo? (or (:save-undo? prev) (not (false? save-undo?)))) + (some? undo-group) (assoc :undo-group undo-group) + (some? undo-id) (assoc :undo-id undo-id)))) (defn resize-wasm-text-debounce-commit [] @@ -210,7 +211,7 @@ (defn resize-wasm-text-debounce ([id] (resize-wasm-text-debounce id nil)) - ([id {:keys [undo-group undo-id skip-component-sync? save-undo?] :as opts}] + ([id opts] (ptk/reify ::resize-wasm-text-debounce ptk/WatchEvent (watch [_ state _] @@ -228,14 +229,8 @@ resize-wasm-stream (if fonts-ready? - (let [pass-opts (when (or (some? undo-group) (some? undo-id) skip-component-sync? - (false? save-undo?)) - (cond-> {} - (some? undo-group) (assoc :undo-group undo-group) - (some? undo-id) (assoc :undo-id undo-id) - skip-component-sync? (assoc :skip-component-sync? true) - (false? save-undo?) (assoc :save-undo? false)))] - (rx/of (resize-wasm-text-debounce-inner id pass-opts))) + ;; `merge-resize-debounce-opts` reads only the keys it knows. + (rx/of (resize-wasm-text-debounce-inner id opts)) ;; Fonts not loaded; retry after 20 msecs (->> (rx/of (resize-wasm-text-debounce id opts)) diff --git a/frontend/src/app/main/ui/workspace/shapes/text/viewport_texts_html.cljs b/frontend/src/app/main/ui/workspace/shapes/text/viewport_texts_html.cljs index 615955fd93..04b150e62d 100644 --- a/frontend/src/app/main/ui/workspace/shapes/text/viewport_texts_html.cljs +++ b/frontend/src/app/main/ui/workspace/shapes/text/viewport_texts_html.cljs @@ -14,6 +14,7 @@ [app.common.geom.shapes.text :as gsht] [app.common.logging :as log] [app.common.math :as mth] + [app.common.types.component :as ctk] [app.common.types.modifiers :as ctm] [app.common.types.text :as txt] [app.common.uuid :as uuid] @@ -92,22 +93,29 @@ (defn- text-heal "How to commit a measured auto-grow text in heal `phase`: nil commits - nothing, otherwise a map with the commit `:opts` and the `:next` heal - phase, if any. - The `:check` phase runs when the page opens. It commits when the size - drifted, so rounding differences between renderers or browsers are not - written back on every open, or when the text has no position-data. A heal - records no undo step. A resize makes the text be measured again at its new - box, in the `:settle` phase, which is part of the heal too. Without a phase - the text is committed as usual." + nothing, otherwise a map with the commit `:opts`, whether to `:resize?` + the text and the `:next` heal phase, if any. + The `:check` phase runs when the page opens. It resizes the text when the + size drifted, so rounding differences between renderers or browsers are + not written back on every open. A text with no position-data that did not + drift gets its position-data only. A heal records no undo step. A resize + makes the text be measured again at its new box, in the `:settle` phase, + which is part of the heal too. Without a phase the text is committed as + usual. + Known limit: the WebGL and SVG renderers can measure the same text + differently. When they differ by more than 1px, each page open by a user + of the other renderer writes the size back. Two browsers on the SVG + renderer can do the same: a long auto-width line can differ by more than + 1px, and an auto-height text can wrap a line differently." [phase shape size] (case phase - :check (let [drifted? (and (some? size) (apply dwt/text-size-drifted? shape size))] + :check (let [drifted? (when-let [[width height] size] + (gsht/text-size-drifted? shape width height 1))] (when (or drifted? (nil? (:position-data shape))) (cond-> {:opts {:save-undo? false}} - drifted? (assoc :next :settle)))) - :settle {:opts {:save-undo? false}} - {})) + drifted? (assoc :resize? true :next :settle)))) + :settle {:opts {:save-undo? false} :resize? true} + {:resize? true})) (defn- update-text-shape "Measure the text and commit its position-data and auto-grow size as @@ -115,7 +123,11 @@ [{:keys [id] :as shape} node phase] (->> (tsp/calc-position-data id) (p/fmap (fn [position-data] - (let [size (measured-auto-size shape node) + (let [;; A page-open check never writes a size laid out + ;; with a fallback font + size (when-not (and (= :check phase) + (tsp/font-failed? position-data)) + (measured-auto-size shape node)) heal (text-heal phase shape size) opts (:opts heal)] (when (some? heal) @@ -123,7 +135,7 @@ (when (gsht/overlaps-position-data? shape position-data) (st/emit! (dwt/update-position-data id position-data opts))) - (when-let [[width height] size] + (when-let [[width height] (and (:resize? heal) size)] (st/emit! (dwt/resize-text id width height opts)))) (st/emit! (dwt/clean-text-modifier id)) @@ -205,15 +217,18 @@ (nil? (:position-data new-shape)) (= :check phase)))) -(defn override-copy-heal-phases - "Auto-grow texts whose content is overridden on a copy, each in the `:check` - heal phase: a component sync can give them the main's size, so they are - measured again when the page opens." +(defn copy-heal-phases + "Auto-grow texts inside a component copy, each in the `:check` heal phase: + a component sync, also one through a nested main, can give them a stale + size, so they are measured again when the page opens. Texts of a main are + never synced. The check runs on every mount of `viewport-texts`: a page + open, a version change, and the end of read-only mode (Inspect, save-lock + release), which unmounts it." [text-shapes] (into {} (comp (map val) (filter (comp #{:auto-width :auto-height} :grow-type)) - (filter #(contains? (:touched %) :content-group)) + (filter ctk/in-component-copy?) (map (fn [{:keys [id]}] [id :check]))) text-shapes)) @@ -229,11 +244,11 @@ pending-update* (mf/use-state {}) pending-update (deref pending-update*) - ;; Heal phase per text id. Copies whose text is overridden start in + ;; Heal phase per text id. Auto-grow texts in copies start in ;; `:check` and are measured on page open: a sync while their page was - ;; closed can give them the main's size. A text in `:settle` waits for + ;; closed can give them a stale size. A text in `:settle` waits for ;; its heal resize to change the shape, which measures it again. - phases* (mf/use-state #(override-copy-heal-phases text-shapes)) + phases* (mf/use-state #(copy-heal-phases text-shapes)) phases (deref phases*) text-change? diff --git a/frontend/src/app/render_wasm/api.cljs b/frontend/src/app/render_wasm/api.cljs index 57416237cf..546f4c4bdc 100644 --- a/frontend/src/app/render_wasm/api.cljs +++ b/frontend/src/app/render_wasm/api.cljs @@ -14,6 +14,7 @@ [app.common.files.focus :as cpf] [app.common.files.helpers :as cfh] [app.common.fonts :as cfnt] + [app.common.geom.shapes.text :as gsht] [app.common.logging :as log] [app.common.math :as mth] [app.common.render-wasm.api.props :as props] @@ -1661,16 +1662,13 @@ [text-ids] (run! f/force-update-text-layout text-ids)) -(defn- text-selrect-stale? +(defn- text-size-stale? "Check if the WASM-measured dimensions of an auto-grow text shape differ - from its stored selrect by more than `tolerance`." - [{:keys [id selrect grow-type]} tolerance] + from its stored size by more than `tolerance` on an axis that grows and + does not fill its layout parent." + [{:keys [id] :as shape} tolerance] (when-let [{:keys [width height]} (get-text-dimensions id)] - (case grow-type - :auto-width (or (not (mth/close? width (:width selrect) tolerance)) - (not (mth/close? height (:height selrect) tolerance))) - :auto-height (not (mth/close? height (:height selrect) tolerance)) - false))) + (gsht/text-size-drifted? shape width height tolerance))) (defonce ^:private pending-stale-selrect-ids (atom #{})) (defonce ^:private stale-selrect-sync-token (atom 0)) @@ -1696,8 +1694,9 @@ (listen-tiles-render-complete-once! flush-on-idle!))) (defn- sync-stale-text-selrects! - "Emit the ids of auto-grow text shapes whose selrect no longer matches the - measured layout, so the workspace resizes them (data-event instead of a + "Emit the ids of auto-grow text shapes whose stored size drifted from the + measured layout on an axis that grows and does not fill its layout + parent, so the workspace resizes them (data-event instead of a direct call to avoid a circular dependency; see the watcher in `app.main.data.workspace/initialize-workspace`). The default tolerance is 0.1px, as in the classic renderer." @@ -1707,7 +1706,7 @@ (let [stale-ids (into [] (comp (filter cfh/text-shape?) (filter (comp #{:auto-width :auto-height} :grow-type)) - (filter #(text-selrect-stale? % tolerance)) + (filter #(text-size-stale? % tolerance)) (map :id)) shapes)] (when (seq stale-ids) diff --git a/frontend/src/app/util/text_svg_position.cljs b/frontend/src/app/util/text_svg_position.cljs index 13558db6de..05ad576f1a 100644 --- a/frontend/src/app/util/text_svg_position.cljs +++ b/frontend/src/app/util/text_svg_position.cljs @@ -40,6 +40,8 @@ load-promise))) (defn resolve-font + "Ensure the font of `node` is loaded. Resolves to `::font-failed` when it + cannot be loaded: the text is then laid out with a fallback font." [node] (let [styles (dom/get-computed-styles node) font (dom/get-property-value styles "font") @@ -59,7 +61,7 @@ (load-font font)))) (p/merr (fn [_cause] (js/console.error (str/ffmt "Cannot load font %" font-id)) - (p/resolved nil)))))) + (p/resolved ::font-failed)))))) (defn- process-text-node @@ -84,7 +86,15 @@ (let [text-nodes (-> (dom/query (dm/fmt "#html-text-node-%" shape-id)) (dom/query-all ".text-node"))] (->> (p/all (map resolve-font text-nodes)) - (p/fmap #(mapcat process-text-node text-nodes))))) + (p/fmap (fn [fonts] + (cond-> (into [] (mapcat process-text-node) text-nodes) + (some #{::font-failed} fonts) + (with-meta {::font-failed true}))))))) + +(defn font-failed? + "True when `position-data` was measured with a font that failed to load." + [position-data] + (true? (::font-failed (meta position-data)))) (defn calc-position-data [shape-id] @@ -113,4 +123,5 @@ (when (some? shape-id) (->> (calc-text-node-positions shape-id) (p/fmap (fn [text-data] - (mapv transform-data text-data))))))) + (with-meta (mapv transform-data text-data) + (meta text-data)))))))) diff --git a/frontend/test/frontend_tests/data/workspace_heal_undo_test.cljs b/frontend/test/frontend_tests/data/workspace_heal_undo_test.cljs index 9eaee02e3e..71082eb29a 100644 --- a/frontend/test/frontend_tests/data/workspace_heal_undo_test.cljs +++ b/frontend/test/frontend_tests/data/workspace_heal_undo_test.cljs @@ -9,19 +9,23 @@ user action) must not record an undo step, so Ctrl+Z reverts the user's own last edit." (:require + [app.common.math :as mth] [app.common.test-helpers.compositions :as ctho] [app.common.test-helpers.files :as cthf] [app.common.test-helpers.ids-map :as cthi] [app.common.test-helpers.shapes :as cths] [app.main.data.changes :as dch] + [app.main.data.helpers :as dsh] [app.main.data.workspace.shape-layout :as dwsl] [app.main.data.workspace.texts :as dwt] + [app.main.data.workspace.undo :as dwu] [app.main.data.workspace.wasm-text :as dwwt] [beicon.v2.core :as rx] [cljs.test :as t :include-macros true] [frontend-tests.helpers.async :as async] [frontend-tests.helpers.state :as ths] [frontend-tests.helpers.wasm :as thw] + [frontend-tests.tokens.helpers.state :as tohs] [potok.v2.core :as ptk])) (t/use-fixtures :each @@ -66,7 +70,11 @@ (def ^:private heal {:skip-component-sync? true :save-undo? false}) -(def ^:private user {:skip-component-sync? true}) +;; What the component sync sends when it re-measures the synced copies. +(def ^:private sync-remeasure {:skip-component-sync? true}) + +;; A user resize carries no options. +(def ^:private user nil) (t/deftest ^:async heal-resize-records-no-undo-step (let [{:keys [commit]} (await (batch-commit heal))] @@ -76,28 +84,67 @@ (t/deftest ^:async user-resize-keeps-its-undo-step (let [{:keys [commit]} (await (batch-commit user))] (t/is (true? (:save-undo? commit)) - "a resize without the flag records undo as today"))) + "a user resize records undo") + (t/is (not (:skip-component-sync? commit)) + "a user resize syncs to component copies"))) + +(t/deftest ^:async sync-remeasure-keeps-its-undo-step + (let [{:keys [commit]} (await (batch-commit sync-remeasure))] + (t/is (true? (:save-undo? commit)) + "a sync re-measure records undo") + (t/is (true? (:skip-component-sync? commit)) + "a sync re-measure does not start another sync"))) (t/deftest ^:async user-resize-batched-after-a-heal-keeps-its-undo-step - (let [{:keys [commit ids]} (await (batch-commit heal nil))] + (let [{:keys [commit ids]} (await (batch-commit heal user))] (t/is (every? #(touches? commit %) ids) "both resizes land in one commit") (t/is (true? (:save-undo? commit)) - "a user resize without options keeps its undo step"))) + "a user resize without options keeps its undo step") + (t/is (not (:skip-component-sync? commit)) + "a user resize without options still syncs to component copies"))) (t/deftest ^:async heal-batched-after-a-user-resize-keeps-the-undo-step - (let [{:keys [commit ids]} (await (batch-commit nil heal))] + (let [{:keys [commit ids]} (await (batch-commit user heal))] (t/is (every? #(touches? commit %) ids) "both resizes land in one commit") (t/is (true? (:save-undo? commit)) - "the user's resize keeps its undo step"))) + "the user's resize keeps its undo step") + (t/is (not (:skip-component-sync? commit)) + "the user's resize still syncs to component copies"))) + +(t/deftest ^:async user-resize-batched-after-a-sync-remeasure-still-syncs + (let [{:keys [commit ids]} (await (batch-commit sync-remeasure user))] + (t/is (every? #(touches? commit %) ids) + "both resizes land in one commit") + (t/is (true? (:save-undo? commit))) + (t/is (not (:skip-component-sync? commit)) + "the main's new size reaches its copies"))) + +(t/deftest ^:async sync-remeasure-batched-after-a-user-resize-still-syncs + (let [{:keys [commit ids]} (await (batch-commit user sync-remeasure))] + (t/is (every? #(touches? commit %) ids) + "both resizes land in one commit") + (t/is (true? (:save-undo? commit))) + (t/is (not (:skip-component-sync? commit)) + "the main's new size reaches its copies"))) + +(t/deftest ^:async batch-of-sync-remeasures-skips-the-sync + (let [{:keys [commit ids]} (await (batch-commit sync-remeasure sync-remeasure))] + (t/is (every? #(touches? commit %) ids) + "both re-measures land in one commit") + (t/is (true? (:save-undo? commit))) + (t/is (true? (:skip-component-sync? commit)) + "a batch of re-measures does not start another sync"))) (t/deftest ^:async batch-of-heals-records-no-undo-step (let [{:keys [commit ids]} (await (batch-commit heal heal))] (t/is (every? #(touches? commit %) ids) "both heals land in one commit") (t/is (false? (:save-undo? commit)) - "a batch of heals is not added to the undo history"))) + "a batch of heals is not added to the undo history") + (t/is (true? (:skip-component-sync? commit)) + "a batch of heals does not sync to component copies"))) ;; SVG renderer @@ -124,8 +171,11 @@ "the heal commit is not added to the undo history") (t/is (true? (:skip-component-sync? (first @commits))) "the heal does not sync to component copies") - (t/is (some #(and (false? (:save-undo? %)) (contains? (set (:ids %)) id)) @layouts) - "the parents' reflow is asked for without undo too"))) + (t/is (some #(and (false? (:save-undo? %)) + (true? (:skip-component-sync? %)) + (contains? (set (:ids %)) id)) + @layouts) + "the parents' reflow is asked for without undo and without sync too"))) (defn- ^:async svg-mixed-commits "Emit `heal-event` for one text and `user-event` for another in the same @@ -225,12 +275,84 @@ user (collect-commits store rect-b)] (ptk/emit! store (dwsl/initialize-shape-layout)) ;; Both updates land in the same 100 ms layout buffer. - (ptk/emit! store (ptk/data-event :layout/update {:ids [rect-a] :save-undo? false})) + (ptk/emit! store (ptk/data-event :layout/update {:ids [rect-a] + :save-undo? false + :skip-component-sync? true})) (ptk/emit! store (ptk/data-event :layout/update {:ids [rect-b]})) (await (async/wait-for #(and (seq @heal) (seq @user)) "a reflow commit for each board" {:max-ticks 400})) (ptk/emit! store (dwsl/finalize-shape-layout)) (t/is (false? (:save-undo? (first @heal))) "the reflow of a heal is not added to the undo history") + ;; A commit without undo and without this flag would make the component + ;; watcher touch the component, so a page open would change it + (t/is (true? (:skip-component-sync? (first @heal))) + "the reflow of a heal does not change components") (t/is (true? (:save-undo? (first @user))) - "a user reflow in the same buffer keeps its undo step"))) + "a user reflow in the same buffer keeps its undo step") + (t/is (not (:skip-component-sync? (first @user))) + "and still syncs to component copies"))) + +;; Undo history + +(defn- undo-stack + [store] + (select-keys (:workspace-undo @store) [:items :index])) + +(defn- text-size + [store id] + (-> (dsh/lookup-page-objects @store) + (get id) + (select-keys [:width :height]))) + +(defn- ^:async heal-keeps-the-undo-history + "Make a user edit on one text with `user-event`, then heal another with + `heal-event`, each in its own commit. The heal must leave the undo stack + as the user edit left it, and undo must revert the user edit." + [renderer user-event heal-event] + (let [file (-> (cthf/sample-file :file1) + (ctho/add-frame-with-text :frame-a :text-a "hello") + (ctho/add-frame-with-text :frame-b :text-b "world")) + store (ths/setup-store file (when renderer {:renderer renderer})) + user-id (:id (cths/get-shape file :text-a)) + heal-id (:id (cths/get-shape file :text-b)) + user-commits (collect-commits store user-id) + heal-commits (collect-commits store heal-id) + original (text-size store user-id)] + (ptk/emit! store (tohs/watch-undo-stack)) + + (ptk/emit! store (user-event user-id)) + (await (async/wait-for #(and (seq @user-commits) (seq (:items (undo-stack store)))) + "an undo entry for the user edit" {:max-ticks 200})) + (let [after-user (undo-stack store) + edited (text-size store user-id)] + (t/is (not= original edited) + "the user edit changes the text size") + + (ptk/emit! store (heal-event heal-id)) + (await (async/wait-for #(seq @heal-commits) "a heal commit" {:max-ticks 200})) + (await (async/settle)) + (let [healed (text-size store heal-id)] + (t/is (= after-user (undo-stack store)) + "the heal adds no undo entry and does not move the index") + + (ptk/emit! store dwu/undo) + (await (async/wait-for #(not= edited (text-size store user-id)) + "the undo of the user edit" {:max-ticks 200})) + (t/is (and (mth/close? (:width original) (:width (text-size store user-id))) + (mth/close? (:height original) (:height (text-size store user-id)))) + "undo reverts the user edit") + (t/is (= healed (text-size store heal-id)) + "undo leaves the heal in place"))))) + +(t/deftest ^:async heal-keeps-the-undo-history-on-wasm + (await (heal-keeps-the-undo-history + nil + #(dwwt/resize-wasm-text-all [%] nil) + #(dwwt/resize-wasm-text-all [%] heal)))) + +(t/deftest ^:async heal-keeps-the-undo-history-on-svg + (await (heal-keeps-the-undo-history + :svg + #(dwt/resize-text % 60 40) + #(dwt/resize-text % 50 30 {:save-undo? false})))) diff --git a/frontend/test/frontend_tests/data/workspace_sync_text_wasm_test.cljs b/frontend/test/frontend_tests/data/workspace_sync_text_wasm_test.cljs index 64a77d93fe..a476ac085b 100644 --- a/frontend/test/frontend_tests/data/workspace_sync_text_wasm_test.cljs +++ b/frontend/test/frontend_tests/data/workspace_sync_text_wasm_test.cljs @@ -6,8 +6,9 @@ (ns frontend-tests.data.workspace-sync-text-wasm-test "Regression test for #12721: after component sync with render-wasm/v1, - auto-grow text copies must be scheduled for WASM remasure with - :skip-component-sync? so box size heals without marking :geometry-group." + auto-grow text copies must be scheduled for a WASM re-measure with + :skip-component-sync?, so the re-measure commit does not start another + sync." (:require [app.common.files.changes-builder :as pcb] [app.common.geom.shapes :as gsh] @@ -19,7 +20,9 @@ [app.common.test-helpers.shapes :as cths] [app.common.types.modifiers :as ctm] [app.common.uuid :as uuid] + [app.main.data.changes :as dch] [app.main.data.workspace.libraries :as dwl] + [app.main.data.workspace.undo :as dwu] [app.main.data.workspace.wasm-text :as dwwt] [beicon.v2.core :as rx] [cljs.test :as t :include-macros true] @@ -92,7 +95,7 @@ (rx/subs! (fn [_] nil))) acc)) -(t/deftest test-sync-file-schedules-wasm-text-remasure +(t/deftest test-sync-file-schedules-wasm-text-remeasure (t/async done (let [file (-> (setup-file) bump-main-font-size) @@ -118,15 +121,114 @@ (mapcat :ids) set)] (t/is (some #{copy-id} ids) - "remasure ids should include the copy text") + "re-measure ids should include the copy text") (t/is (:skip-component-sync? opts) - "remasure must use :skip-component-sync? so size heal does not mark :geometry-group") + "re-measure must use :skip-component-sync? so its commit does not start another sync") (t/is (= undo-group (:undo-group opts))) (t/is (every? layout-ids ids) - (str "current-page :layout/update ids must include remasure ids; " - "layout=" layout-ids " remasure=" ids)))))))) + (str "current-page :layout/update ids must include re-measure ids; " + "layout=" layout-ids " re-measure=" ids)))))))) -(t/deftest test-sync-file-skips-remasure-for-fixed-text +(defn- collect-commits + "Subscribe before emit; accumulates the commits that touch `id`." + [store id] + (let [acc (atom [])] + (->> (ptk/input-stream store) + (rx/filter dch/commit?) + (rx/map deref) + (rx/filter #(some (comp #{id} :id) (:redo-changes %))) + (rx/subs! #(swap! acc conj %))) + acc)) + +(t/deftest test-sync-file-without-undo-group-shares-one-with-its-remeasure + (t/async + done + (let [file (-> (setup-file) bump-main-font-size) + store (ths/setup-store file) + copy-id (:id (cths/get-shape file :copy-child)) + commits (collect-commits store copy-id) + ;; The library update dialog and the color and typography syncs + ;; pass no undo group + events [(dwl/sync-file (:id file) (:id file) + :components (cthi/id :component1))]] + (ths/run-store + store done events + (fn [_] + (let [sync-group (:undo-group (first @commits)) + remeasure-opts (:opts (first @resize-calls))] + (t/is (some? sync-group) + "the sync commit gets an undo group") + (t/is (= sync-group (:undo-group remeasure-opts)) + "the re-measure shares it, so one undo reverts both"))))))) + +(defn- run-sync-in-undo-transaction + "Runs, inside one undo transaction, an edit commit with `edit-group` (nil + for none) and then `sync-file` with no undo group, and checks that the + sync commit and its re-measure take the edit's group. With `edit-group` + the edit's history entry is appended by hand, as the workspace undo + watcher does, so the transaction gets that group as its `:undo-group`." + [done edit-group] + (let [file (-> (setup-file) bump-main-font-size) + store (ths/setup-store file) + page-id (cthf/current-page-id file) + tx (js/Symbol) + redo [{:type :mod-page :id page-id :name "Edited"}] + undo [{:type :mod-page :id page-id :name "Page 1"}] + groups (atom []) + sub (->> (ptk/input-stream store) + (rx/filter dch/commit?) + (rx/subs! #(swap! groups conj (:undo-group (deref %))))) + events (cond-> [(dwu/start-undo-transaction tx :timeout 0) + ;; Stands for the color, typography or delete commit + (dch/commit-changes {:redo-changes redo + :undo-changes undo + :undo-group edit-group})] + (some? edit-group) + (conj (dwu/append-undo {:undo-changes undo + :redo-changes redo + :undo-group edit-group + :tags #{}} + false)) + + :always + (conj (dwl/sync-file (:id file) (:id file) + :components (cthi/id :component1)) + (dwu/commit-undo-transaction tx)))] + (ths/run-store + store done events + (fn [_] + (rx/dispose! sub) + (let [first-group (first @groups) + remeasure-opts (:opts (first @resize-calls))] + (t/is (some? first-group)) + (when (some? edit-group) + (t/is (= edit-group first-group))) + (t/is (< 1 (count @groups)) + "the sync commits after the edit") + (t/is (every? #{first-group} @groups) + "the sync commit takes the transaction's group") + (t/is (= first-group (:undo-group remeasure-opts)) + "the re-measure takes the transaction's group")))))) + +;; Scenario: the color and typography edits commit and call `sync-file` +;; with no undo group inside their own undo transaction. Proves: the sync +;; commit and its re-measure take the transaction's group, so one undo +;; reverts the edit and its sync, and a rejected sync rolls back both. +(t/deftest test-sync-file-in-undo-transaction-shares-its-group + (t/async + done + (run-sync-in-undo-transaction done nil))) + +;; Scenario: `delete-component` commits with its own undo group inside the +;; sidebar's undo transaction, then syncs with no group. Proves: the sync +;; takes the transaction's `:undo-group` (the delete's), not the group the +;; transaction was opened with. +(t/deftest test-sync-file-in-undo-transaction-takes-the-entry-group + (t/async + done + (run-sync-in-undo-transaction done (uuid/next)))) + +(t/deftest test-sync-file-skips-remeasure-for-fixed-text (t/async done (let [file (-> (setup-file :grow-type :fixed) bump-main-font-size) @@ -140,7 +242,50 @@ store done events (fn [_new-state] (t/is (empty? @resize-calls) - "fixed-grow texts must not be scheduled for WASM remasure")))))) + "fixed-grow texts must not be scheduled for a WASM re-measure")))))) + +(defn- set-main-grow-type + [grow-type] + (fn [file] + (update-main-text file #(assoc % :grow-type grow-type)))) + +(t/deftest test-sync-file-remeasures-text-that-becomes-auto-grow + (t/async + done + (let [file (-> (setup-file :grow-type :fixed) + ((set-main-grow-type :auto-height))) + store (ths/setup-store file) + copy-id (:id (cths/get-shape file :copy-child)) + events [(dwl/sync-file (:id file) (:id file) + :components (cthi/id :component1))]] + (ths/run-store + store done events + (fn [_] + (t/is (= 1 (count @resize-calls)) + "a copy turned auto-grow by the sync is re-measured") + (t/is (some #{copy-id} (:ids (first @resize-calls))) + "the re-measure includes the copy")))))) + +(t/deftest test-sync-file-skips-text-that-becomes-fixed + (t/async + done + (let [file (-> (setup-file :grow-type :auto-height) + ((set-main-grow-type :fixed))) + store (ths/setup-store file) + page-id (cthf/current-page-id file) + copy-id (:id (cths/get-shape file :copy-child)) + layout-updates (collect-layout-updates store) + events [(dwl/sync-file (:id file) (:id file) + :components (cthi/id :component1))]] + (ths/run-store + store done events + (fn [_] + (t/is (empty? @resize-calls) + "a copy turned fixed by the sync is not re-measured") + (t/is (not-any? #(and (= page-id (:page-id %)) + (some #{copy-id} (:ids %))) + @layout-updates) + "and gets no layout update for a re-measure")))))) (defn- sync-remeasures "Sync the copy after `change-main` and call `check` with the re-measure @@ -152,7 +297,7 @@ :components (cthi/id :component1))]] (ths/run-store store done events (fn [_] (check @resize-calls))))) -(t/deftest test-sync-file-skips-remasure-for-fill-change +(t/deftest test-sync-file-skips-remeasure-for-fill-change (t/async done (sync-remeasures done recolor-main-text @@ -160,7 +305,7 @@ (t/is (empty? calls) "a text color change does not change its size"))))) -(t/deftest test-sync-file-skips-remasure-for-opacity-change +(t/deftest test-sync-file-skips-remeasure-for-opacity-change (t/async done (sync-remeasures done fade-main-text @@ -168,7 +313,7 @@ (t/is (empty? calls) "an opacity change does not change the text size"))))) -(t/deftest test-sync-file-remasures-auto-height-text-on-font-change +(t/deftest test-sync-file-remeasures-auto-height-text-on-font-change (t/async done (sync-remeasures done bump-main-font-size @@ -176,7 +321,7 @@ (t/is (= 1 (count calls)) "a font change can change the text size"))))) -(t/deftest test-sync-file-remasures-auto-height-text-on-width-change +(t/deftest test-sync-file-remeasures-auto-height-text-on-width-change (t/async done (sync-remeasures done widen-main-text diff --git a/frontend/test/frontend_tests/data/workspace_texts_test.cljs b/frontend/test/frontend_tests/data/workspace_texts_test.cljs index bf87c5162c..57838bcd45 100644 --- a/frontend/test/frontend_tests/data/workspace_texts_test.cljs +++ b/frontend/test/frontend_tests/data/workspace_texts_test.cljs @@ -769,35 +769,3 @@ (t/deftest same-styled-text-sees-a-text-change (t/is (not (dwt/same-styled-text? (text-content {:text "Hello" :font-weight "400"}) (text-content {:text "Hello!" :font-weight "400"}))))) - -(t/deftest text-size-drifted-ignores-sub-pixel-gaps - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-width :width 100 :height 17} 100.5 17.5))) - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 17.5)))) - -(t/deftest text-size-drifted-checks-only-the-growing-axis - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 140 17)) - "auto-height width comes from the box, not the text") - (t/is (dwt/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 34)) - (t/is (dwt/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 67 17)) - (t/is (dwt/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 44 34) - "auto-width grows in height too")) - -(t/deftest text-size-drifted-treats-exactly-one-pixel-as-rounding - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-height :width 100 :height 17} 100 18)) - "a 1px height gap is rounding, as in the WebGL check") - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-width :width 44 :height 17} 45 17)) - "a 1px width gap is rounding, as in the WebGL check")) - -(t/deftest text-size-drifted-ignores-an-axis-that-fills-its-parent - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-height :width 100 :height 40 - :layout-item-v-sizing :fill} - 100 17)) - "a height set by the layout is not drift") - (t/is (not (dwt/text-size-drifted? {:grow-type :auto-width :width 200 :height 17 - :layout-item-h-sizing :fill} - 44 17)) - "a width set by the layout is not drift") - (t/is (dwt/text-size-drifted? {:grow-type :auto-width :width 200 :height 17 - :layout-item-h-sizing :fill} - 44 34) - "the axis that does not fill is still checked")) diff --git a/frontend/test/frontend_tests/render_wasm/stale_text_selrects_test.cljs b/frontend/test/frontend_tests/render_wasm/stale_text_selrects_test.cljs index 55b17b0046..7e42a152e0 100644 --- a/frontend/test/frontend_tests/render_wasm/stale_text_selrects_test.cljs +++ b/frontend/test/frontend_tests/render_wasm/stale_text_selrects_test.cljs @@ -22,12 +22,17 @@ [promesa.core :as p])) (defn- text-shape - [grow-type width height] - {:id (uuid/next) - :type :text - :parent-id uuid/zero - :grow-type grow-type - :selrect {:x 0 :y 0 :width width :height height}}) + ([grow-type width height] + (text-shape grow-type width height nil)) + ([grow-type width height attrs] + (merge {:id (uuid/next) + :type :text + :parent-id uuid/zero + :grow-type grow-type + :width width + :height height + :selrect {:x 0 :y 0 :width width :height height}} + attrs))) (defn- rect-shape [] @@ -133,6 +138,22 @@ (t/is (empty? (stale-selrect-ids events)) "fixed text boxes are never resized to their layout"))) +(t/deftest ^:async page-load-skips-axes-that-fill-their-layout-parent + (let [fill-width (text-shape :auto-width 200 17 {:layout-item-h-sizing :fill}) + fill-height (text-shape :auto-height 100 40 {:layout-item-v-sizing :fill}) + events (await (load-page (page-objects fill-width fill-height) + {(:id fill-width) {:width 44 :height 17} + (:id fill-height) {:width 100 :height 17}}))] + (t/is (empty? (stale-selrect-ids events)) + "a size set by the layout is not stale"))) + +(t/deftest ^:async page-load-checks-the-axis-that-does-not-fill + (let [text (text-shape :auto-width 200 17 {:layout-item-h-sizing :fill}) + events (await (load-page (page-objects text) + {(:id text) {:width 44 :height 34}}))] + (t/is (= #{(:id text)} (stale-selrect-ids events)) + "the height of a fill-width auto-width text still grows with its content"))) + (t/deftest ^:async page-load-skips-texts-waiting-for-a-font (let [waiting (text-shape :auto-height 100 17) ready (text-shape :auto-height 100 17) diff --git a/frontend/test/frontend_tests/ui/viewport_texts_html_test.cljs b/frontend/test/frontend_tests/ui/viewport_texts_html_test.cljs index 13f8caff4e..de133dacc5 100644 --- a/frontend/test/frontend_tests/ui/viewport_texts_html_test.cljs +++ b/frontend/test/frontend_tests/ui/viewport_texts_html_test.cljs @@ -7,10 +7,16 @@ (ns frontend-tests.ui.viewport-texts-html-test "How the SVG renderer measures text shapes and commits the result." (:require + ["jsdom" :refer [JSDOM]] + ["react" :as react] + ["react-dom" :as rd] + ["react-dom/client" :as rdc] [app.common.geom.point :as gpt] [app.common.uuid :as uuid] + [app.main.data.workspace.reflow :as wrf] [app.main.data.workspace.texts :as dwt] [app.main.store :as st] + [app.main.ui.shapes.text.html-text :as html] [app.main.ui.workspace.shapes.text.viewport-texts-html :as vth] [app.util.dom :as dom] [app.util.text-svg-position :as tsp] @@ -18,7 +24,8 @@ [frontend-tests.helpers.async :as async] [frontend-tests.helpers.mock :as mock] [potok.v2.core :as ptk] - [promesa.core :as p])) + [promesa.core :as p] + [rumext.v2 :as mf])) (def ^:private fixed-text {:id (uuid/next) :type :text :grow-type :fixed}) @@ -89,40 +96,53 @@ [& shapes] (into {} (map (juxt :id identity)) shapes)) -(t/deftest override-copy-heal-phases-checks-overridden-auto-grow-copies - (let [fixed (text :fixed #{:content-group}) - untouched (text :auto-height nil) - geometry (text :auto-height #{:geometry-group}) - unknown (text nil #{:content-group}) - override (text :auto-width #{:content-group})] - (t/is (= {(:id override) :check} - (vth/override-copy-heal-phases (by-id fixed untouched geometry unknown override))) - "only auto-grow texts with overridden content are checked"))) +(defn- in-copy + [shape] + (assoc shape :shape-ref (uuid/next))) + +(t/deftest copy-heal-phases-checks-auto-grow-texts-in-copies + (let [fixed (in-copy (text :fixed #{:content-group})) + unknown (in-copy (text nil #{:content-group})) + main (text :auto-height #{:content-group}) + untouched (in-copy (text :auto-height nil)) + geometry (in-copy (text :auto-height #{:geometry-group})) + override (in-copy (text :auto-width #{:content-group}))] + (t/is (= {(:id untouched) :check + (:id geometry) :check + (:id override) :check} + (vth/copy-heal-phases (by-id fixed unknown main untouched geometry override))) + (str "every auto-grow text in a copy is checked, also one nested in a " + "main that overrides it, which has no touched flag of its own; " + "texts of a main and fixed texts are not")))) (t/deftest unchanged-copy-is-measured-in-the-check-phase (let [copy (text :auto-height #{:content-group})] (t/is (vth/text-changed? copy copy :check) "an unchanged copy waiting for its check is measured") (t/is (not (vth/text-changed? copy copy nil)) - "once checked, an unchanged copy is left alone"))) + "once checked, an unchanged copy is left alone") + (t/is (not (vth/text-changed? copy copy :settle)) + "a copy waiting to settle is measured only once its heal resize changes it"))) (defn- measure-with-box "Measure `shape` in heal `phase` with its layout box measured at `width` x `height`. Resolves to the events emitted to the store and the next heal phase. The resize and position-data requests are recorded as `::resize` and `::position-data` events carrying their options." - [shape phase width height] - (let [emitted (atom []) - record (fn [type] (fn [& args] (ptk/data-event type {:opts (last args)})))] - (->> (mock/with-mocks* - {tsp/calc-position-data (mock/stub (constantly (p/resolved [fragment]))) - dom/query (mock/stub (constantly #js {})) - dom/get-bounding-rect (mock/stub (constantly {:width width :height height})) - dwt/resize-text (mock/stub (record ::resize)) - dwt/update-position-data (mock/stub (record ::position-data)) - st/emit! (mock/stub (fn [& events] (swap! emitted into events) nil))} - (await (measure-text shape #js {} phase))) - (p/fmap (fn [next-phase] {:events @emitted :next next-phase}))))) + ([shape phase width height] + (measure-with-box shape phase width height [fragment])) + ([shape phase width height position-data] + (let [emitted (atom []) + record (fn [type] (fn [& args] (ptk/data-event type {:opts (last args)})))] + (->> (mock/with-mocks* + {tsp/calc-position-data (mock/stub (constantly (p/resolved position-data))) + dom/query (mock/stub (constantly #js {})) + dom/get-bounding-rect (mock/stub (constantly {:width width :height height})) + dwt/resize-text (mock/stub (record ::resize)) + dwt/update-position-data (mock/stub (record ::position-data)) + st/emit! (mock/stub (fn [& events] (swap! emitted into events) nil))} + (await (measure-text shape #js {} phase))) + (p/fmap (fn [next-phase] {:events @emitted :next next-phase})))))) (defn- committed "Options of the `type` request among `events`, `::none` if there is none." @@ -159,9 +179,21 @@ {:keys [events next]} (await (measure-with-box copy :check 200 17.4))] (t/is (= no-undo (committed ::position-data events)) "a copy that lost its position-data in a sync gets it back, with no undo step") + (t/is (= ::none (committed ::resize events)) + "a copy whose size did not drift is not resized") (t/is (nil? next) "nothing resizes it, so the heal ends"))) +(t/deftest ^:async check-phase-heals-a-drifted-copy-without-position-data + (let [copy (assoc (text :auto-height #{:content-group}) :position-data nil) + {:keys [events next]} (await (measure-with-box copy :check 200 34))] + (t/is (= no-undo (committed ::resize events)) + "a drifted copy without position-data is resized, with no undo step") + (t/is (= no-undo (committed ::position-data events)) + "and gets its position-data back, with no undo step") + (t/is (= :settle next) + "the measurement caused by the resize belongs to the heal"))) + (t/deftest ^:async check-phase-commits-nothing-when-it-cannot-measure (let [{:keys [events]} (await (measure-with-box (text :auto-height #{:content-group}) :check 0 0))] @@ -188,3 +220,146 @@ (t/is (= {} (committed ::position-data events)) "and so is the position-data") (t/is (nil? next)))) + +(def ^:private fallback-font-position-data + "Position-data measured with a font that failed to load." + (with-meta [fragment] {::tsp/font-failed true})) + +(t/deftest font-failed-reads-the-measurement-mark + (t/is (tsp/font-failed? fallback-font-position-data)) + (t/is (not (tsp/font-failed? [fragment])))) + +(t/deftest ^:async check-phase-writes-no-size-from-a-fallback-font + (let [{:keys [events next]} + (await (measure-with-box (text :auto-height #{:content-group}) :check 200 34 + fallback-font-position-data))] + (t/is (= ::none (committed ::resize events)) + "a size laid out with a fallback font is not written on page open") + (t/is (= ::none (committed ::position-data events)) + "nor its position-data") + (t/is (nil? next) + "the heal ends"))) + +(t/deftest ^:async check-phase-restores-position-data-with-a-fallback-font + (let [copy (assoc (text :auto-height #{:content-group}) :position-data nil) + {:keys [events]} + (await (measure-with-box copy :check 200 34 fallback-font-position-data))] + (t/is (= no-undo (committed ::position-data events)) + "a copy without position-data still gets it, with no undo step") + (t/is (= ::none (committed ::resize events)) + "but its size is not written"))) + +(t/deftest ^:async no-phase-commits-a-fallback-font-size-as-usual + (let [{:keys [events]} + (await (measure-with-box (text :auto-height nil) nil 200 34 + fallback-font-position-data))] + (t/is (= {} (committed ::resize events)) + "outside a heal, the measured size is committed as before"))) + +;; The heal phases through the mounted renderer: a text is measured when it +;; mounts, and how often it mounts depends on its phase. + +(def ^:private measured-text + "Stands in for `html/text-shape*`: a node to measure, with no content." + (react/forwardRef + (fn [_props ref] + (react/createElement "div" #js {:ref ref :className "measured-text"})))) + +(defn- next-immediate + "Resolves after the tasks React's scheduler queued with `setImmediate` + so far have run." + [] + (js/Promise. (fn [resolve] (js/setImmediate resolve)))) + +(defn- mount-text-changes + "Mount `text-changes-renderer` in a jsdom document. Returns `:render`, + which renders it with a map of text shapes, `:measuring`, the number of + texts mounted to be measured, `:errors`, what React reported, and + `:unmount`, which resolves once React's scheduler has run. react-dom + reads the global `window`, so the jsdom one stays installed until then." + [] + (let [errors (atom []) + on-error (fn [error _info] (swap! errors conj error)) + window (.-window (JSDOM. "
")) + container (.getElementById (.-document window) "root") + root (rdc/createRoot container #js {:onUncaughtError on-error + :onCaughtError on-error + :onRecoverableError on-error}) + previous (.-window js/globalThis)] + (set! (.-window js/globalThis) window) + {:render (fn [shapes] + (rd/flushSync + #(.render root (mf/element vth/text-changes-renderer + #js {"text-shapes" shapes})))) + :measuring #(.-length (.querySelectorAll container ".measured-text")) + :errors #(deref errors) + :unmount (fn [] + (rd/flushSync #(.unmount root)) + (p/finally (next-immediate) + #(set! (.-window js/globalThis) previous)))})) + +(defn- with-text-changes + "Run `(f mount counts)` with `text-changes-renderer` mounted and every + text measured `height` px tall. `counts` returns the number of + measurements so far and the options of each resize request. Resolves + once `f` settles and the renderer is unmounted." + [height f] + (let [measures (atom 0) + resizes (atom [])] + (mock/with-mocks* + {tsp/calc-position-data (mock/stub (fn [_id] + (swap! measures inc) + (p/resolved [fragment]))) + dom/query (mock/stub (constantly #js {})) + dom/get-bounding-rect (mock/stub (constantly {:width 200 :height height})) + dwt/resize-text (mock/stub (fn [& args] + (swap! resizes conj (last args)) + (ptk/data-event ::resize {}))) + dwt/update-position-data (mock/stub (fn [& _] (ptk/data-event ::position-data {}))) + wrf/run-pending! (mock/stub (fn [_kind _ids f] (f))) + html/text-shape* measured-text + st/emit! (mock/stub (constantly nil))} + (let [mount (mount-text-changes) + counts (fn [] {:measures @measures :resizes @resizes})] + (await (f mount counts)) + (await ((:unmount mount))))))) + +(t/deftest ^:async drifted-copy-is-measured-once-to-check-and-once-to-settle + (let [copy (in-copy (text :auto-height nil)) + resized (assoc copy :height 34)] + (await + (with-text-changes + 34 + (^:async fn [{:keys [render measuring errors]} counts] + (render (by-id copy)) + (await (async/wait-for #(zero? (measuring)) "the check measurement ends")) + (t/is (= {:measures 1 :resizes [no-undo]} (counts)) + "the check measures the copy once and resizes it, with no undo step") + + (render (by-id resized)) + (await (async/wait-for #(zero? (measuring)) "the settle measurement ends")) + (t/is (= {:measures 2 :resizes [no-undo no-undo]} (counts)) + "the heal resize measures it once more, with no undo step") + + (render (by-id resized)) + (await (async/settle)) + (t/is (= 2 (:measures (counts))) + "once settled, the copy is not measured again") + (t/is (empty? (errors)))))))) + +(t/deftest ^:async matching-copy-is-measured-once + (let [copy (in-copy (text :auto-height nil))] + (await + (with-text-changes + 17.4 + (^:async fn [{:keys [render measuring errors]} counts] + (render (by-id copy)) + (await (async/wait-for #(zero? (measuring)) "the check measurement ends")) + (t/is (= {:measures 1 :resizes []} (counts)) + "the check measures the copy once and leaves its size alone") + + (render (by-id copy)) + (await (async/settle)) + (t/is (= 1 (:measures (counts))) + "once checked, the copy is not measured again") + (t/is (empty? (errors))))))))