stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/number_input_controller.d.ts

@@ -36,6 +36,12 @@ import { Controller } from '@hotwired/stimulus';
  *
  * `change` dispatches `{ value: number }`; `reconcile` dispatches `{ value: number }`.
  *
+ * All published state is settled before its reports. A synchronous listener
+ * that confirms another value leaves that newer confirmation to report itself;
+ * reports still pending for the replaced value are not sent. A read-only listener
+ * or a confirmation that moves no published value leaves pending reports intact.
+ * An event already being dispatched still reaches its remaining listeners.
+ *
  * @remarks
  * Behavior only — the consumer styles the field and buttons. The input is the
  * sole Tab stop; the buttons are `tabindex="-1"` and keep focus on the input
@@ -46,8 +52,8 @@ import { Controller } from '@hotwired/stimulus';
  *   (default `step × 10`); `Home`/`End` jump to a finite `min`/`max`.
  * - Increment/decrement buttons step too, and are `disabled` at the bounds (focus
  *   is returned to the input before a focused button is disabled).
- * - **Press-and-hold auto-repeat**: holding a step button steps once, then after a
- *   short delay repeats until release, the bound is reached, or the element
+ * - **Press-and-hold auto-repeat**: holding a step button starts repeated steps
+ *   after a short delay until release, the bound is reached, or the element
  *   disconnects. The `click` binding stays the single-step path (a quick click, a
  *   synthesized/programmatic click, or assistive activation), so a normal click
  *   never double-steps — the trailing click after a hold is swallowed.
@@ -61,9 +67,20 @@ import { Controller } from '@hotwired/stimulus';
  *   last, which a blank field leaves empty and a missing input leaves as it was.
  *   The same instance keeps that number when it connects again — after an
  *   in-page move, say — and takes a new one without a report from an input that
- *   is present, while a new instance starts with none. Neither event fires on
- *   connect. A runtime change that arrives while the input is composing (IME)
- *   leaves the uncommitted text alone and is applied once the composition ends.
+ *   is present unless that same input still carries focused, unconfirmed typing.
+ *   A new instance starts with none. Neither event fires on connect. A runtime change
+ *   that arrives while the input is composing (IME) leaves the uncommitted text alone.
+ * - Text the user typed or a composition left stays a draft, separate from the
+ *   accepted text, until the field reports change or a widget step confirms it.
+ *   While the same input holds focus and that draft, morphs, reconnections and the
+ *   input leaving the targets and coming back preserve its text and selection, and
+ *   restore only accepted ARIA and button state; the input losing focus while the controller
+ *   cannot see it ends the draft. Range declarations wait:
+ *   confirmation applies the latest range once, reports a changed number as change,
+ *   and adds no reconcile or native report to the browser's own change. A draft that
+ *   returns to the accepted text ends, and a range that waited is reconciled then.
+ *   A different page write ends this draft's protection; an identical write gives
+ *   no evidence of a different origin. A replacement input is reconciled normally.
  * - A text-type spinbutton's text is read through the half-width mapping, so
  *   full-width digits and signs an IME confirms (`３４`, `－５`) count as the number
  *   they show, and the field is written back in half-width.
@@ -91,9 +108,28 @@ declare class NumberInputController extends Controller<HTMLElement> {
             default: number;
         };
     };
+    static valueConstraints: {
+        min: {
+            readonly finite: true;
+            readonly allowInfinity: "negative";
+        };
+        max: {
+            readonly finite: true;
+            readonly allowInfinity: "positive";
+        };
+        step: {
+            readonly finite: true;
+            readonly exclusiveMin: 0;
+        };
+        pageStep: {
+            readonly finite: true;
+            readonly min: 0;
+        };
+    };
     static actions: readonly ["decrement", "increment", "onInput", "onKeydown"];
     static events: readonly ["change", "reconcile"];
     readonly inputTarget: HTMLInputElement;
+    readonly inputTargets: HTMLInputElement[];
     readonly hasInputTarget: boolean;
     readonly incrementTarget: HTMLButtonElement;
     readonly incrementTargets: HTMLButtonElement[];
@@ -110,7 +146,8 @@ declare class NumberInputController extends Controller<HTMLElement> {
     /**
      * Releases listeners, derived attributes, timers, and the hold state. The number
      * shown last stays: the pass the next `connect()` runs takes a new one without a
-     * report from an input that is present, and with none it stays the number an
+     * report from a non-editing input that is present; the same focused draft keeps its
+     * accepted number. With none it stays the number an
      * input arriving later is compared with.
      */
     disconnect(): void;
@@ -120,12 +157,17 @@ declare class NumberInputController extends Controller<HTMLElement> {
     maxValueChanged(): void;
     /** Reconciles the value against a step changed by application code or a Turbo morph. */
     stepValueChanged(): void;
-    /** Tracks and reconciles an input inserted or replaced at runtime. */
+    /**
+     * Tracks and reconciles an input inserted or replaced at runtime. One that moved
+     * here keeping its conversion is the same input: the pass shows what it showed and
+     * holds nothing.
+     */
     inputTargetConnected(input: HTMLInputElement): void;
     /**
      * Releases ARIA and composition state owned by an input that left the controller.
      * The number it showed stays the baseline, so an input swapped in holding another
-     * number is reported as `reconcile`.
+     * number is reported as `reconcile`. An input that moved keeping focus keeps its
+     * conversion and stays the input, so nothing is released.
      */
     inputTargetDisconnected(input: HTMLInputElement): void;
     /** Wires focus preservation and hold behavior on a runtime increment target. */