tuile 0.14.0 → 0.16.0

data/lib/tuile/component/abstract_string_field.rb

@@ -12,8 +12,9 @@ module Tuile
     # Holds the shared state — a mutable {#text} buffer, a {#caret} index,
     # {#on_change} and {#on_escape} callbacks — and the keyboard machinery
     # that single-line and multi-line inputs both need: ESC handling,
-    # LEFT/RIGHT caret movement, CTRL+LEFT/CTRL+RIGHT word jumps, and the
-    # `tab_stop?` flag (`focusable?` comes from {HasValue}).
+    # LEFT/RIGHT caret movement, CTRL+LEFT/CTRL+RIGHT word jumps, CTRL+W
+    # word-delete, and the `tab_stop?` flag (`focusable?` comes from
+    # {HasValue}).
     #
     # {#caret} counts *characters* into {#text} but may only sit *between*
     # grapheme clusters — the glyphs a terminal draws. Both write sites snap it
@@ -23,7 +24,7 @@ module Tuile
     #   f.text  = "e\u{0301}x"   # a decomposed e-acute then "x": 3 chars, 2 glyphs
     #   f.caret = 1              # into the middle of the e-acute …
     #   f.caret                  # => 2, its end — where the caret already drew
-    #   f.handle_key(Keys::BACKSPACE)
+    #   f.handle_key?(Keys::BACKSPACE)
     #   f.text                   # => "x": the whole glyph went, not its accent
     #
     # Insertion stays character-native, so `String#insert` merges a typed
@@ -33,18 +34,49 @@ module Tuile
     # Subclasses implement the layout-specific pieces ({#cursor_position},
     # {#repaint}) and add their own keys (HOME/END, ENTER, UP/DOWN,
     # printable insertion) by overriding the protected
-    # {#handle_text_input_key} hook — `super` falls through to the common
+    # {#handle_text_input_key?} hook — `super` falls through to the common
     # navigation handling.
     #
+    # == Customizing a field is subclassing it, and there are two seams
+    # To change what **keys** do, override {#handle_text_input_key?}; to
+    # constrain what the buffer may **hold**, override {#insert_text}, which
+    # every insertion runs through — typed, pasted, or the ENTER newline:
+    #
+    #   class HexField < TextField
+    #     protected
+    #
+    #     # ENTER submits instead of falling through to the parent.
+    #     def handle_text_input_key?(key)
+    #       return super unless key == Keys::ENTER
+    #
+    #       submit(text)
+    #       true
+    #     end
+    #
+    #     # Hex digits only — and a paste of "12zz" lands nothing, not "12".
+    #     def insert_text(str)
+    #       return false unless @text.dup.insert(@caret, str).match?(/\A\h*\z/)
+    #
+    #       super
+    #     end
+    #   end
+    #
+    # Both compose through `super`, which is why they are overrides rather than
+    # the callback slot this class carried until 0.15.0: two behaviors could not
+    # share one slot, and a filter written on a *key* callback let the same
+    # characters in through a paste (`D_input_filters`, book ch7).
+    #
     # The mutation pipeline is a template method: {#text=} and {#caret=}
     # detect no-ops, mutate state, fire {#on_change}, and invalidate.
-    # Subclasses inject their own behavior via two protected hooks:
+    # Subclasses inject their own behavior via four protected hooks:
     #
-    # - {#preprocess_text} — input filter (e.g. {TextField} truncates to
-    #   fit `rect.width - 1`).
-    # - {#preprocess_paste} — the same for {#handle_paste}, which lands a
-    #   whole clipboard at the caret in one mutation.
-    # - {#on_text_mutated} / {#on_caret_mutated} — post-mutation side
+    # - {#insert_text} — **the one filter seam**: every insertion runs through
+    #   it, typed or pasted, so what the buffer may hold is decided here.
+    # - {#preprocess_text} — filter for a whole assignment to {#text=},
+    #   which insertion does *not* pass through.
+    # - {#preprocess_paste} — sanitizer for {#handle_paste}, run before the
+    #   clipboard reaches {#insert_text} ({TextField} keeps its first line).
+    # - {#handle_text_mutated} / {#handle_caret_mutated} — post-mutation side
     #   effects (e.g. {TextArea} invalidates its wrap cache and scrolls to
     #   keep the caret visible).
     class AbstractStringField < Component
@@ -56,7 +88,6 @@ module Tuile
         @caret = 0
         @on_change = nil
         @on_value_change = nil
-        @on_key = nil
         @on_escape = method(:default_on_escape)
       end
 
@@ -89,20 +120,6 @@ module Tuile
       # @return [Proc, Method, nil] one-arg callable, or nil.
       attr_accessor :on_change
 
-      # Optional interceptor consulted before the input's own key handling.
-      # Receives the pressed key; return a truthy value to consume it (the
-      # input then ignores that key), falsy to let normal editing proceed.
-      #
-      # The keyboard analog of {#on_change}: it lets app code layer behavior
-      # onto an input without subclassing. The motivating case is an
-      # autocomplete / slash-command overlay (a non-modal {Component::Popup}):
-      # while it is open the interceptor claims Up/Down/Enter/ESC and forwards
-      # them to the overlay's list, but lets ordinary characters fall through
-      # so typing keeps editing the field (and {#on_change} keeps refilling the
-      # list).
-      # @return [Proc, Method, nil] one-arg callable, or nil.
-      attr_accessor :on_key
-
       # Callback fired when ESC is pressed. Defaults to a closure that clears
       # focus (`screen.focused = nil`) so ESC visibly cancels text entry instead
       # of bubbling to the parent — and, in particular, instead of reaching the
@@ -124,7 +141,7 @@ module Tuile
 
         @text = +new_text
         @caret = snap_to_cluster(@caret.clamp(0, @text.length))
-        on_text_mutated
+        handle_text_mutated
         invalidate
         @on_change&.call(@text)
         on_value_change&.call(@text)
@@ -132,7 +149,7 @@ module Tuile
 
       # Clamps to `0..text.length`, then snaps forward onto a grapheme-cluster
       # boundary, so an index that fell inside a cluster reads back as that
-      # cluster's end. Fires the {#on_caret_mutated} hook for subclasses (e.g.
+      # cluster's end. Fires the {#handle_caret_mutated} hook for subclasses (e.g.
       # {TextArea} scrolls).
       # @param new_caret [Integer]
       def caret=(new_caret)
@@ -140,32 +157,25 @@ module Tuile
         return if @caret == new_caret
 
         @caret = new_caret
-        on_caret_mutated
+        handle_caret_mutated
         invalidate
       end
 
-      # Handles a key. An {#on_key} interceptor (if set) gets first refusal —
-      # a truthy return consumes the key — otherwise it delegates to
-      # {#handle_text_input_key}. Dispatch ({ScreenPane#handle_key}) only routes
-      # keys here when this input is on the focus chain, so there is no
-      # {#active?} gate.
+      # Handles a key, by delegating to the {#handle_text_input_key?} hook a
+      # subclass overrides. Dispatch ({ScreenPane#handle_key?}) only routes keys
+      # here when this input is on the focus chain, so there is no {#active?}
+      # gate.
       # @param key [String]
       # @return [Boolean]
-      def handle_key(key)
-        return true if @on_key&.call(key)
-
-        handle_text_input_key(key)
-      end
+      def handle_key?(key) = handle_text_input_key?(key)
 
       # Inserts pasted text at the caret as **one** mutation, so {#on_change}
       # fires once for the whole paste rather than once per character.
       # {#preprocess_paste} filters it first.
       # @param text [String]
-      # @return [Boolean] always true — a field consumes every paste, an empty
-      #   one included.
+      # @return [void]
       def handle_paste(text)
         insert_text(preprocess_paste(text))
-        true
       end
 
       protected
@@ -180,8 +190,28 @@ module Tuile
       # @return [String]
       def preprocess_paste(text) = text.tr("\t", " ").gsub(/[\x00-\x09\x0b-\x1f\x7f]/, "")
 
-      # Inserts `str` at the caret, leaving the caret behind it. The bulk
-      # counterpart of a subclass's per-key insert.
+      # Inserts `str` at the caret, leaving the caret behind it.
+      #
+      # **Every insertion lands here** — a typed character, the ENTER newline
+      # and a whole pasted clipboard alike — so a field constrains its contents
+      # by overriding this, and one override covers typing and pasting both:
+      #
+      #   def insert_text(str)      # hex digits only, in a TextField subclass
+      #     return false unless @text.dup.insert(@caret, str).match?(/\A\h*\z/)
+      #
+      #     super
+      #   end
+      #
+      # Test the whole resulting buffer, as above, and not the fragment being
+      # inserted: sieving per character turns a pasted `"1,5"` into the
+      # plausible, wrong `"15"`, where an all-or-nothing test drops it — which
+      # is also what typing the comma does. Filtering at all works only for a
+      # grammar every valid value can be *typed through*; one where it can't
+      # (a date — `"2020-13-45"` is well-formed at every character) reports bad
+      # input rather than filtering it (`D_input_filters`, book ch7).
+      #
+      # {#text=} does *not* pass through here: only user input is filtered, so a
+      # programmatic {HasValue#value=} may still write what no key types.
       # @param str [String]
       # @return [Boolean] true if the text changed.
       def insert_text(str)
@@ -193,20 +223,25 @@ module Tuile
         true
       end
 
-      # Renders `text` on the field's background well, looked up from the
-      # current {Screen#theme} at paint time: {Theme#active_bg_color} when this
-      # input is on the active (focus) chain, {Theme#input_bg_color} otherwise —
-      # visibly a field either way, distinctly highlighted when active.
-      # @param text [String]
-      # @return [StyledString] text on the field's background well.
-      def background(text)
-        StyledString.styled(text, bg: active? ? screen.theme.active_bg_color : screen.theme.input_bg_color)
-      end
-
-      # Input filter for {#text=}. Subclasses override to truncate or reject
-      # invalid input. Default coerces to String.
+      # The field's background well, looked up from the current {Screen#theme}
+      # at paint time: {Theme#active_bg_color} while this input is on the active
+      # (focus) chain, {Theme#input_bg_color} otherwise — visibly a field either
+      # way, distinctly highlighted when focused. An app overrides the pair by
+      # setting {Component#bg_color}, which wins over this.
+      #
+      # Unconditional on purpose. A field used as the face of a composed one
+      # ({Component::ComboBox}, {Component::IntegerField} …) is *told* to drop
+      # its well — that widget assigns {Component::BG_INHERIT} at construction,
+      # since it owns the surface and a second well would make its own
+      # {Component#bg_color} inert over the very cells this field paints.
+      # @return [Color]
+      def default_bg_color = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
+
+      # Input filter for a whole assignment to {#text=}. Nothing overrides it
+      # today; a subclass that does is filtering the *programmatic* setter, not
+      # user input — that is {#insert_text}.
       # @param new_text [String]
-      # @return [String] possibly transformed text.
+      # @return [String] possibly transformed text; the default coerces to String.
       def preprocess_text(new_text) = new_text.to_s
 
       # The one measurement primitive both inputs share: a caret index counts
@@ -222,29 +257,31 @@ module Tuile
       # {#on_change}. Default no-op. Subclasses use this to invalidate caches
       # ({TextArea}'s wrap cache) and update derived state.
       # @return [void]
-      def on_text_mutated; end
+      def handle_text_mutated; end
 
       # Hook called after {#caret} has been mutated, before invalidation.
       # Default no-op. Subclasses use this to keep the caret visible
       # ({TextArea}'s vertical scroll).
       # @return [void]
-      def on_caret_mutated; end
+      def handle_caret_mutated; end
 
-      # Dispatch hook for {#handle_key}. Handles ESC and the navigation keys
-      # that have identical semantics in single-line and multi-line inputs:
+      # Dispatch hook for {#handle_key?}. Handles ESC and the editing keys that
+      # have identical semantics in single-line and multi-line inputs:
       # LEFT/RIGHT arrows (one grapheme cluster per press, so a press always
-      # moves), CTRL+LEFT/CTRL+RIGHT for word jumps. Subclasses
-      # override to add their own keys (HOME/END, UP/DOWN, ENTER, BACKSPACE/
-      # DELETE, printable insertion) and call `super` to fall back to the
-      # common navigation handling.
+      # moves), CTRL+LEFT/CTRL+RIGHT for word jumps, and CTRL+W, which deletes
+      # exactly what CTRL+LEFT would have skipped over (readline's
+      # `unix-word-rubout`). Subclasses override to add their own keys (HOME/END,
+      # UP/DOWN, ENTER, CTRL+U, BACKSPACE/DELETE, printable insertion) and call
+      # `super` to fall back to the common handling.
       # @param key [String]
       # @return [Boolean] true if the key was handled.
-      def handle_text_input_key(key)
+      def handle_text_input_key?(key)
         case key
         when Keys::LEFT_ARROW then self.caret = cluster_boundary_before(@caret)
         when Keys::RIGHT_ARROW then self.caret = cluster_boundary_after(@caret)
         when Keys::CTRL_LEFT_ARROW then self.caret = word_left
         when Keys::CTRL_RIGHT_ARROW then self.caret = word_right
+        when Keys::CTRL_W then delete_back_to(word_left)
         when Keys::ESC
           return false if @on_escape.nil?
 
@@ -259,10 +296,19 @@ module Tuile
       # glyph, whatever it is built from (a ZWJ emoji family and a three-jamo
       # Hangul syllable each go whole).
       # @return [void]
-      def delete_before_caret
-        return if @caret.zero?
+      def delete_before_caret = delete_back_to(cluster_boundary_before(@caret))
+
+      # Removes the text between `index` and the caret, leaving the caret at
+      # `index` — one mutation, so {#on_change} fires once.
+      #
+      # `index` is snapped forward onto a grapheme-cluster boundary, so a
+      # caller may compute it by counting characters.
+      # @param index [Integer] a {#text} index; clamped to `0..caret`.
+      # @return [void]
+      def delete_back_to(index)
+        start = snap_to_cluster(index.clamp(0, @caret))
+        return if start == @caret
 
-        start = cluster_boundary_before(@caret)
         new_text = @text.dup
         new_text.slice!(start...@caret)
         @caret = start

data/lib/tuile/component/abstract_wrapping_field.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+module Tuile
+  class Component
+    # Abstract base for a field that **wraps one editor completely**: it carries
+    # a typed {HasValue#value} but paints nothing itself, handing the whole UI to
+    # a single {AbstractStringField} it owns and hides. Subclass it by passing
+    # the editor to `super` and defining the conversion both ways:
+    #
+    #   class IntegerField < Component::AbstractWrappingField
+    #     def initialize = super(TextField.new)
+    #
+    #     def value = Integer(editor.text, 10) rescue nil
+    #
+    #     def value=(new_value)
+    #       editor.text = new_value.nil? ? "" : new_value.to_s
+    #       editor.caret = editor.text.length
+    #     end
+    #
+    #     def empty_value = nil
+    #   end
+    #
+    # Everything else arrives already wired: the editor is added as the single
+    # child and positioned across {Component#rect}, focus forwards into it, it
+    # sits on this field's one background well, and {#placeholder} /
+    # {#on_enter} / {#cursor_position} / {#clear} are re-exposed here so an app
+    # never addresses it. Give the field a single-row rect.
+    #
+    # == The editor is private machinery
+    # There is no public accessor — {#editor} is protected, for subclasses — and
+    # that is the point: swapping it would break the conversion. **An app never
+    # addresses the editor**; what it needs is either already delegated here or
+    # earns a forwarder here. It is still in `children`, because the tree is
+    # reported honestly, but that is not an invitation.
+    #
+    # A **spec** is the exception, and it has a sanctioned path — driving the
+    # editor is how a test reaches a state no public setter produces:
+    #
+    #   editor = Testing.get(Component::TextField, in: field)
+    #   editor.text = "-"          # bad input; field.value still reads nil
+    #
+    # A knob that is *editor-shaped* rather than a concept of this field's own
+    # domain is **not** forwarded, and the subclass sets it on its editor
+    # instead:
+    #
+    #   def initialize
+    #     super(TextField.new)
+    #     editor.max_text_length = 20   # an internal cap, not part of my surface
+    #   end
+    #
+    # == Committing: leaving the widget, and ENTER
+    # {#commit} fires on both commit gestures. Leaving the focus chain is one —
+    # the *field*'s, not its editor's, which is left on every hop within a
+    # widget. ENTER is the other, because a form whose default button is reached
+    # by ENTER never moves focus at all. Override it to canonicalize a buffer
+    # the user typed loosely:
+    #
+    #   def commit = (self.value = value unless value.nil?)   # rewrite in the canonical form
+    #
+    # ENTER is committed and then **left to keep bubbling**, so a scope's
+    # default button still sees it; only an {#on_enter} of this field's own
+    # consumes it, which is {TextField#on_enter}'s existing contract.
+    #
+    # == When the value notice fires
+    # Per edit by default. A field whose grammar is not prefix-closed sets
+    # {#notify_on_edit?} to `false` and lets the notice settle onto those same
+    # two gestures, so a form is never handed a half-typed date that happens to
+    # parse ({DateField}, {TimeField}).
+    #
+    # == Implementation details
+    # - **{HasValue#value} and {#value=} raise until overridden.** The inherited
+    #   pair stores into `@value` and never touches the editor, so a subclass
+    #   that defined only one would silently half-work.
+    # - **{HasValue#empty_value} is called during construction**, to seed the
+    #   change guard, so it must not depend on subclass state that `super` has
+    #   not set yet. In practice it is a constant per class.
+    # - **The editor's `on_change` and `on_enter` slots are claimed** — for that
+    #   guard, and to commit before an app's ENTER handler runs. A slot cannot
+    #   be shared, so a subclass reacting to buffer edits overrides
+    #   {#handle_editor_change} (every edit), {#value=} or {#commit} rather than
+    #   reassigning either.
+    # - **Not for a field whose editor is a *filter*.** This base assumes the
+    #   buffer is a rendering of the value, so an edit may change the value.
+    #   {ComboBox} breaks both halves — its text is a transient query and only a
+    #   commit moves its value — which is the same line {HasBadInput} draws.
+    #
+    # UI-thread-confined, like every component (see {Screen}).
+    class AbstractWrappingField < Component
+      include HasValue
+      include HasPlaceholder
+
+      # @param editor [AbstractStringField] the editor to wrap; becomes this
+      #   field's single child and is never swapped.
+      # @raise [TypeError] unless `editor` is an {AbstractStringField}.
+      def initialize(editor)
+        super()
+        raise TypeError, "expected AbstractStringField, got #{editor.inspect}" unless editor.is_a?(AbstractStringField)
+
+        @editor = editor
+        @last_value = empty_value
+        @on_enter = nil
+        # One widget, one surface: the editor paints no well of its own, so this
+        # field's bg_color reaches the cells the editor paints.
+        editor.bg_color = BG_INHERIT
+        editor.on_change = lambda do |_text|
+          handle_editor_change
+          fire_if_changed if notify_on_edit?
+        end
+        add_child(editor, at: 0)
+      end
+
+      # @return [Object] the typed value, parsed from the editor's buffer.
+      # @raise [NotImplementedError] unless the subclass overrides it.
+      def value = raise(NotImplementedError, "#{self.class} must implement value")
+
+      # Writes `new_value` into the editor's buffer.
+      # @param new_value [Object]
+      # @return [void]
+      # @raise [NotImplementedError] unless the subclass overrides it.
+      def value=(new_value)
+        raise(NotImplementedError, "#{self.class} must implement value=")
+      end
+
+      # Empties the *input*, not just the value — a field holding bad input
+      # already reads {HasValue#empty_value}, so clearing through {#value=} could
+      # leave the glyphs on screen ({HasBadInput}).
+      # @return [void]
+      def clear
+        editor.clear
+        # Announced here rather than through the editor's change, so a field
+        # holding its notice ({#notify_on_edit?}) still reports an emptying as
+        # it happens: emptying is not a half-typed prefix.
+        fire_if_changed
+      end
+
+      # @return [String, nil] the hint the editor paints while empty
+      #   ({HasPlaceholder}).
+      def placeholder = editor.placeholder
+
+      # @param text [String, nil]
+      # @return [void]
+      # @raise [TypeError] unless `text` is a String or nil.
+      def placeholder=(text)
+        editor.placeholder = text
+      end
+
+      # @return [Proc, Method, nil] fired when ENTER is pressed, *after*
+      #   {#commit}; see {TextField#on_enter}.
+      attr_reader :on_enter
+
+      # @param callback [Proc, Method, nil]
+      # @return [void]
+      def on_enter=(callback)
+        @on_enter = callback
+        # Wrapped rather than forwarded, so an app's ENTER handler reads a
+        # committed buffer. A nil callback leaves the editor's own slot nil,
+        # which is what keeps ENTER *bubbling* — see {#handle_key?}.
+        editor.on_enter = callback && lambda do
+          commit_and_notify
+          callback.call
+        end
+      end
+
+      # Commits on ENTER, and leaves the key unconsumed so it keeps bubbling.
+      #
+      # The editor declines ENTER whenever {#on_enter} is nil, so the key
+      # reaches this field instead — and it must be committed on the way past,
+      # or the form default button it is bubbling towards acts on an
+      # uncommitted buffer.
+      # @param key [String]
+      # @return [Boolean] whatever `super` returns — committing never consumes
+      #   the key.
+      def handle_key?(key)
+        commit_and_notify if key == Keys::ENTER
+        super
+      end
+
+      # @return [Point, nil] the editor's caret — the hardware cursor is
+      #   delegated to it.
+      def cursor_position = editor.cursor_position
+
+      # Runs {#commit} on the falling edge, i.e. when this field leaves the focus
+      # chain. Moving focus *within* a widget keeps it active, so a future
+      # multi-editor field inherits the same semantics unchanged.
+      # @param flag [Boolean]
+      # @return [void]
+      def active=(flag)
+        was = active?
+        super
+        commit_and_notify if was && !active?
+      end
+
+      # @return [void]
+      def handle_focus
+        super
+        # The editor is what actually edits, so it takes the focus this field was
+        # given — the field itself has no keys of its own.
+        screen.focused = editor if editor.focusable?
+      end
+
+      # @param new_rect [Rect]
+      # @return [void]
+      def rect=(new_rect)
+        super
+        layout(editor)
+      end
+
+      protected
+
+      # @return [AbstractStringField] the wrapped editor.
+      attr_reader :editor
+
+      # Called on a commit gesture — the field leaving the focus chain, or
+      # ENTER; no-op by default. This is the commit point a canonicalizing
+      # field rewrites its buffer from.
+      # @return [void]
+      def commit = nil
+
+      # Whether an edit of the buffer fires {HasValue#on_value_change} as it
+      # happens. `true` here, which is right wherever every buffer state is a
+      # value the user might mean: an {IntegerField} passing through `4` on the
+      # way to `42` really does hold 4 for that keystroke. A field whose
+      # grammar is **not prefix-closed** answers `false` and lets the notice
+      # settle onto the commit gestures instead ({DateField}, `D_date_field`).
+      #
+      # Only the *push* settles: {HasValue#value} stays a live parse of the
+      # buffer either way. And overriding this is half the job — {#commit} is
+      # covered here, but the field must fire from its own `value=` too, or a
+      # programmatic write and an Up/Down step go unannounced until the next
+      # commit.
+      # @return [Boolean]
+      def notify_on_edit? = true
+
+      # Called whenever the editor's buffer changes, however the characters
+      # arrived — a typed key, a paste, or a {#value=} of this field's own. It
+      # is named for the *editor*, not for the user, because those last two are
+      # not input. No-op by default; override it to drop state that describes
+      # the *previous* buffer, as a field latching whether its input has settled
+      # must ({HasBadInput}).
+      # @return [void]
+      def handle_editor_change; end
+
+      # Places the editor across the whole rect; override to reserve cells for a
+      # face of your own.
+      # @param editor [Component]
+      # @return [void]
+      def layout(editor) = (editor.rect = rect)
+
+      # The field well the face sits on — the editor is marked
+      # {Component::BG_INHERIT}, so this one covers it (exactly one well per
+      # widget) and {Component#bg_color} set here reaches the cells it paints.
+      # @return [Color]
+      def default_bg_color = active? ? screen.theme.active_bg_color : screen.theme.input_bg_color
+
+      private
+
+      # Every commit gesture runs through here, so a field holding its notice
+      # ({#notify_on_edit?}) announces from one place rather than three; the
+      # diff guard makes the call free for a field that fired on the way in.
+      # @return [void]
+      def commit_and_notify
+        commit
+        fire_if_changed
+      end
+
+      # Re-emits {HasValue#on_value_change}, but only when {#value} differs from
+      # the last one fired — so a buffer edit that leaves the value alone
+      # (`"7"`→`"07"`) stays silent.
+      # @return [void]
+      def fire_if_changed
+        v = value
+        return if v == @last_value
+
+        @last_value = v
+        on_value_change&.call(v)
+      end
+    end
+  end
+end