WIP

frontend/src/app/main/errors.cljs

@@ -116,17 +116,6 @@
       (ex/print-throwable cause :prefix "Unexpected Error")
       (show-not-blocking-error cause))))
 
-(defmethod ptk/handle-error :wasm-non-blocking
-  [error]
-  (when-let [cause (::instance error)]
-    (show-not-blocking-error cause)))
-
-(defmethod ptk/handle-error :wasm-critical
-  [error]
-  (when-let [cause (::instance error)]
-    (ex/print-throwable cause :prefix "WASM critical error"))
-  (st/emit! (rt/assign-exception error)))
-
 ;; We receive a explicit authentication error; If the uri is for
 ;; workspace, dashboard, viewer or settings, then assign the exception
 ;; for show the error page. Otherwise this explicitly clears all
@@ -338,24 +327,20 @@
                   (str/starts-with? message "invalid props on component")
                   (str/starts-with? message "Unexpected token "))))
 
-          (handle-uncaught [cause]
-            (when cause
-              (set! last-exception cause)
-              (let [data (ex-data cause)
-                    type (get data :type)]
-                (if (#{:wasm-critical :wasm-non-blocking} type)
-                  (on-error cause)
-                  (when-not (is-ignorable-exception? cause)
-                    (ex/print-throwable cause :prefix "Uncaught Exception")
-                    (ts/schedule #(show-not-blocking-error cause)))))))
-
           (on-unhandled-error [event]
             (.preventDefault ^js event)
-            (handle-uncaught (unchecked-get event "error")))
+            (when-let [cause (unchecked-get event "error")]
+              (set! last-exception cause)
+              (when-not (is-ignorable-exception? cause)
+                (ex/print-throwable cause :prefix "Uncaught Exception")
+                (ts/schedule #(show-not-blocking-error cause)))))
 
           (on-unhandled-rejection [event]
             (.preventDefault ^js event)
-            (handle-uncaught (unchecked-get event "reason")))]
+            (when-let [cause (unchecked-get event "reason")]
+              (set! last-exception cause)
+              (ex/print-throwable cause :prefix "Uncaught Rejection")
+              (ts/schedule #(show-not-blocking-error cause))))]
 
     (.addEventListener g/window "error" on-unhandled-error)
     (.addEventListener g/window "unhandledrejection" on-unhandled-rejection)

frontend/src/app/main/features.cljs

@@ -86,6 +86,24 @@
       :else
       (enabled-by-flags? state feature))))
 
+(defn active-features?
+  "Given a state and a set of features, check if the features are all enabled."
+  ([state a]
+   (js/console.warn "Please, use active-feature? instead")
+   (active-feature? state a))
+  ([state a b]
+   (and ^boolean (active-feature? state a)
+        ^boolean (active-feature? state b)))
+  ([state a b c]
+   (and ^boolean (active-feature? state a)
+        ^boolean (active-feature? state b)
+        ^boolean (active-feature? state c)))
+  ([state a b c & others]
+   (and ^boolean (active-feature? state a)
+        ^boolean (active-feature? state b)
+        ^boolean (active-feature? state c)
+        ^boolean (every? #(active-feature? state %) others))))
+
 (def ^:private features-ref
   (l/derived (l/key :features) st/state))
 

frontend/src/app/main/ui/workspace/shapes/text/v2_editor.cljs

@@ -131,7 +131,8 @@
 
         on-style-change
         (fn [event]
-          (let [styles (styles/get-styles-from-event event)]
+          (let [
+            styles (styles/get-styles-from-event event)]
             (st/emit! (dwt/v2-update-text-editor-styles shape-id styles))))
 
         on-needs-layout

frontend/src/app/main/ui/workspace/shapes/text/v3_editor.cljs

@@ -0,0 +1,338 @@
+;; 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.main.ui.workspace.shapes.text.v3-editor
+  "Contenteditable DOM element for WASM text editor input"
+  (:require-macros [app.main.style :as stl])
+  (:require
+   [app.common.data.macros :as dm]
+   [app.common.geom.shapes :as gsh]
+   [app.common.math :as mth]
+   [app.main.data.helpers :as dsh]
+   [app.main.data.workspace.texts :as dwt]
+   [app.main.refs :as refs]
+   [app.main.store :as st]
+   [app.main.ui.css-cursors :as cur]
+   [app.render-wasm.api :as wasm.api]
+   [app.render-wasm.text-editor :as text-editor]
+   [app.util.dom :as dom]
+   [app.util.object :as obj]
+   [cuerdas.core :as str]
+   [rumext.v2 :as mf]
+   [app.main.ui.ds.foundations.assets.icon :as i]))
+
+(def caret-blink-interval-ms 250)
+
+(defn- sync-wasm-text-editor-content!
+  "Sync WASM text editor content back to the shape via the standard
+  commit pipeline. Called after every text-modifying input."
+  [& {:keys [finalize?]}]
+  (when-let [{:keys [shape-id content]}
+             (text-editor/text-editor-sync-content)]
+    (st/emit! (dwt/v2-update-text-shape-content
+               shape-id content
+               :update-name? true
+               :finalize? finalize?))))
+
+(defn- font-family-from-font-id [font-id]
+  (if (str/includes? font-id "gfont-noto-sans")
+    (let [lang (str/replace font-id #"gfont\-noto\-sans\-" "")]
+      (if (>= (count lang) 3) (str/capital lang) (str/upper lang)))
+    "Noto Color Emoji"))
+
+(mf/defc text-editor
+  "Contenteditable element positioned over the text shape to capture input events."
+  {::mf/wrap-props false}
+  [props]
+  (let [shape     (obj/get props "shape")
+        shape-id  (dm/get-prop shape :id)
+
+        clip-id   (dm/str "text-edition-clip" shape-id)
+
+        contenteditable-ref (mf/use-ref nil)
+        composing?          (mf/use-state false)
+
+        fallback-fonts    (wasm.api/fonts-from-text-content (:content shape) false)
+        fallback-families (map (fn [font]
+                                 (font-family-from-font-id (:font-id font))) fallback-fonts)
+
+        ;; Calculate screen position from shape bounds
+        bounds (gsh/shape->rect shape)
+
+        x      (mth/min (dm/get-prop bounds :x)
+                        (dm/get-prop shape :x))
+        y      (mth/min (dm/get-prop bounds :y)
+                        (dm/get-prop shape :y))
+        width  (mth/max (dm/get-prop bounds :width)
+                        (dm/get-prop shape :width))
+        height (mth/max (dm/get-prop bounds :height)
+                        (dm/get-prop shape :height))
+
+        [{:keys [x y width height]} transform]
+        (let [{:keys [width height]} (wasm.api/get-text-dimensions shape-id)
+              selrect-transform (mf/deref refs/workspace-selrect)
+              [selrect transform] (dsh/get-selrect selrect-transform shape)
+              selrect-height (:height selrect)
+              selrect-width (:width selrect)
+              max-width (max width selrect-width)
+              max-height (max height selrect-height)
+              valign (-> shape :content :vertical-align)
+              y (:y selrect)
+              y (case valign
+                  "bottom" (+ y (- selrect-height height))
+                  "center" (+ y (/ (- selrect-height height) 2))
+                  y)]
+          [(assoc selrect :y y :width max-width :height max-height) transform])
+
+        on-composition-start
+        (mf/use-fn
+         (fn [_event]
+           (reset! composing? true)))
+
+        on-composition-end
+        (mf/use-fn
+         (fn [^js event]
+           (reset! composing? false)
+           (let [data (.-data event)]
+             (when data
+               (text-editor/text-editor-insert-text data)
+               (sync-wasm-text-editor-content!)
+               (wasm.api/request-render "text-composition"))
+             (when-let [node (mf/ref-val contenteditable-ref)]
+               (set! (.-textContent node) "")))))
+
+        on-paste
+        (mf/use-fn
+         (fn [^js event]
+           (dom/prevent-default event)
+           (let [clipboard-data (.-clipboardData event)
+                 text (.getData clipboard-data "text/plain")]
+             (when (and text (seq text))
+               (text-editor/text-editor-insert-text text)
+               (sync-wasm-text-editor-content!)
+               (wasm.api/request-render "text-paste"))
+             (when-let [node (mf/ref-val contenteditable-ref)]
+               (set! (.-textContent node) "")))))
+
+        on-copy
+        (mf/use-fn
+         (fn [^js event]
+           (when (text-editor/text-editor-is-active?)
+             (dom/prevent-default event)
+             (when (text-editor/text-editor-get-selection)
+               (let [text (text-editor/text-editor-export-selection)]
+                 (.setData (.-clipboardData event) "text/plain" text))))))
+
+        on-key-down
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event) (.-key event))
+           (when (and (text-editor/text-editor-is-active?)
+                      (not @composing?))
+
+             (let [key    (.-key event)
+                   ctrl?  (or (.-ctrlKey event) (.-metaKey event))
+                   shift? (.-shiftKey event)]
+
+               (cond
+                 ;; Escape: finalize and stop
+                 (= key "Escape")
+                 (do
+                   (dom/prevent-default event)
+                   (sync-wasm-text-editor-content! :finalize? true)
+                   (text-editor/text-editor-stop))
+
+                 ;; Ctrl+A: select all (key is "a" or "A" depending on platform)
+                 (and ctrl? (= (str/lower key) "a"))
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-select-all)
+                   (wasm.api/request-render "text-select-all"))
+
+                 ;; Enter
+                 (= key "Enter")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-insert-paragraph)
+                   (sync-wasm-text-editor-content!)
+                   (wasm.api/request-render "text-paragraph"))
+
+                 ;; Backspace
+                 (= key "Backspace")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-delete-backward)
+                   (sync-wasm-text-editor-content!)
+                   (wasm.api/request-render "text-delete-backward"))
+
+                 ;; Delete
+                 (= key "Delete")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-delete-forward)
+                   (sync-wasm-text-editor-content!)
+                   (wasm.api/request-render "text-delete-forward"))
+
+                 ;; Arrow keys
+                 (= key "ArrowLeft")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 0 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 (= key "ArrowRight")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 1 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 (= key "ArrowUp")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 2 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 (= key "ArrowDown")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 3 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 (= key "Home")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 4 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 (= key "End")
+                 (do
+                   (dom/prevent-default event)
+                   (text-editor/text-editor-move-cursor 5 shift?)
+                   (wasm.api/request-render "text-cursor-move"))
+
+                 ;; Let contenteditable handle text input via on-input
+                 :else nil)))))
+
+        on-input
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log "event" event)
+           (let [native-event (.-nativeEvent event)
+                 input-type   (.-inputType native-event)
+                 data         (.-data native-event)]
+             ;; Skip composition-related input events - composition-end handles those
+             (when (and (not @composing?)
+                        (not= input-type "insertCompositionText"))
+               (when (and data (seq data))
+                 (text-editor/text-editor-insert-text data)
+                 (sync-wasm-text-editor-content!)
+                 (wasm.api/request-render "text-input"))
+               (when-let [node (mf/ref-val contenteditable-ref)]
+                 (set! (.-textContent node) ""))))))
+
+        on-pointer-down
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event))
+           (let [native-event (dom/event->native-event event)
+                 off-pt (dom/get-offset-position native-event)]
+             (wasm.api/text-editor-pointer-down (.-x off-pt) (.-y off-pt)))))
+
+        on-pointer-move
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event))
+           (let [native-event (dom/event->native-event event)
+                 off-pt (dom/get-offset-position native-event)]
+             (wasm.api/text-editor-pointer-move (.-x off-pt) (.-y off-pt)))))
+
+        on-pointer-up
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event))
+           (let [native-event (dom/event->native-event event)
+                 off-pt (dom/get-offset-position native-event)]
+             (wasm.api/text-editor-pointer-up (.-x off-pt) (.-y off-pt)))))
+
+        on-click
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event))
+           (let [native-event (dom/event->native-event event)
+                 off-pt (dom/get-offset-position native-event)]
+             (wasm.api/text-editor-set-cursor-from-offset (.-x off-pt) (.-y off-pt)))))
+
+        on-focus
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event) event)))
+
+        on-blur
+        (mf/use-fn
+         (fn [^js event]
+           (js/console.log (.-type event) event)
+           (sync-wasm-text-editor-content!)
+           (wasm.api/text-editor-stop)))
+
+        style #js {:pointerEvents "all"
+                   "--editor-container-width" (dm/str width "px")
+                   "--editor-container-height" (dm/str height "px")
+                   "--fallback-families" (if (seq fallback-families) (dm/str (str/join ", " fallback-families)) "sourcesanspro")}]
+
+    ;; Focus contenteditable on mount
+    (mf/use-effect
+     (mf/deps contenteditable-ref)
+     (fn []
+       (when-let [node (mf/ref-val contenteditable-ref)]
+         (js/console.log "focusing")
+         (.focus node))))
+
+    (mf/use-effect
+     (fn []
+       (let [timeout-id (atom nil)
+             schedule-blink (fn schedule-blink []
+                              (when (text-editor/text-editor-is-active?)
+                                (wasm.api/request-render "cursor-blink"))
+                              (reset! timeout-id (js/setTimeout schedule-blink caret-blink-interval-ms)))]
+         (schedule-blink)
+         (fn []
+           (when @timeout-id
+             (js/clearTimeout @timeout-id))))))
+
+    ;; Composition and input events
+    [:g.text-editor {:clip-path (dm/fmt "url(#%)" clip-id)
+                     :transform (dm/str transform)
+                     :data-testid "text-editor"}
+     [:defs
+      [:clipPath {:id clip-id}
+       [:rect {:x x :y y :width width :height height}]]]
+
+     [:foreignObject {:x x :y y :width width :height height}
+      [:div {:on-click on-click
+             :on-pointer-down on-pointer-down
+             :on-pointer-move on-pointer-move
+             :on-pointer-up on-pointer-up
+             :class (stl/css :text-editor)
+             :style style}
+       [:div
+        {:ref contenteditable-ref
+         :contentEditable true
+         :suppressContentEditableWarning true
+         :on-composition-start on-composition-start
+         :on-composition-end on-composition-end
+         :on-key-down on-key-down
+         :on-input on-input
+         :on-paste on-paste
+         :on-copy on-copy
+         :on-focus on-focus
+         :on-blur on-blur
+         ;; FIXME on-click
+         ;; :on-click on-click
+         :id "text-editor-wasm-input"
+         :class (dm/str (cur/get-dynamic "text" (:rotation shape))
+                        " "
+                        (stl/css :text-editor-container))
+         :data-testid "text-editor-container"}]]]]))

frontend/src/app/main/ui/workspace/shapes/text/v3_editor.scss

@@ -0,0 +1,12 @@
+.text-editor {
+  height: 100%;
+}
+
+.text-editor-container {
+  height: 100%;
+  position: absolute;
+
+  opacity: 0;
+  overflow: hidden;
+  white-space: pre;
+}

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

@@ -94,23 +94,8 @@
                (st/emit! (mse/->MouseEvent :down ctrl? shift? alt? meta?)
                          ::dwsp/interrupt)
 
-               (when (wasm.api/text-editor-is-active?)
-                 (wasm.api/text-editor-pointer-down (.-x off-pt) (.-y off-pt)))
-
                (when (and (not= edition id) (or text-editing? grid-editing?))
-                 (st/emit! (dw/clear-edition-mode))
-                 ;; FIXME: I think this is not completely correct because this
-                 ;; is going to happen even when clicking or selecting text.
-                 ;; Sync and stop WASM text editor when exiting edit mode
-                 #_(when (and text-editing?
-                              (features/active-feature? @st/state "render-wasm/v1")
-                              wasm.wasm/context-initialized?)
-                     (when-let [{:keys [shape-id content]} (wasm.api/text-editor-sync-content)]
-                       (st/emit! (dwt/v2-update-text-shape-content
-                                  shape-id content
-                                  :update-name? true
-                                  :finalize? true)))
-                     (wasm.api/text-editor-stop)))
+                 (st/emit! (dw/clear-edition-mode)))
 
                (when (and (not text-editing?)
                           (not blocked)

frontend/src/app/main/ui/workspace/viewport_wasm.cljs

@@ -30,6 +30,7 @@
    [app.main.ui.workspace.shapes.text.editor :as editor-v1]
    [app.main.ui.workspace.shapes.text.text-edition-outline :refer [text-edition-outline]]
    [app.main.ui.workspace.shapes.text.v2-editor :as editor-v2]
+   [app.main.ui.workspace.shapes.text.v3-editor :as editor-v3]
    [app.main.ui.workspace.top-toolbar :refer [top-toolbar*]]
    [app.main.ui.workspace.viewport.actions :as actions]
    [app.main.ui.workspace.viewport.comments :as comments]
@@ -54,7 +55,6 @@
    [app.main.ui.workspace.viewport.viewport-ref :refer [create-viewport-ref]]
    [app.main.ui.workspace.viewport.widgets :as widgets]
    [app.render-wasm.api :as wasm.api]
-   [app.render-wasm.text-editor-input :refer [text-editor-input]]
    [app.util.debug :as dbg]
    [app.util.text-editor :as ted]
    [beicon.v2.core :as rx]
@@ -328,10 +328,14 @@
 
     (mf/with-effect [show-text-editor? workspace-editor-state edition]
       (let [active-editor-state (get workspace-editor-state edition)]
+        (js/console.log "show-text-editor?" show-text-editor?)
         (when (and show-text-editor? active-editor-state)
           (let [content (-> active-editor-state
                             (ted/get-editor-current-content)
                             (ted/export-content))]
+            (when-not (wasm.api/text-editor-is-active? edition)
+              (prn "hola")
+              (wasm.api/text-editor-start edition))
             (wasm.api/use-shape edition)
             (wasm.api/set-shape-text-content edition content)
             (let [dimension (wasm.api/get-text-dimensions)]
@@ -417,14 +421,7 @@
 
       (when picking-color?
         [:> pixel-overlay/pixel-overlay-wasm* {:viewport-ref viewport-ref
-                                               :canvas-ref canvas-ref}])
-
-      ;; WASM text editor contenteditable (must be outside SVG to work)
-      (when (and show-text-editor?
-                 (features/active-feature? @st/state "text-editor-wasm/v1"))
-        [:& text-editor-input {:shape editing-shape
-                               :zoom zoom
-                               :vbox vbox}])]
+                                               :canvas-ref canvas-ref}])]
 
      [:canvas {:id "render"
                :data-testid "canvas-wasm-shapes"
@@ -471,14 +468,20 @@
       [:g {:style {:pointer-events (if disable-events? "none" "auto")}}
        ;; Text editor handling:
        ;; - When text-editor-wasm/v1 is active, contenteditable is rendered in viewport-overlays (HTML DOM)
-       (when (and show-text-editor?
-                  (not (features/active-feature? @st/state "text-editor-wasm/v1")))
-         (if (features/active-feature? @st/state "text-editor/v2")
+       (when show-text-editor?
+         (cond
+           (features/active-feature? @st/state "text-editor-wasm/v1")
+           [:& editor-v3/text-editor {:shape editing-shape
+                                      :canvas-ref canvas-ref
+                                      :ref text-editor-ref}]
+
+           (features/active-feature? @st/state "text-editor/v2")
            [:& editor-v2/text-editor {:shape editing-shape
                                       :canvas-ref canvas-ref
                                       :ref text-editor-ref}]
-           [:& editor-v1/text-editor-svg {:shape editing-shape
-                                          :ref text-editor-ref}]))
+
+           :else [:& editor-v1/text-editor-svg {:shape editing-shape
+                                                :ref text-editor-ref}]))
 
        (when show-frame-outline?
          (let [outlined-frame-id

frontend/src/app/render_wasm/api.cljs

@@ -86,6 +86,7 @@
 ;; Re-export public text editor functions
 (def text-editor-start text-editor/text-editor-start)
 (def text-editor-stop text-editor/text-editor-stop)
+(def text-editor-set-cursor-from-offset text-editor/text-editor-set-cursor-from-offset)
 (def text-editor-set-cursor-from-point text-editor/text-editor-set-cursor-from-point)
 (def text-editor-pointer-down text-editor/text-editor-pointer-down)
 (def text-editor-pointer-move text-editor/text-editor-pointer-move)

frontend/src/app/render_wasm/helpers.cljc

@@ -7,28 +7,11 @@
 (ns app.render-wasm.helpers
   #?(:cljs (:require-macros [app.render-wasm.helpers])))
 
-(def ^:export error-code
-  "WASM error code constants (must match render-wasm/src/error.rs and mem.rs)."
-  {0x01 :wasm-non-blocking 0x02 :wasm-critical})
-
 (defmacro call
-  "A helper for easy call wasm defined function in a module.
-   Catches any exception thrown by the WASM function, reads the error code from
-   WASM when available, and rethrows ex-info with :type (:wasm-non-blocking or
-   :wasm-critical) in ex-data. The uncaught-error-handler in app.main.errors
-   routes these to on-error so critical shows Internal Error, non-blocking shows toast."
+  "A helper for easy call wasm defined function in a module."
   [module name & params]
-  (let [fn-sym   (with-meta (gensym "fn-") {:tag 'function})
-        e-sym    (gensym "e")
-        code-sym (gensym "code")]
+  (let [fn-sym (with-meta (gensym "fn-") {:tag 'function})]
     `(let [~fn-sym (cljs.core/unchecked-get ~module ~name)]
-       (try
-         (~fn-sym ~@params)
-         (catch :default ~e-sym
-           (let [read-code# (cljs.core/unchecked-get ~module "_read_error_code")
-                 ~code-sym (when read-code# (read-code#))
-                 type#    (or (get app.render-wasm.helpers/error-code ~code-sym) :wasm-critical)
-                 ex#      (ex-info (str "WASM error (type: " type# ")")
-                                   {:fn ~name :type type# :message (.-message ~e-sym) :error-code ~code-sym}
-                                   ~e-sym)]
-             (throw ex#)))))))
+       ;; DEBUG
+       ;; (println "##" ~name)
+       (~fn-sym ~@params))))

frontend/src/app/render_wasm/text_editor.cljs

@@ -22,7 +22,14 @@
               (aget buffer 2)
               (aget buffer 3)))))
 
+(defn text-editor-set-cursor-from-offset
+  "Sets caret position from shape relative coordinates"
+  [x y]
+  (when wasm/context-initialized?
+    (h/call wasm/internal-module "_text_editor_set_cursor_from_offset" x y)))
+
 (defn text-editor-set-cursor-from-point
+  "Sets caret position from screen (canvas) coordinates"
   [x y]
   (when wasm/context-initialized?
     (h/call wasm/internal-module "_text_editor_set_cursor_from_point" x y)))

frontend/src/app/render_wasm/text_editor_input.cljs

@@ -203,6 +203,7 @@
           on-input
           (mf/use-fn
            (fn [^js event]
+             (js/console.log "event" event)
              (let [native-event (.-nativeEvent event)
                    input-type   (.-inputType native-event)
                    data         (.-data native-event)]
@@ -214,7 +215,17 @@
                    (sync-wasm-text-editor-content!)
                    (wasm.api/request-render "text-input"))
                  (when-let [node (mf/ref-val contenteditable-ref)]
-                   (set! (.-textContent node) ""))))))]
+                   (set! (.-textContent node) ""))))))
+
+          on-focus
+          (mf/use-fn
+           (fn [^js event]
+             (js/console.log (.-type event) event)))
+
+          on-blur
+          (mf/use-fn
+           (fn [^js event]
+             (js/console.log (.-type event) event)))]
 
       [:div
        {:ref contenteditable-ref
@@ -225,6 +236,8 @@
         :on-input on-input
         :on-paste on-paste
         :on-copy on-copy
+        :on-focus on-focus
+        :on-blur on-blur
         ;; FIXME on-click
         ;; :on-click on-click
         :id "text-editor-wasm-input"

render-wasm/Cargo.lock

@@ -297,8 +297,6 @@ name = "macros"
 version = "0.1.0"
 dependencies = [
  "heck",
- "proc-macro2",
- "quote",
  "syn",
 ]
 
@@ -428,7 +426,6 @@ dependencies = [
  "indexmap",
  "macros",
  "skia-safe",
- "thiserror",
  "uuid",
 ]
 
@@ -582,26 +579,6 @@ dependencies = [
  "xattr",
 ]
 
-[[package]]
-name = "thiserror"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "toml"
 version = "1.0.3+spec-1.1.0"

render-wasm/Cargo.toml

@@ -32,7 +32,6 @@ skia-safe = { version = "0.93.1", default-features = false, features = [
   "binary-cache",
   "webp",
 ] }
-thiserror = "2.0.18"
 uuid = { version = "1.11.0", features = ["v4", "js"] }
 
 [profile.release]

render-wasm/macros/Cargo.lock

@@ -13,8 +13,6 @@ name = "macros"
 version = "0.1.0"
 dependencies = [
  "heck",
- "proc-macro2",
- "quote",
  "syn",
 ]
 

render-wasm/macros/Cargo.toml

@@ -1,13 +1,11 @@
 [package]
 name = "macros"
 version = "0.1.0"
-edition = "2021"
+edition = "2024"
 
 [lib]
 proc-macro = true
 
 [dependencies]
 heck = "0.5.0"
-proc-macro2 = "1.0"
-quote = "1.0"
 syn = "2.0.106"

render-wasm/macros/src/lib.rs

@@ -6,109 +6,9 @@ use std::sync;
 
 use heck::{ToKebabCase, ToPascalCase};
 use proc_macro::TokenStream;
-use quote::quote;
-use syn::{parse_macro_input, Block, GenericArgument, ItemFn, ReturnType, Type};
 
 type Result<T> = std::result::Result<T, String>;
 
-/// Attribute macro for WASM-exported functions. The function **must** return
-/// `std::result::Result<T, E>` where T is a C ABI type and E implements
-/// `std::error::Error` and `Into<u8>`. The macro:
-/// - Clears the error code at entry.
-/// - Runs the body in `std::panic::catch_unwind`.
-/// - Unwraps the Result: `Ok(x)` → return x; `Err(e)` → set error code in memory and panic
-///   (so ClojureScript can catch the exception and read the code via `read_error_code`).
-/// - On panic from the body: sets critical error code (0x02) and resumes unwind.
-#[proc_macro_attribute]
-pub fn wasm_error(_attr: TokenStream, item: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(item as ItemFn);
-    let body = (*input.block).clone();
-
-    let (attrs, boxed_ty) = match &input.sig.output {
-        ReturnType::Type(attrs, boxed_ty) => (attrs, boxed_ty),
-        ReturnType::Default => {
-            return quote! {
-                compile_error!(
-                    "#[wasm_error] requires the function to return std::result::Result<T, E> where E: std::error::Error + Into<u8>"
-                );
-            }
-            .into();
-        }
-    };
-
-    let (inner_ty, error_ty) = match crate_error_result_inner_type(boxed_ty) {
-        Some(t) => (t, quote!(crate::error::Error)),
-        None => {
-            return quote! {
-                    compile_error!(
-                        "#[wasm_error] requires the function to return crate::error::Result<T>. T must be a C ABI type (u32, u8, bool, (), etc.)"
-                    );
-                }
-                .into();
-        }
-    };
-
-    let block: Block = syn::parse2(quote! {
-        {
-            crate::mem::clear_error_code();
-            let __wasm_err_result = std::panic::catch_unwind(|| -> std::result::Result<#inner_ty, #error_ty> {
-                #body
-            });
-            match __wasm_err_result {
-                Ok(__inner) => match __inner {
-                    Ok(__val) => __val,
-                    Err(__e) => {
-                        let _: &dyn std::error::Error = &__e;
-                        let __msg = __e.to_string();
-                        crate::mem::set_error_code(__e.into());
-                        panic!("WASM error: {}",__msg);
-                    }
-                },
-                Err(__payload) => {
-                    crate::mem::set_error_code(0x02); // critical, same as Error::Critical
-                    std::panic::resume_unwind(__payload);
-                }
-            }
-        }
-    })
-    .expect("block parse");
-
-    input.sig.output = ReturnType::Type(attrs.clone(), Box::new(inner_ty.clone()));
-    input.block = Box::new(block);
-    quote! { #input }.into()
-}
-
-/// If the type is crate::error::Result<T> or a single-segment Result<T> (e.g. with
-/// `use crate::error::Result`), returns Some(T). Otherwise None.
-fn crate_error_result_inner_type(ty: &Type) -> Option<&Type> {
-    let path = match ty {
-        Type::Path(tp) => &tp.path,
-        _ => return None,
-    };
-    let segs: Vec<_> = path.segments.iter().collect();
-    let last = path.segments.last()?;
-    if last.ident != "Result" {
-        return None;
-    }
-    let args = match &last.arguments {
-        syn::PathArguments::AngleBracketed(a) => &a.args,
-        _ => return None,
-    };
-    if args.len() != 1 {
-        return None;
-    }
-    // Accept crate::error::Result<T> or bare Result<T> (from use)
-    let ok = segs.len() == 1
-        || (segs.len() == 3 && segs[0].ident == "crate" && segs[1].ident == "error");
-    if !ok {
-        return None;
-    }
-    match &args[0] {
-        GenericArgument::Type(t) => Some(t),
-        _ => None,
-    }
-}
-
 #[proc_macro_derive(ToJs)]
 pub fn derive_to_cljs(input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as syn::DeriveInput);

render-wasm/src/error.rs

@@ -1,25 +0,0 @@
-use thiserror::Error;
-
-pub const RECOVERABLE_ERROR: u8 = 0x01;
-pub const CRITICAL_ERROR: u8 = 0x02;
-
-// This is not really dead code, #[wasm_error] macro replaces this by something else.
-#[allow(dead_code)]
-pub type Result<T> = std::result::Result<T, Error>;
-
-#[derive(Error, Debug)]
-pub enum Error {
-    #[error("[Recoverable] {0}")]
-    RecoverableError(String),
-    #[error("[Critical] {0}")]
-    CriticalError(String),
-}
-
-impl From<Error> for u8 {
-    fn from(error: Error) -> Self {
-        match error {
-            Error::RecoverableError(_) => RECOVERABLE_ERROR,
-            Error::CriticalError(_) => CRITICAL_ERROR,
-        }
-    }
-}

render-wasm/src/main.rs

@@ -1,6 +1,5 @@
 #[cfg(target_arch = "wasm32")]
 mod emscripten;
-mod error;
 mod math;
 mod mem;
 mod options;
@@ -15,16 +14,12 @@ mod view;
 mod wapi;
 mod wasm;
 
-use std::collections::HashMap;
-
-#[allow(unused_imports)]
-use crate::error::{Error, Result};
-use macros::wasm_error;
 use math::{Bounds, Matrix};
 use mem::SerializableResult;
 use shapes::{StructureEntry, StructureEntryType, TransformEntry};
 use skia_safe as skia;
 use state::State;
+use std::collections::HashMap;
 use utils::uuid_from_u32_quartet;
 use uuid::Uuid;
 
@@ -100,27 +95,22 @@ macro_rules! with_state_mut_current_shape {
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn init(width: i32, height: i32) -> Result<()> {
+pub extern "C" fn init(width: i32, height: i32) {
     let state_box = Box::new(State::new(width, height));
     unsafe {
         STATE = Some(state_box);
     }
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_browser(browser: u8) -> Result<()> {
+pub extern "C" fn set_browser(browser: u8) {
     with_state_mut!(state, {
         state.set_browser(browser);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn clean_up() -> Result<()> {
+pub extern "C" fn clean_up() {
     with_state_mut!(state, {
         // Cancel the current animation frame if it exists so
         // it won't try to render without context
@@ -128,60 +118,49 @@ pub extern "C" fn clean_up() -> Result<()> {
         render_state.cancel_animation_frame();
     });
     unsafe { STATE = None }
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_render_options(debug: u32, dpr: f32) -> Result<()> {
+pub extern "C" fn set_render_options(debug: u32, dpr: f32) {
     with_state_mut!(state, {
         let render_state = state.render_state_mut();
         render_state.set_debug_flags(debug);
         render_state.set_dpr(dpr);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_canvas_background(raw_color: u32) -> Result<()> {
+pub extern "C" fn set_canvas_background(raw_color: u32) {
     with_state_mut!(state, {
         let color = skia::Color::new(raw_color);
         state.set_background_color(color);
         state.rebuild_tiles_shallow();
     });
-
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn render(_: i32) -> Result<()> {
+pub extern "C" fn render(_: i32) {
     with_state_mut!(state, {
         state.rebuild_touched_tiles();
         state
             .start_render_loop(performance::get_time())
             .expect("Error rendering");
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn render_sync() -> Result<()> {
+pub extern "C" fn render_sync() {
     with_state_mut!(state, {
         state.rebuild_tiles();
         state
             .render_sync(performance::get_time())
             .expect("Error rendering");
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn render_sync_shape(a: u32, b: u32, c: u32, d: u32) -> Result<()> {
+pub extern "C" fn render_sync_shape(a: u32, b: u32, c: u32, d: u32) {
     with_state_mut!(state, {
         let id = uuid_from_u32_quartet(a, b, c, d);
         state.use_shape(id);
@@ -200,42 +179,34 @@ pub extern "C" fn render_sync_shape(a: u32, b: u32, c: u32, d: u32) -> Result<()
         state.rebuild_tiles_from(Some(&id));
         state
             .render_sync_shape(&id, performance::get_time())
-            .map_err(|e| Error::RecoverableError(e.to_string()))?;
+            .expect("Error rendering");
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn render_from_cache(_: i32) -> Result<()> {
+pub extern "C" fn render_from_cache(_: i32) {
     with_state_mut!(state, {
         state.render_state.cancel_animation_frame();
         state.render_from_cache();
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_preview_mode(enabled: bool) -> Result<()> {
+pub extern "C" fn set_preview_mode(enabled: bool) {
     with_state_mut!(state, {
         state.render_state.set_preview_mode(enabled);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn render_preview() -> Result<()> {
+pub extern "C" fn render_preview() {
     with_state_mut!(state, {
         state.render_preview(performance::get_time());
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn process_animation_frame(timestamp: i32) -> Result<()> {
+pub extern "C" fn process_animation_frame(timestamp: i32) {
     let result = std::panic::catch_unwind(|| {
         with_state_mut!(state, {
             state
@@ -254,45 +225,37 @@ pub extern "C" fn process_animation_frame(timestamp: i32) -> Result<()> {
             std::panic::resume_unwind(err);
         }
     }
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn reset_canvas() -> Result<()> {
+pub extern "C" fn reset_canvas() {
     with_state_mut!(state, {
         state.render_state_mut().reset_canvas();
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn resize_viewbox(width: i32, height: i32) -> Result<()> {
+pub extern "C" fn resize_viewbox(width: i32, height: i32) {
     with_state_mut!(state, {
         state.resize(width, height);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_view(zoom: f32, x: f32, y: f32) -> Result<()> {
+pub extern "C" fn set_view(zoom: f32, x: f32, y: f32) {
     with_state_mut!(state, {
         performance::begin_measure!("set_view");
         let render_state = state.render_state_mut();
         render_state.set_view(zoom, x, y);
         performance::end_measure!("set_view");
     });
-    Ok(())
 }
 
 #[cfg(feature = "profile-macros")]
 static mut VIEW_INTERACTION_START: i32 = 0;
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_view_start() -> Result<()> {
+pub extern "C" fn set_view_start() {
     with_state_mut!(state, {
         #[cfg(feature = "profile-macros")]
         unsafe {
@@ -302,12 +265,10 @@ pub extern "C" fn set_view_start() -> Result<()> {
         state.render_state.options.set_fast_mode(true);
         performance::end_measure!("set_view_start");
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_view_end() -> Result<()> {
+pub extern "C" fn set_view_end() {
     with_state_mut!(state, {
         let _end_start = performance::begin_timed_log!("set_view_end");
         performance::begin_measure!("set_view_end");
@@ -343,21 +304,17 @@ pub extern "C" fn set_view_end() -> Result<()> {
             performance::console_log!("[PERF] view_interaction: {}ms", total_time);
         }
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn clear_focus_mode() -> Result<()> {
+pub extern "C" fn clear_focus_mode() {
     with_state_mut!(state, {
         state.clear_focus_mode();
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_focus_mode() -> Result<()> {
+pub extern "C" fn set_focus_mode() {
     let bytes = mem::bytes();
 
     let entries: Vec<Uuid> = bytes
@@ -368,111 +325,83 @@ pub extern "C" fn set_focus_mode() -> Result<()> {
     with_state_mut!(state, {
         state.set_focus_mode(entries);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn init_shapes_pool(capacity: usize) -> Result<()> {
+pub extern "C" fn init_shapes_pool(capacity: usize) {
     with_state_mut!(state, {
         state.init_shapes_pool(capacity);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn use_shape(a: u32, b: u32, c: u32, d: u32) -> Result<()> {
+pub extern "C" fn use_shape(a: u32, b: u32, c: u32, d: u32) {
     with_state_mut!(state, {
         let id = uuid_from_u32_quartet(a, b, c, d);
         state.use_shape(id);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn touch_shape(a: u32, b: u32, c: u32, d: u32) -> Result<()> {
+pub extern "C" fn touch_shape(a: u32, b: u32, c: u32, d: u32) {
     with_state_mut!(state, {
         let shape_id = uuid_from_u32_quartet(a, b, c, d);
         state.touch_shape(shape_id);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_parent(a: u32, b: u32, c: u32, d: u32) -> Result<()> {
+pub extern "C" fn set_parent(a: u32, b: u32, c: u32, d: u32) {
     with_state_mut!(state, {
         let id = uuid_from_u32_quartet(a, b, c, d);
         state.set_parent_for_current_shape(id);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_masked_group(masked: bool) -> Result<()> {
+pub extern "C" fn set_shape_masked_group(masked: bool) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_masked(masked);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_selrect(left: f32, top: f32, right: f32, bottom: f32) -> Result<()> {
+pub extern "C" fn set_shape_selrect(left: f32, top: f32, right: f32, bottom: f32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_selrect(left, top, right, bottom);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_clip_content(clip_content: bool) -> Result<()> {
+pub extern "C" fn set_shape_clip_content(clip_content: bool) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_clip(clip_content);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_rotation(rotation: f32) -> Result<()> {
+pub extern "C" fn set_shape_rotation(rotation: f32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_rotation(rotation);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_transform(
-    a: f32,
-    b: f32,
-    c: f32,
-    d: f32,
-    e: f32,
-    f: f32,
-) -> Result<()> {
+pub extern "C" fn set_shape_transform(a: f32, b: f32, c: f32, d: f32, e: f32, f: f32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_transform(a, b, c, d, e, f);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn add_shape_child(a: u32, b: u32, c: u32, d: u32) -> Result<()> {
+pub extern "C" fn add_shape_child(a: u32, b: u32, c: u32, d: u32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         let id = uuid_from_u32_quartet(a, b, c, d);
         shape.add_child(id);
     });
-    Ok(())
 }
 
-fn set_children_set(entries: Vec<Uuid>) -> Result<()> {
+fn set_children_set(entries: Vec<Uuid>) {
     let mut deleted = Vec::new();
     let mut parent_id = None;
 
@@ -491,9 +420,7 @@ fn set_children_set(entries: Vec<Uuid>) -> Result<()> {
 
     with_state_mut!(state, {
         let Some(parent_id) = parent_id else {
-            return Err(Error::RecoverableError(
-                "set_children_set: Parent ID not found".to_string(),
-            ));
+            return;
         };
 
         for id in deleted {
@@ -501,27 +428,21 @@ fn set_children_set(entries: Vec<Uuid>) -> Result<()> {
             state.touch_shape(id);
         }
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_children_0() -> Result<()> {
+pub extern "C" fn set_children_0() {
     let entries = vec![];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_children_1(a1: u32, b1: u32, c1: u32, d1: u32) -> Result<()> {
+pub extern "C" fn set_children_1(a1: u32, b1: u32, c1: u32, d1: u32) {
     let entries = vec![uuid_from_u32_quartet(a1, b1, c1, d1)];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
 pub extern "C" fn set_children_2(
     a1: u32,
     b1: u32,
@@ -531,17 +452,15 @@ pub extern "C" fn set_children_2(
     b2: u32,
     c2: u32,
     d2: u32,
-) -> Result<()> {
+) {
     let entries = vec![
         uuid_from_u32_quartet(a1, b1, c1, d1),
         uuid_from_u32_quartet(a2, b2, c2, d2),
     ];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
 pub extern "C" fn set_children_3(
     a1: u32,
     b1: u32,
@@ -555,18 +474,16 @@ pub extern "C" fn set_children_3(
     b3: u32,
     c3: u32,
     d3: u32,
-) -> Result<()> {
+) {
     let entries = vec![
         uuid_from_u32_quartet(a1, b1, c1, d1),
         uuid_from_u32_quartet(a2, b2, c2, d2),
         uuid_from_u32_quartet(a3, b3, c3, d3),
     ];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
 pub extern "C" fn set_children_4(
     a1: u32,
     b1: u32,
@@ -584,19 +501,17 @@ pub extern "C" fn set_children_4(
     b4: u32,
     c4: u32,
     d4: u32,
-) -> Result<()> {
+) {
     let entries = vec![
         uuid_from_u32_quartet(a1, b1, c1, d1),
         uuid_from_u32_quartet(a2, b2, c2, d2),
         uuid_from_u32_quartet(a3, b3, c3, d3),
         uuid_from_u32_quartet(a4, b4, c4, d4),
     ];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
 pub extern "C" fn set_children_5(
     a1: u32,
     b1: u32,
@@ -618,7 +533,7 @@ pub extern "C" fn set_children_5(
     b5: u32,
     c5: u32,
     d5: u32,
-) -> Result<()> {
+) {
     let entries = vec![
         uuid_from_u32_quartet(a1, b1, c1, d1),
         uuid_from_u32_quartet(a2, b2, c2, d2),
@@ -626,13 +541,11 @@ pub extern "C" fn set_children_5(
         uuid_from_u32_quartet(a4, b4, c4, d4),
         uuid_from_u32_quartet(a5, b5, c5, d5),
     ];
-    set_children_set(entries)?;
-    Ok(())
+    set_children_set(entries);
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_children() -> Result<()> {
+pub extern "C" fn set_children() {
     let bytes = mem::bytes_or_empty();
 
     let entries: Vec<Uuid> = bytes
@@ -640,76 +553,58 @@ pub extern "C" fn set_children() -> Result<()> {
         .map(|data| Uuid::try_from(data).unwrap())
         .collect();
 
-    set_children_set(entries)?;
+    set_children_set(entries);
 
     if !bytes.is_empty() {
-        mem::free_bytes()?;
+        mem::free_bytes();
     }
-
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn is_image_cached(
-    a: u32,
-    b: u32,
-    c: u32,
-    d: u32,
-    is_thumbnail: bool,
-) -> Result<bool> {
+pub extern "C" fn is_image_cached(a: u32, b: u32, c: u32, d: u32, is_thumbnail: bool) -> bool {
     with_state_mut!(state, {
         let id = uuid_from_u32_quartet(a, b, c, d);
-        let result = state.render_state().has_image(&id, is_thumbnail);
-        Ok(result)
+        state.render_state().has_image(&id, is_thumbnail)
     })
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_svg_raw_content() -> Result<()> {
+pub extern "C" fn set_shape_svg_raw_content() {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         let bytes = mem::bytes();
         let svg_raw_content = String::from_utf8(bytes)
-            .map_err(|e| Error::RecoverableError(e.to_string()))?
+            .unwrap()
             .trim_end_matches('\0')
             .to_string();
-        shape.set_svg_raw_content(svg_raw_content);
+        shape
+            .set_svg_raw_content(svg_raw_content)
+            .expect("Failed to set svg raw content");
     });
-
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_opacity(opacity: f32) -> Result<()> {
+pub extern "C" fn set_shape_opacity(opacity: f32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_opacity(opacity);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_hidden(hidden: bool) -> Result<()> {
+pub extern "C" fn set_shape_hidden(hidden: bool) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_hidden(hidden);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_corners(r1: f32, r2: f32, r3: f32, r4: f32) -> Result<()> {
+pub extern "C" fn set_shape_corners(r1: f32, r2: f32, r3: f32, r4: f32) {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         shape.set_corners((r1, r2, r3, r4));
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn get_selection_rect() -> Result<*mut u8> {
+pub extern "C" fn get_selection_rect() -> *mut u8 {
     let bytes = mem::bytes();
 
     let entries: Vec<Uuid> = bytes
@@ -724,41 +619,40 @@ pub extern "C" fn get_selection_rect() -> Result<*mut u8> {
         })
         .collect();
 
-    let result_bound = with_state_mut!(state, {
+    with_state_mut!(state, {
         let bbs: Vec<_> = entries
             .iter()
             .flat_map(|id| state.shapes.get(id).map(|b| b.bounds()))
             .collect();
 
-        if bbs.len() == 1 {
+        let result_bound = if bbs.len() == 1 {
             bbs[0]
         } else {
             Bounds::join_bounds(&bbs)
-        }
-    });
+        };
 
-    let width = result_bound.width();
-    let height = result_bound.height();
-    let center = result_bound.center();
-    let transform = result_bound.transform_matrix().unwrap_or(Matrix::default());
+        let width = result_bound.width();
+        let height = result_bound.height();
+        let center = result_bound.center();
+        let transform = result_bound.transform_matrix().unwrap_or(Matrix::default());
 
-    let mut bytes = vec![0; 40];
-    bytes[0..4].clone_from_slice(&width.to_le_bytes());
-    bytes[4..8].clone_from_slice(&height.to_le_bytes());
-    bytes[8..12].clone_from_slice(&center.x.to_le_bytes());
-    bytes[12..16].clone_from_slice(&center.y.to_le_bytes());
-    bytes[16..20].clone_from_slice(&transform[0].to_le_bytes());
-    bytes[20..24].clone_from_slice(&transform[3].to_le_bytes());
-    bytes[24..28].clone_from_slice(&transform[1].to_le_bytes());
-    bytes[28..32].clone_from_slice(&transform[4].to_le_bytes());
-    bytes[32..36].clone_from_slice(&transform[2].to_le_bytes());
-    bytes[36..40].clone_from_slice(&transform[5].to_le_bytes());
-    Ok(mem::write_bytes(bytes))
+        let mut bytes = vec![0; 40];
+        bytes[0..4].clone_from_slice(&width.to_le_bytes());
+        bytes[4..8].clone_from_slice(&height.to_le_bytes());
+        bytes[8..12].clone_from_slice(&center.x.to_le_bytes());
+        bytes[12..16].clone_from_slice(&center.y.to_le_bytes());
+        bytes[16..20].clone_from_slice(&transform[0].to_le_bytes());
+        bytes[20..24].clone_from_slice(&transform[3].to_le_bytes());
+        bytes[24..28].clone_from_slice(&transform[1].to_le_bytes());
+        bytes[28..32].clone_from_slice(&transform[4].to_le_bytes());
+        bytes[32..36].clone_from_slice(&transform[2].to_le_bytes());
+        bytes[36..40].clone_from_slice(&transform[5].to_le_bytes());
+        mem::write_bytes(bytes)
+    })
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_structure_modifiers() -> Result<()> {
+pub extern "C" fn set_structure_modifiers() {
     let bytes = mem::bytes();
 
     let entries: Vec<_> = bytes
@@ -796,22 +690,18 @@ pub extern "C" fn set_structure_modifiers() -> Result<()> {
         }
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn clean_modifiers() -> Result<()> {
+pub extern "C" fn clean_modifiers() {
     with_state_mut!(state, {
         state.shapes.clean_all();
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_modifiers() -> Result<()> {
+pub extern "C" fn set_modifiers() {
     let bytes = mem::bytes();
 
     let entries: Vec<_> = bytes
@@ -830,31 +720,26 @@ pub extern "C" fn set_modifiers() -> Result<()> {
         state.set_modifiers(modifiers);
         state.rebuild_modifier_tiles(ids);
     });
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn start_temp_objects() -> Result<()> {
+pub extern "C" fn start_temp_objects() {
     unsafe {
         #[allow(static_mut_refs)]
         let mut state = STATE.take().expect("Got an invalid state pointer");
         state = Box::new(state.start_temp_objects());
         STATE = Some(state);
     }
-    Ok(())
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn end_temp_objects() -> Result<()> {
+pub extern "C" fn end_temp_objects() {
     unsafe {
         #[allow(static_mut_refs)]
         let mut state = STATE.take().expect("Got an invalid state pointer");
         state = Box::new(state.end_temp_objects());
         STATE = Some(state);
     }
-    Ok(())
 }
 
 fn main() {

render-wasm/src/mem.rs

@@ -1,29 +1,29 @@
+use std::alloc::{alloc, Layout};
+use std::ptr;
 use std::sync::Mutex;
 
-use crate::error::{Error, Result, CRITICAL_ERROR};
+const LAYOUT_ALIGN: usize = 4;
 
-pub const LAYOUT_ALIGN: usize = 4;
-
-pub static BUFFERU8: Mutex<Option<Vec<u8>>> = Mutex::new(None);
-pub static BUFFER_ERROR: Mutex<u8> = Mutex::new(0x00);
-
-pub fn clear_error_code() {
-    let mut guard = BUFFER_ERROR.lock().unwrap();
-    *guard = 0x00;
-}
-
-/// Sets the error buffer from a byte. Used by #[wasm_error] when E: Into<u8>.
-pub fn set_error_code(code: u8) {
-    let mut guard = BUFFER_ERROR.lock().unwrap();
-    *guard = code;
-}
+static BUFFERU8: Mutex<Option<Vec<u8>>> = Mutex::new(None);
 
 #[no_mangle]
-pub extern "C" fn read_error_code() -> u8 {
-    if let Ok(guard) = BUFFER_ERROR.lock() {
-        *guard
-    } else {
-        CRITICAL_ERROR
+pub extern "C" fn alloc_bytes(len: usize) -> *mut u8 {
+    let mut guard = BUFFERU8.lock().unwrap();
+
+    if guard.is_some() {
+        panic!("Bytes already allocated");
+    }
+
+    unsafe {
+        let layout = Layout::from_size_align_unchecked(len, LAYOUT_ALIGN);
+        let ptr = alloc(layout);
+        if ptr.is_null() {
+            panic!("Allocation failed");
+        }
+        // TODO: Maybe this could be removed.
+        ptr::write_bytes(ptr, 0, len);
+        *guard = Some(Vec::from_raw_parts(ptr, len, len));
+        ptr
     }
 }
 
@@ -40,6 +40,13 @@ pub fn write_bytes(mut bytes: Vec<u8>) -> *mut u8 {
     ptr
 }
 
+#[no_mangle]
+pub extern "C" fn free_bytes() {
+    let mut guard = BUFFERU8.lock().unwrap();
+    *guard = None;
+    std::mem::drop(guard);
+}
+
 pub fn bytes() -> Vec<u8> {
     let mut guard = BUFFERU8.lock().unwrap();
     guard.take().expect("Buffer is not initialized")
@@ -50,15 +57,6 @@ pub fn bytes_or_empty() -> Vec<u8> {
     guard.take().unwrap_or_default()
 }
 
-pub fn free_bytes() -> Result<()> {
-    let mut guard = BUFFERU8
-        .lock()
-        .map_err(|_| Error::CriticalError("Failed to lock buffer".to_string()))?;
-    *guard = None;
-    std::mem::drop(guard);
-    Ok(())
-}
-
 pub trait SerializableResult: From<Self::BytesType> + Into<Self::BytesType> {
     type BytesType;
     fn clone_to_slice(&self, slice: &mut [u8]);

render-wasm/src/shapes.rs

@@ -705,8 +705,9 @@ impl Shape {
         self.invalidate_extrect();
     }
 
-    pub fn set_svg_raw_content(&mut self, content: String) {
+    pub fn set_svg_raw_content(&mut self, content: String) -> Result<(), String> {
         self.shape_type = Type::SVGRaw(SVGRaw::from_content(content));
+        Ok(())
     }
 
     pub fn set_blend_mode(&mut self, mode: BlendMode) {

render-wasm/src/state/text_editor.rs

@@ -142,9 +142,9 @@ impl TextEditorState {
         self.is_active = false;
         self.active_shape_id = None;
         self.cursor_visible = false;
+        self.last_blink_time = 0.0;
         self.is_pointer_selection_active = false;
         self.pending_events.clear();
-        self.reset_blink();
     }
 
     pub fn start_pointer_selection(&mut self) -> bool {
@@ -195,13 +195,11 @@ impl TextEditorState {
 
     pub fn set_caret_from_position(&mut self, position: &TextPositionWithAffinity) {
         self.selection.set_caret(*position);
-        self.reset_blink();
         self.push_event(TextEditorEvent::SelectionChanged);
     }
 
     pub fn extend_selection_from_position(&mut self, position: &TextPositionWithAffinity) {
         self.selection.extend_to(*position);
-        self.reset_blink();
         self.push_event(TextEditorEvent::SelectionChanged);
     }
 

render-wasm/src/wasm.rs

@@ -3,7 +3,6 @@ pub mod blurs;
 pub mod fills;
 pub mod fonts;
 pub mod layouts;
-pub mod mem;
 pub mod paths;
 pub mod shadows;
 pub mod shapes;

render-wasm/src/wasm/fills.rs

@@ -1,4 +1,4 @@
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 
 use crate::mem;
 use crate::shapes;
@@ -67,8 +67,7 @@ pub fn parse_fills_from_bytes(buffer: &[u8], num_fills: usize) -> Vec<shapes::Fi
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_fills() -> Result<()> {
+pub extern "C" fn set_shape_fills() {
     with_current_shape_mut!(state, |shape: &mut Shape| {
         let bytes = mem::bytes();
         // The first byte contains the actual number of fills
@@ -76,9 +75,8 @@ pub extern "C" fn set_shape_fills() -> Result<()> {
         // Skip the first 4 bytes (header with fill count) and parse only the actual fills
         let fills = parse_fills_from_bytes(&bytes[4..], num_fills);
         shape.set_fills(fills);
-        mem::free_bytes()?;
+        mem::free_bytes();
     });
-    Ok(())
 }
 
 #[no_mangle]

render-wasm/src/wasm/fills/image.rs

@@ -1,7 +1,5 @@
 use crate::mem;
-use macros::wasm_error;
 // use crate::mem::SerializableResult;
-use crate::error::Error;
 use crate::uuid::Uuid;
 use crate::with_state_mut;
 use crate::STATE;
@@ -67,8 +65,7 @@ impl TryFrom<Vec<u8>> for ShapeImageIds {
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn store_image() -> crate::error::Result<()> {
+pub extern "C" fn store_image() {
     let bytes = mem::bytes();
     let ids = ShapeImageIds::try_from(bytes[0..IMAGE_IDS_SIZE].to_vec()).unwrap();
 
@@ -90,8 +87,7 @@ pub extern "C" fn store_image() -> crate::error::Result<()> {
         state.touch_shape(ids.shape_id);
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 /// Stores an image from an existing WebGL texture, avoiding re-decoding
@@ -103,17 +99,13 @@ pub extern "C" fn store_image() -> crate::error::Result<()> {
 /// - bytes 40-43: width (i32)
 /// - bytes 44-47: height (i32)
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn store_image_from_texture() -> crate::error::Result<()> {
+pub extern "C" fn store_image_from_texture() {
     let bytes = mem::bytes();
 
     if bytes.len() < 48 {
-        // FIXME: Review if this should be an critical or a recoverable error.
         eprintln!("store_image_from_texture: insufficient data");
-        mem::free_bytes()?;
-        return Err(Error::RecoverableError(
-            "store_image_from_texture: insufficient data".to_string(),
-        ));
+        mem::free_bytes();
+        return;
     }
 
     let ids = ShapeImageIds::try_from(bytes[0..IMAGE_IDS_SIZE].to_vec()).unwrap();
@@ -147,6 +139,5 @@ pub extern "C" fn store_image_from_texture() -> crate::error::Result<()> {
         state.touch_shape(ids.shape_id);
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }

render-wasm/src/wasm/fonts.rs

@@ -1,4 +1,4 @@
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 
 use crate::mem;
 use crate::shapes::{FontFamily, FontStyle};
@@ -30,7 +30,6 @@ impl From<RawFontStyle> for FontStyle {
 }
 
 #[no_mangle]
-#[wasm_error]
 pub extern "C" fn store_font(
     a: u32,
     b: u32,
@@ -40,7 +39,7 @@ pub extern "C" fn store_font(
     style: u8,
     is_emoji: bool,
     is_fallback: bool,
-) -> Result<()> {
+) {
     with_state_mut!(state, {
         let id = uuid_from_u32_quartet(a, b, c, d);
         let font_bytes = mem::bytes();
@@ -53,9 +52,8 @@ pub extern "C" fn store_font(
                 .fonts_mut()
                 .add(family, &font_bytes, is_emoji, is_fallback);
 
-        mem::free_bytes()?;
+        mem::free_bytes();
     });
-    Ok(())
 }
 
 #[no_mangle]

render-wasm/src/wasm/layouts/grid.rs

@@ -1,4 +1,4 @@
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 
 use crate::mem;
 use crate::shapes::{GridCell, GridDirection, GridTrack, GridTrackType};
@@ -7,9 +7,6 @@ use crate::{uuid_from_u32_quartet, with_current_shape_mut, with_state, with_stat
 
 use super::align;
 
-#[allow(unused_imports)]
-use crate::error::Result;
-
 #[derive(Debug)]
 #[repr(C, align(1))]
 struct RawGridCell {
@@ -171,8 +168,7 @@ pub extern "C" fn set_grid_layout_data(
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_grid_columns() -> Result<()> {
+pub extern "C" fn set_grid_columns() {
     let bytes = mem::bytes();
 
     let entries: Vec<GridTrack> = bytes
@@ -185,13 +181,11 @@ pub extern "C" fn set_grid_columns() -> Result<()> {
         shape.set_grid_columns(entries);
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_grid_rows() -> Result<()> {
+pub extern "C" fn set_grid_rows() {
     let bytes = mem::bytes();
 
     let entries: Vec<GridTrack> = bytes
@@ -204,13 +198,11 @@ pub extern "C" fn set_grid_rows() -> Result<()> {
         shape.set_grid_rows(entries);
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_grid_cells() -> Result<()> {
+pub extern "C" fn set_grid_cells() {
     let bytes = mem::bytes();
 
     let cells: Vec<RawGridCell> = bytes
@@ -223,8 +215,7 @@ pub extern "C" fn set_grid_cells() -> Result<()> {
         shape.set_grid_cells(cells.into_iter().map(|raw| raw.into()).collect());
     });
 
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]

render-wasm/src/wasm/mem.rs

@@ -1,38 +0,0 @@
-use std::alloc::{alloc, Layout};
-use std::ptr;
-
-#[allow(unused_imports)]
-use crate::error::{Error, Result};
-use crate::mem::{BUFFERU8, LAYOUT_ALIGN};
-use macros::wasm_error;
-
-#[no_mangle]
-#[wasm_error]
-pub extern "C" fn alloc_bytes(len: usize) -> Result<*mut u8> {
-    let mut guard = BUFFERU8
-        .lock()
-        .map_err(|_| Error::CriticalError("Failed to lock buffer".to_string()))?;
-
-    if guard.is_some() {
-        return Err(Error::CriticalError("Bytes already allocated".to_string()));
-    }
-
-    unsafe {
-        let layout = Layout::from_size_align_unchecked(len, LAYOUT_ALIGN);
-        let ptr = alloc(layout);
-        if ptr.is_null() {
-            return Err(Error::CriticalError("Allocation failed".to_string()));
-        }
-        // TODO: Maybe this could be removed.
-        ptr::write_bytes(ptr, 0, len);
-        *guard = Some(Vec::from_raw_parts(ptr, len, len));
-        Ok(ptr)
-    }
-}
-
-#[no_mangle]
-#[wasm_error]
-pub extern "C" fn free_bytes() -> Result<()> {
-    crate::mem::free_bytes()?;
-    Ok(())
-}

render-wasm/src/wasm/paths.rs

@@ -1,5 +1,5 @@
 #![allow(unused_mut, unused_variables)]
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 use mem::SerializableResult;
 use std::mem::size_of;
 use std::sync::{Mutex, OnceLock};
@@ -161,14 +161,12 @@ pub extern "C" fn start_shape_path_buffer() {
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_path_chunk_buffer() -> Result<()> {
+pub extern "C" fn set_shape_path_chunk_buffer() {
     let bytes = mem::bytes();
     let buffer = get_path_upload_buffer();
     let mut buffer = buffer.lock().unwrap();
     buffer.extend_from_slice(&bytes);
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]

render-wasm/src/wasm/paths/bools.rs

@@ -1,4 +1,4 @@
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 
 use super::RawSegmentData;
 use crate::math;
@@ -8,9 +8,6 @@ use crate::{mem, SerializableResult};
 use crate::{with_current_shape_mut, with_state, STATE};
 use std::mem::size_of;
 
-#[allow(unused_imports)]
-use crate::error::{Error, Result};
-
 #[derive(Debug, Clone, Copy, PartialEq, ToJs)]
 #[repr(u8)]
 #[allow(dead_code)]
@@ -46,19 +43,15 @@ pub extern "C" fn set_shape_bool_type(raw_bool_type: u8) {
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn calculate_bool(raw_bool_type: u8) -> Result<*mut u8> {
+pub extern "C" fn calculate_bool(raw_bool_type: u8) -> *mut u8 {
     let bytes = mem::bytes_or_empty();
 
     let entries: Vec<Uuid> = bytes
         .chunks(size_of::<<Uuid as SerializableResult>::BytesType>())
-        .map(|data| {
-            // FIXME: Review if this should be an critical or a recoverable error.
-            Uuid::try_from(data).map_err(|_| Error::RecoverableError("Invalid UUID".to_string()))
-        })
-        .collect::<Result<Vec<Uuid>>>()?;
+        .map(|data| Uuid::try_from(data).unwrap())
+        .collect();
 
-    mem::free_bytes()?;
+    mem::free_bytes();
 
     let bool_type = RawBoolType::from(raw_bool_type).into();
     let result;
@@ -71,5 +64,5 @@ pub extern "C" fn calculate_bool(raw_bool_type: u8) -> Result<*mut u8> {
             .map(RawSegmentData::from_segment)
             .collect();
     });
-    Ok(mem::write_vec(result))
+    mem::write_vec(result)
 }

render-wasm/src/wasm/text.rs

@@ -1,4 +1,4 @@
-use macros::{wasm_error, ToJs};
+use macros::ToJs;
 
 use super::{fills::RawFillData, fonts::RawFontStyle};
 
@@ -9,8 +9,6 @@ use crate::shapes::{
 use crate::utils::{uuid_from_u32, uuid_from_u32_quartet};
 use crate::{with_current_shape, with_current_shape_mut, with_state, with_state_mut, STATE};
 
-use crate::error::Error;
-
 const RAW_SPAN_DATA_SIZE: usize = std::mem::size_of::<RawTextSpan>();
 const RAW_PARAGRAPH_DATA_SIZE: usize = std::mem::size_of::<RawParagraphData>();
 
@@ -287,22 +285,16 @@ pub extern "C" fn clear_shape_text() {
 }
 
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn set_shape_text_content() -> crate::error::Result<()> {
+pub extern "C" fn set_shape_text_content() {
     let bytes = mem::bytes();
     with_current_shape_mut!(state, |shape: &mut Shape| {
         let raw_text_data = RawParagraph::try_from(&bytes).unwrap();
 
-        shape.add_paragraph(raw_text_data.into()).map_err(|_| {
-            Error::RecoverableError(format!(
-                "Error with set_shape_text_content on {:?}",
-                shape.id
-            ))
-        })?;
+        if shape.add_paragraph(raw_text_data.into()).is_err() {
+            println!("Error with set_shape_text_content on {:?}", shape.id);
+        }
     });
-
-    mem::free_bytes()?;
-    Ok(())
+    mem::free_bytes();
 }
 
 #[no_mangle]

render-wasm/src/wasm/text_editor.rs

@@ -1,6 +1,3 @@
-use macros::{wasm_error, ToJs};
-
-use crate::error::Error;
 use crate::math::{Matrix, Point, Rect};
 use crate::mem;
 use crate::shapes::{Paragraph, Shape, TextContent, TextPositionWithAffinity, Type, VerticalAlign};
@@ -8,6 +5,7 @@ use crate::state::TextSelection;
 use crate::utils::uuid_from_u32_quartet;
 use crate::utils::uuid_to_u32_quartet;
 use crate::{with_state, with_state_mut, STATE};
+use macros::ToJs;
 
 #[derive(PartialEq, ToJs)]
 #[repr(u8)]
@@ -128,11 +126,9 @@ pub extern "C" fn text_editor_pointer_down(x: f32, y: f32) {
             return;
         };
         let point = Point::new(x, y);
-        let view_matrix: Matrix = state.render_state.viewbox.get_matrix();
-        let shape_matrix = shape.get_matrix();
         state.text_editor_state.start_pointer_selection();
         if let Some(position) =
-            text_content.get_caret_position_from_screen_coords(&point, &view_matrix, &shape_matrix)
+            text_content.get_caret_position_from_shape_coords(&point)
         {
             state.text_editor_state.set_caret_from_position(&position);
         }
@@ -145,7 +141,6 @@ pub extern "C" fn text_editor_pointer_move(x: f32, y: f32) {
         if !state.text_editor_state.is_active {
             return;
         }
-        let view_matrix: Matrix = state.render_state.viewbox.get_matrix();
         let point = Point::new(x, y);
         let Some(shape_id) = state.text_editor_state.active_shape_id else {
             return;
@@ -153,11 +148,6 @@ pub extern "C" fn text_editor_pointer_move(x: f32, y: f32) {
         let Some(shape) = state.shapes.get(&shape_id) else {
             return;
         };
-        let shape_matrix = shape.get_matrix();
-        let Some(_shape_rel_point) = Shape::get_relative_point(&point, &view_matrix, &shape_matrix)
-        else {
-            return;
-        };
         if !state.text_editor_state.is_pointer_selection_active {
             return;
         }
@@ -166,7 +156,7 @@ pub extern "C" fn text_editor_pointer_move(x: f32, y: f32) {
         };
 
         if let Some(position) =
-            text_content.get_caret_position_from_screen_coords(&point, &view_matrix, &shape_matrix)
+            text_content.get_caret_position_from_shape_coords(&point)
         {
             state
                 .text_editor_state
@@ -181,7 +171,6 @@ pub extern "C" fn text_editor_pointer_up(x: f32, y: f32) {
         if !state.text_editor_state.is_active {
             return;
         }
-        let view_matrix: Matrix = state.render_state.viewbox.get_matrix();
         let point = Point::new(x, y);
         let Some(shape_id) = state.text_editor_state.active_shape_id else {
             return;
@@ -189,11 +178,6 @@ pub extern "C" fn text_editor_pointer_up(x: f32, y: f32) {
         let Some(shape) = state.shapes.get(&shape_id) else {
             return;
         };
-        let shape_matrix = shape.get_matrix();
-        let Some(_shape_rel_point) = Shape::get_relative_point(&point, &view_matrix, &shape_matrix)
-        else {
-            return;
-        };
         if !state.text_editor_state.is_pointer_selection_active {
             return;
         }
@@ -201,7 +185,7 @@ pub extern "C" fn text_editor_pointer_up(x: f32, y: f32) {
             return;
         };
         if let Some(position) =
-            text_content.get_caret_position_from_screen_coords(&point, &view_matrix, &shape_matrix)
+            text_content.get_caret_position_from_shape_coords(&point)
         {
             state
                 .text_editor_state
@@ -211,6 +195,31 @@ pub extern "C" fn text_editor_pointer_up(x: f32, y: f32) {
     });
 }
 
+#[no_mangle]
+pub extern "C" fn text_editor_set_cursor_from_offset(x: f32, y: f32) {
+    with_state_mut!(state, {
+        if !state.text_editor_state.is_active {
+            return;
+        }
+
+        let point = Point::new(x, y);
+        let Some(shape_id) = state.text_editor_state.active_shape_id else {
+            return;
+        };
+        let Some(shape) = state.shapes.get(&shape_id) else {
+            return;
+        };
+        let Type::Text(text_content) = &shape.shape_type else {
+            return;
+        };
+        if let Some(position) =
+            text_content.get_caret_position_from_shape_coords(&point)
+        {
+            state.text_editor_state.set_caret_from_position(&position);
+        }
+    });
+}
+
 #[no_mangle]
 pub extern "C" fn text_editor_set_cursor_from_point(x: f32, y: f32) {
     with_state_mut!(state, {
@@ -242,29 +251,29 @@ pub extern "C" fn text_editor_set_cursor_from_point(x: f32, y: f32) {
 // TEXT OPERATIONS
 // ============================================================================
 
-// FIXME: Review if all the return Ok(()) should be Err instead.
 #[no_mangle]
-#[wasm_error]
-pub extern "C" fn text_editor_insert_text() -> Result<()> {
+pub extern "C" fn text_editor_insert_text() {
     let bytes = crate::mem::bytes();
-    let text = String::from_utf8(bytes)
-        .map_err(|_| Error::RecoverableError("Invalid UTF-8 string".to_string()))?;
+    let text = match String::from_utf8(bytes) {
+        Ok(s) => s,
+        Err(_) => return,
+    };
 
     with_state_mut!(state, {
         if !state.text_editor_state.is_active {
-            return Ok(());
+            return;
         }
 
         let Some(shape_id) = state.text_editor_state.active_shape_id else {
-            return Ok(());
+            return;
         };
 
         let Some(shape) = state.shapes.get_mut(&shape_id) else {
-            return Ok(());
+            return;
         };
 
         let Type::Text(text_content) = &mut shape.shape_type else {
-            return Ok(());
+            return;
         };
 
         let selection = state.text_editor_state.selection;
@@ -297,8 +306,7 @@ pub extern "C" fn text_editor_insert_text() -> Result<()> {
         state.render_state.mark_touched(shape_id);
     });
 
-    crate::mem::free_bytes()?;
-    Ok(())
+    crate::mem::free_bytes();
 }
 
 #[no_mangle]