stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/character_counter_controller.d.ts

@@ -17,7 +17,13 @@ type CharacterCounterField = HTMLInputElement | HTMLTextAreaElement;
  * Watches the field's UTF-16 code-unit length, writes the remaining/used count
  * into `output`, and toggles the `data-near-limit` / `data-over-limit` state
  * hooks. While over the limit it temporarily leases `aria-invalid="true"` on
- * the field and returns the consumer's authored value on recovery or teardown.
+ * the field and, on recovery or teardown, gives the field back the value beneath
+ * it: the consumer's authored value, or the latest value of a `stimeo--form-field`
+ * whose control is the same field. The lease records the authored value on the
+ * field, so the connection that adopts a copy of the page Turbo restores from its
+ * cache gives it back once the field is within the limit — a password field comes
+ * back empty. Nothing is undone on `turbo:before-cache`, which Turbo also
+ * dispatches on pages that stay: an over-limit field stays invalid there.
  * The field is the first `input` target, or — when the controller is attached
  * straight onto an `<input>`/`<textarea>` — the controller element itself.
  *
@@ -39,6 +45,14 @@ type CharacterCounterField = HTMLInputElement | HTMLTextAreaElement;
  * Runtime target/Value reconciliation dispatches
  * `stimeo--character-counter:reconcile` only when the public derived state
  * changes, and never announces.
+ * All input targets keep composition tracking even while another one is first,
+ * and only the first field's own conversion holds back its `input`.
+ * A composing field that returns first restores its own accepted count silently;
+ * its confirmation is compared with that field's accepted length, never another's,
+ * and a confirmation or cancellation at that length dispatches `reconcile` once when
+ * the state reported last differs from it. A conversion there that ends without
+ * `compositionend` reconciles that accepted count the same way, without reading the
+ * field; the next edit counts what the field holds.
  */
 declare class CharacterCounterController extends Controller<HTMLElement> {
     #private;
@@ -61,8 +75,19 @@ declare class CharacterCounterController extends Controller<HTMLElement> {
             default: string;
         };
     };
+    static valueConstraints: {
+        max: {
+            readonly finite: true;
+            readonly min: 0;
+        };
+        warnAt: {
+            readonly finite: true;
+            readonly min: 0;
+        };
+    };
     static events: readonly ["change", "reconcile"];
     readonly inputTarget: CharacterCounterField;
+    readonly inputTargets: CharacterCounterField[];
     readonly outputTarget: HTMLElement;
     readonly hasInputTarget: boolean;
     readonly hasOutputTarget: boolean;
@@ -70,14 +95,28 @@ declare class CharacterCounterController extends Controller<HTMLElement> {
     warnAtValue: number;
     modeValue: string;
     announceTextValue: string;
-    /** Reflects the current DOM state and opens the mutation-reconciliation window. */
+    /**
+     * Reflects the current DOM state and opens the mutation-reconciliation window. A
+     * field that moved here with its conversion has nothing new to read; the pass waits
+     * for the conversion only if the declarations changed with the move.
+     */
     connect(): void;
     /** Releases listeners, timers, borrowed ARIA, and controller-owned state hooks. */
     disconnect(): void;
-    /** Rebinds and repaints after an input target is added or replaced at runtime. */
+    /**
+     * Rebinds and repaints after an input target is added or replaced at runtime. A
+     * field that moved here keeping its conversion is the same field: the pass shows what
+     * it showed and holds nothing.
+     */
     inputTargetConnected(): void;
-    /** Releases and repaints after an input target is removed or replaced at runtime. */
-    inputTargetDisconnected(): void;
+    /**
+     * Releases and repaints after an input target is removed or replaced at runtime.
+     * A field that moves or leaves mid-composition hears no `compositionend`, so its
+     * composition ends here — unless it kept focus through the move, which keeps the
+     * conversion; a field that stays bound is observed again at once. The pass counts
+     * the field that is first now, and waits only for a conversion in that field.
+     */
+    inputTargetDisconnected(element: CharacterCounterField): void;
     /** Initializes a display target inserted after the controller connected. */
     outputTargetConnected(): void;
     /** Reconciles the optional display target set after a removal or replacement. */
@@ -88,8 +127,6 @@ declare class CharacterCounterController extends Controller<HTMLElement> {
     warnAtValueChanged(): void;
     /** Repaints when application code or a Turbo morph changes `mode`. */
     modeValueChanged(): void;
-    /** Rewords a pending announcement with the template the consumer changed it to. */
-    announceTextValueChanged(): void;
 }
 
 export { CharacterCounterController };