stimeo-ui 0.15.0 → 0.17.0

data/dist/controllers/input_mask_controller.js

@@ -1,55 +1,71 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/input_mask_controller.ts
-
-// src/utils/composition_tracker.ts
+var COMPOSITION_INPUT_TYPES = /* @__PURE__ */ new Set([
+  "insertCompositionText",
+  "insertFromComposition",
+  "deleteCompositionText",
+  "deleteByComposition"
+]);
 var CompositionTracker = class {
   #observedTargets = /* @__PURE__ */ new Set();
   #activeTargets = /* @__PURE__ */ new Set();
   #onStart;
   #onEnd;
+  #confirmedTarget = null;
   constructor(options = {}) {
     this.#onStart = options.onStart;
     this.#onEnd = options.onEnd;
   }
-  /** Starts lifecycle tracking for `target`; repeated calls are idempotent. */
   observe(target) {
     if (this.#observedTargets.has(target)) return;
     target.addEventListener("compositionstart", this.#handleStart);
     target.addEventListener("compositionend", this.#handleEnd);
+    target.addEventListener("keydown", this.#handleKeydown);
     this.#observedTargets.add(target);
   }
-  /** Stops tracking one target and clears any active composition it owned. */
   unobserve(target) {
     if (!this.#observedTargets.delete(target)) return;
     target.removeEventListener("compositionstart", this.#handleStart);
     target.removeEventListener("compositionend", this.#handleEnd);
+    target.removeEventListener("keydown", this.#handleKeydown);
     this.#activeTargets.delete(target);
+    if (this.#confirmedTarget === target) this.#confirmedTarget = null;
   }
-  /** Releases every listener and clears state so reconnect starts cleanly. */
   disconnect() {
     for (const target of this.#observedTargets) {
       target.removeEventListener("compositionstart", this.#handleStart);
       target.removeEventListener("compositionend", this.#handleEnd);
+      target.removeEventListener("keydown", this.#handleKeydown);
     }
     this.#observedTargets.clear();
     this.#activeTargets.clear();
+    this.#confirmedTarget = null;
   }
-  /** True when lifecycle tracking or the current event reports composition. */
   isComposing(event) {
     return this.#activeTargets.size > 0 || event?.isComposing === true;
   }
+  consumesConfirmedInput(event) {
+    const confirmed = this.#confirmedTarget;
+    this.#confirmedTarget = null;
+    if (confirmed === null || confirmed !== event.target) return false;
+    const inputType = event.inputType;
+    return !inputType || COMPOSITION_INPUT_TYPES.has(inputType);
+  }
   #handleStart = (event) => {
+    this.#confirmedTarget = null;
     if (event.currentTarget) this.#activeTargets.add(event.currentTarget);
     this.#onStart?.(event);
   };
   #handleEnd = (event) => {
     if (event.currentTarget) this.#activeTargets.delete(event.currentTarget);
+    this.#confirmedTarget = event.target;
     this.#onEnd?.(event);
   };
+  #handleKeydown = () => {
+    this.#confirmedTarget = null;
+  };
 };
 
-// src/utils/declared_value.ts
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -73,7 +89,6 @@ function parseJsonObject(raw) {
   return parsed;
 }
 
-// src/utils/focus_candidate.ts
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
   while (fieldset) {
@@ -84,7 +99,6 @@ function inheritsFieldsetDisabled(control) {
   return false;
 }
 
-// src/utils/half_width.ts
 var FULL_WIDTH_SHIFT = 65248;
 function halfWidthChar(char) {
   if (char >= "\uFF01" && char <= "\uFF5E") {
@@ -93,13 +107,76 @@ function halfWidthChar(char) {
   return char === "\u3000" ? " " : char;
 }
 
-// src/controllers/input_mask_controller.ts
+var ListenerSet = class {
+  #abort = new AbortController();
+  add(target, type, handler, options) {
+    target.addEventListener(type, handler, { ...options, signal: this.#abort.signal });
+  }
+  dispose() {
+    this.#abort.abort();
+    this.#abort = new AbortController();
+  }
+};
+
+var MicrotaskCoalescer = class {
+  #run;
+  #queued = false;
+  #active = false;
+  #generation = 0;
+  constructor(run) {
+    this.#run = run;
+  }
+  activate() {
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
+  }
+  schedule() {
+    if (!this.#active || this.#queued) return;
+    this.#queued = true;
+    const generation = this.#generation;
+    queueMicrotask(() => {
+      if (generation !== this.#generation || !this.#queued || !this.#active) return;
+      this.#queued = false;
+      this.#run();
+    });
+  }
+};
+
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(run);
+  }
+  observe(element) {
+    if (this.#element === element) return;
+    this.disconnect();
+    this.#element = element;
+    this.#pass.activate();
+    this.#listeners.add(element, "turbo:morph-element", this.#onMorph);
+  }
+  schedule() {
+    this.#pass.schedule();
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
+  }
+};
+
 var DEFAULT_TOKENS = {
   "9": "\\d",
   a: "[A-Za-z]",
   "*": "[A-Za-z0-9]"
 };
-var UNMASK_ATTR = "data-stimeo--input-mask-unmask";
+var UNMASK_ATTR = "unmask";
 function acceptedForm(regex, char) {
   if (regex.test(char)) return char;
   const half = halfWidthChar(char);
@@ -176,6 +253,9 @@ function tokenCharOffset(tokenFlags, n) {
   return -1;
 }
 var InputMaskController = class extends Controller {
+  get #unmaskAttribute() {
+    return `data-${this.identifier}-${UNMASK_ATTR}`;
+  }
   static values = {
     pattern: { type: String, default: "" },
     tokens: { type: String, default: "" },
@@ -183,14 +263,19 @@ var InputMaskController = class extends Controller {
   };
   static actions = ["format"];
   static events = ["change", "reconcile"];
-  /** The value this controller last committed, and the baseline both events compare. */
   #lastValue = null;
   #started = false;
-  /** Validated token map; the hot path never parses the `tokens` declaration. */
   #tokens = compileTokens("");
-  /** Holds mid-composition input so the IME's uncommitted text is never rewritten. */
-  #composition = new CompositionTracker({ onEnd: () => this.#reformat("edit") });
-  /** Re-parses the declaration and re-formats under the tokens it now selects. */
+  #textBeforeComposition = "";
+  #composition = new CompositionTracker({
+    onStart: () => {
+      this.#textBeforeComposition = this.element.value;
+    },
+    onEnd: () => {
+      const committedNothing = this.element.value === this.#textBeforeComposition;
+      this.#reformat(committedNothing ? "reconcile" : "edit");
+    }
+  });
   tokensValueChanged() {
     this.#tokens = compileTokens(this.tokensValue);
     if (this.#started) this.#reformat("reconcile");
@@ -198,7 +283,6 @@ var InputMaskController = class extends Controller {
   patternValueChanged() {
     if (this.#started) this.#reformat("reconcile");
   }
-  /** Clears a sink it stops maintaining so a submit cannot carry a stale raw value. */
   unmaskToHiddenValueChanged() {
     if (!this.#started) return;
     if (!this.unmaskToHiddenValue) {
@@ -207,26 +291,25 @@ var InputMaskController = class extends Controller {
     }
     this.#reformat("reconcile");
   }
+  #morph = new MorphRenderWatcher(() => this.#reformat("reconcile"));
   connect() {
+    this.#morph.observe(this.element);
     this.#started = true;
     this.#composition.observe(this.element);
     this.#lastValue = this.element.value;
     this.#reformat("reconcile");
   }
   disconnect() {
+    this.#morph.disconnect();
     this.#started = false;
     this.#composition.disconnect();
   }
-  /** Formats the field on input, preserving the caret. Bound via `data-action`. */
   format(event) {
     if (this.#composition.isComposing(event)) return;
     this.#reformat("edit", deletionOf(event));
   }
-  /**
-   * Core reformat: mask the current value, restore the caret, sync the sink and
-   * the state hooks, and report a moved value under the event `cause` selects.
-   */
   #reformat(cause, deletion = null) {
+    if (this.#composition.isComposing()) return;
     const input = this.element;
     const raw = input.value;
     if (this.patternValue === "") {
@@ -255,8 +338,10 @@ var InputMaskController = class extends Controller {
       this.#lastValue = raw;
       return;
     }
-    input.value = result.masked;
-    this.#restoreCaret(result.tokenFlags, anchor);
+    if (input.value !== result.masked) {
+      input.value = result.masked;
+      this.#restoreCaret(result.tokenFlags, anchor);
+    }
     this.#publish(result, result.masked);
     if (result.masked === this.#lastValue) return;
     this.#lastValue = result.masked;
@@ -264,7 +349,6 @@ var InputMaskController = class extends Controller {
     if (cause === "edit") this.dispatch("change", { detail });
     else this.dispatch("reconcile", { detail });
   }
-  /** Syncs the raw-value sink and the state hooks for the `shown` field text. */
   #publish(result, shown) {
     if (this.unmaskToHiddenValue) {
       const sink = this.#resolveSink();
@@ -273,15 +357,9 @@ var InputMaskController = class extends Controller {
     this.#flag("data-mask-complete", result.complete);
     this.#flag("data-mask-empty", shown.length === 0);
   }
-  /**
-   * How many token slots the text before the caret fills. Masking that prefix is
-   * what makes a rejected character — or a literal that also matches a token —
-   * count exactly as the rendering counts it, so the caret cannot drift.
-   */
   #significantBefore(prefix) {
     return applyMask(prefix, this.patternValue, this.#tokens).unmasked.length;
   }
-  /** Places the caret after the `n`-th token char (skipping following literals). */
   #restoreCaret(tokenFlags, n) {
     let position;
     if (n <= 0) {
@@ -303,31 +381,14 @@ var InputMaskController = class extends Controller {
     } catch {
     }
   }
-  /**
-   * The hidden raw-value sink for this input, resolved so several masked inputs
-   * can coexist in one form:
-   *
-   * 1. **Explicit pairing** — a sink whose attribute value names this input's
-   *    `id` (`data-stimeo--input-mask-unmask="zip"`).
-   * 2. **Nearest container** — otherwise, walking up from the input, the first
-   *    *value-less* sink in the closest ancestor. Wrapped input+sink pairs each
-   *    find their own sink, and the single form-level sink keeps working
-   *    unchanged. A sink claimed by another input's id is never matched here.
-   *
-   * Both steps only ever consider the associated form's own controls, so a sink
-   * belonging to a different form (or to none) is never written, while one the
-   * `form` attribute associates from elsewhere in the document still resolves —
-   * for either the input or the sink, neither of which needs to contain or be
-   * contained by the form. A form-less input reads the document instead.
-   */
   #resolveSink() {
     const candidates = this.#sinkCandidates();
     const id = this.element.id;
     if (id.length > 0) {
-      const paired = candidates.find((sink) => sink.getAttribute(UNMASK_ATTR) === id);
+      const paired = candidates.find((sink) => sink.getAttribute(this.#unmaskAttribute) === id);
       if (paired) return paired;
     }
-    const free = candidates.filter((sink) => sink.getAttribute(UNMASK_ATTR) === "");
+    const free = candidates.filter((sink) => sink.getAttribute(this.#unmaskAttribute) === "");
     for (let node = this.element.parentElement; node !== null; node = node.parentElement) {
       const ancestor = node;
       const sink = free.find((candidate) => ancestor.contains(candidate));
@@ -335,22 +396,17 @@ var InputMaskController = class extends Controller {
     }
     return null;
   }
-  /**
-   * Every sink the input's form owns, in document order — one collection read per
-   * resolution, so the cost tracks the form's own controls and not the depth of
-   * the markup around it. `form.elements` lists controls the `form` attribute
-   * associates from anywhere in the document, and lists nothing another form owns.
-   */
   #sinkCandidates() {
     const form = this.element.form;
     if (form === null) {
-      return Array.from(document.querySelectorAll(`input[${UNMASK_ATTR}]`));
+      return Array.from(
+        document.querySelectorAll(`input[${this.#unmaskAttribute}]`)
+      );
     }
     return Array.from(form.elements).filter(
-      (element) => element instanceof HTMLInputElement && element.hasAttribute(UNMASK_ATTR)
+      (element) => element instanceof HTMLInputElement && element.hasAttribute(this.#unmaskAttribute)
     );
   }
-  /** Sets a boolean `data-*` flag to `"true"` when `on`, else removes it. */
   #flag(name, on) {
     if (on) this.element.setAttribute(name, "true");
     else this.element.removeAttribute(name);
@@ -358,5 +414,4 @@ var InputMaskController = class extends Controller {
 };
 
 export { InputMaskController, applyMask };
-//# sourceMappingURL=input_mask_controller.js.map
 //# sourceMappingURL=input_mask_controller.js.map