stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/password_strength_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/password_strength_controller.ts
-
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -19,63 +16,59 @@ function fillTemplate(template, values) {
   });
 }
 
-// src/utils/before_cache_reset.ts
-var BeforeCacheReset = class _BeforeCacheReset {
-  /** Every subscribed instance, iterated by the one shared document listener. */
-  static #subscribers = /* @__PURE__ */ new Set();
-  /** The shared listener; installed while at least one instance is subscribed. */
-  static #onBeforeCache = () => {
-    for (const subscriber of _BeforeCacheReset.#subscribers) subscriber.#rewind();
-  };
-  #rewind;
-  /** @param rewind - the pass that returns this controller's state to its initial form. */
-  constructor(rewind) {
-    this.#rewind = rewind;
-  }
-  /** Subscribes to `turbo:before-cache`; call from `connect()`. Idempotent. */
-  activate() {
-    const first = _BeforeCacheReset.#subscribers.size === 0;
-    _BeforeCacheReset.#subscribers.add(this);
-    if (first) {
-      document.addEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
-    }
-  }
-  /** Unsubscribes; call from `disconnect()`. Safe when never subscribed. */
-  deactivate() {
-    _BeforeCacheReset.#subscribers.delete(this);
-    if (_BeforeCacheReset.#subscribers.size > 0) return;
-    document.removeEventListener("turbo:before-cache", _BeforeCacheReset.#onBeforeCache);
-  }
-};
+var NUMBER_BOUNDS = {
+  nonNegative: { finite: true, min: 0 }};
+function matchesNumberBounds(value, bounds) {
+  if (!Number.isFinite(value)) {
+    const direction = value === Infinity ? "positive" : value === -Infinity ? "negative" : null;
+    if (direction === null) return false;
+    if (bounds.allowInfinity !== "both" && bounds.allowInfinity !== direction) return false;
+  }
+  if (bounds.min !== void 0 && value < bounds.min) return false;
+  if (bounds.max !== void 0 && value > bounds.max) return false;
+  if (bounds.exclusiveMin !== void 0 && value <= bounds.exclusiveMin) return false;
+  if (bounds.integer && !Number.isInteger(value)) return false;
+  if (bounds.allowedValues !== void 0 && !bounds.allowedValues.includes(value)) return false;
+  return true;
+}
 
-// src/utils/coerce.ts
 function toFiniteNumber(raw) {
-  if (raw === null || raw === void 0 || raw === "") return null;
-  const value = typeof raw === "number" ? raw : Number(raw);
+  if (typeof raw !== "number" && typeof raw !== "string") return null;
+  if (typeof raw === "string" && raw.trim().length === 0) return null;
+  const value = Number(raw);
   return Number.isFinite(value) ? value : null;
 }
+function readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+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();
+  }
+};
 
-// src/utils/microtask_coalescer.ts
 var MicrotaskCoalescer = class {
   #run;
   #queued = false;
   #active = false;
   #generation = 0;
-  /** @param run - the single reconciliation pass, invoked at most once per batch. */
   constructor(run) {
     this.#run = run;
   }
-  /** Opens the window in which {@link schedule} is honoured; call from `connect()`. */
   activate() {
     this.#active = true;
   }
-  /** Closes the window and drops any pending pass; call from `disconnect()`. */
   cancel() {
     this.#active = false;
     this.#queued = false;
     this.#generation += 1;
   }
-  /** Requests one pass after the batch settles. Idempotent; inert outside the window. */
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -88,43 +81,73 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/safe_timeout.ts
+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 NumberValueReader = class {
+  #lastRejected = /* @__PURE__ */ new Map();
+  read(owner, name, raw, fallback, bounds) {
+    const resolved = readNumber(raw, fallback, bounds);
+    if (matchesNumberBounds(raw, bounds)) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    const attribute = `data-${owner.identifier}-${name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}-value`;
+    const literal = owner.element.getAttribute(attribute);
+    if (literal === null) {
+      this.#lastRejected.delete(name);
+      return resolved;
+    }
+    if (this.#lastRejected.get(name) !== literal) {
+      this.#lastRejected.set(name, literal);
+      console.warn(
+        `Stimeo UI: "${owner.identifier}" has an invalid number Value "${name}" declaration ${JSON.stringify(literal)}; using ${fallback}.`
+      );
+    }
+    return resolved;
+  }
+};
+
 var TimerRegistry = class {
-  /** Live timer ids that have not yet been cleared (or, for timeouts, fired). */
   ids = /* @__PURE__ */ new Set();
-  /**
-   * Cancels a single tracked timer.
-   *
-   * No-ops if the id is unknown (already cleared, fired, or never owned by this
-   * registry), so callers can clear defensively without guarding.
-   */
   clear(id) {
     if (this.ids.delete(id)) {
       this.cancel(id);
     }
   }
-  /**
-   * Cancels every tracked timer. Call this from a controller's `disconnect()`
-   * to guarantee no timer outlives the element.
-   */
   clearAll() {
     for (const id of this.ids) {
       this.cancel(id);
     }
     this.ids.clear();
   }
-  /** Number of timers currently tracked (pending). */
   get size() {
     return this.ids.size;
   }
 };
 var SafeTimeout = class extends TimerRegistry {
-  /**
-   * Schedules `callback` after `delay` ms and returns the timer id.
-   *
-   * The id is removed from the registry automatically when the timeout fires,
-   * so {@link TimerRegistry.size | size} reflects only still-pending timers.
-   */
   set(callback, delay) {
     const id = this.schedule(() => {
       this.ids.delete(id);
@@ -141,7 +164,6 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/utils/string_list.ts
 function parseStringList(raw, fallback = []) {
   const text = raw.trim();
   if (text.length === 0) return [...fallback];
@@ -155,7 +177,6 @@ function parseStringList(raw, fallback = []) {
   return parsed.filter((entry) => typeof entry === "string");
 }
 
-// src/controllers/password_strength_controller.ts
 var CLASS_PATTERNS = [/[a-z]/, /[A-Z]/, /[0-9]/, /[^A-Za-z0-9]/];
 var DEFAULT_LEVELS = ["weak", "fair", "good", "strong"];
 var LENGTH_MILESTONES = [8, 12, 16];
@@ -163,107 +184,85 @@ var MAX_POINTS = LENGTH_MILESTONES.length + (CLASS_PATTERNS.length - 1);
 var STRENGTH_BANDS = ["weak", "fair", "good", "strong"];
 var MIN_LEVELS = 2;
 var PasswordStrengthController = class _PasswordStrengthController extends Controller {
+  #numbers = new NumberValueReader();
   static targets = ["input", "meter", "label"];
   static values = {
     minScore: { type: Number, default: 0 },
-    // A JSON list read through `parseStringList` rather than Stimulus's `Array`
-    // type: that reader throws out of the value observer before any callback
-    // runs, so one malformed attribute would stop the meter connecting.
     levels: { type: String, default: "" },
     announceText: { type: String, default: "" }
   };
+  static valueConstraints = {
+    minScore: NUMBER_BOUNDS.nonNegative
+  };
   static actions = ["evaluate", "setScore"];
   static events = ["change", "reconcile"];
-  /** Delay (ms) before one settled level is sent to the shared announcer. */
   static #announceDelay = 200;
   #timers = new SafeTimeout();
-  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
-  #repaint = new MicrotaskCoalescer(() => this.#reconcile());
+  #repaint = new MorphRenderWatcher(() => this.#reconcile());
   #levels = [...DEFAULT_LEVELS];
   #announceId = null;
   #announcedLevel = null;
   #externalScore = null;
   #lastDetail = null;
-  /** Reflects the current DOM state and opens the reconciliation window. */
   connect() {
-    this.#repaint.activate();
-    this.#beforeCache.activate();
+    this.#repaint.observe(this.element);
     this.#lastDetail = this.#detail(this.#render());
+    this.#repaint.schedule();
   }
-  /** Releases the reconciliation window, the cache subscription and the debounce. */
   disconnect() {
-    this.#repaint.cancel();
-    this.#beforeCache.deactivate();
+    this.#repaint.disconnect();
     this.#cancelAnnouncement();
     this.#announcedLevel = null;
     this.#externalScore = null;
     this.#lastDetail = null;
   }
-  /** Re-evaluates strength from the input. Bound via `data-action` (`input`). */
   evaluate() {
     this.#externalScore = null;
     this.#commit();
   }
-  /**
-   * Adopts a score computed outside the built-in heuristic, clamped into the
-   * declared scale. An unreadable value leaves the current score standing, and
-   * the next `evaluate` hands scoring back to the heuristic.
-   */
   setScore(event) {
     const next = toFiniteNumber(event.params?.score ?? event.detail?.score);
     if (next === null) return;
     this.#externalScore = next;
     this.#commit();
   }
-  /** Re-reads the scale when application code or a Turbo morph changes `levels`. */
   levelsValueChanged() {
     this.#levels = this.#readLevels();
     this.#repaint.schedule();
   }
-  /** Repaints when application code or a Turbo morph changes `minScore`. */
   minScoreValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code or a Turbo morph changes `announceText`. */
   announceTextValueChanged() {
     this.#repaint.schedule();
   }
-  /** Scores the field added or replaced at runtime. */
   inputTargetConnected() {
     this.#repaint.schedule();
   }
-  /** Falls back to the pristine state after the scored field is removed. */
   inputTargetDisconnected() {
     this.#repaint.schedule();
   }
-  /** Syncs a meter added or replaced at runtime, which carries no value yet. */
   meterTargetConnected() {
     this.#repaint.schedule();
   }
-  /** Repaints the remaining output after a meter is removed. */
   meterTargetDisconnected() {
     this.#repaint.schedule();
   }
-  /** Fills a readout added or replaced at runtime. */
   labelTargetConnected() {
     this.#repaint.schedule();
   }
-  /** Repaints the remaining output after a readout is removed. */
   labelTargetDisconnected() {
     this.#repaint.schedule();
   }
-  /** Reflects one confirmed scoring pass and offers its level to the reader. */
   #commit() {
     const reading = this.#render();
     this.#lastDetail = this.#detail(reading);
     this.dispatch("change", { detail: this.#lastDetail });
     this.#scheduleAnnouncement(reading);
   }
-  /** Repaints one mutation batch and reports a changed controller-derived state. */
   #reconcile() {
     const previous = this.#lastDetail;
     const owed = this.#announceId !== null;
-    this.#cancelAnnouncement();
     const reading = this.#render();
     const detail = this.#detail(reading);
     this.#lastDetail = detail;
@@ -273,12 +272,6 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
       this.dispatch("reconcile", { detail });
     }
   }
-  /**
-   * Synchronizes the meter ARIA, the root state hooks, the fill custom property
-   * and the visible level readout.
-   *
-   * @stimeoRenderRoot
-   */
   #render() {
     const max = this.#levels.length;
     const score = this.#currentScore(max);
@@ -290,58 +283,35 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
     this.#writeLabel(level);
     return { score, level, max, meetsMin, band };
   }
-  /**
-   * The declared minimum, or the Value's default (`0`, an inert gate) when the
-   * declaration cannot be read as a number. Every comparison against an unread
-   * number answers false, which would fail even the strongest password instead
-   * of leaving the gate off, so the unreadable declaration is confined to its
-   * own Value the way an unreadable scale is.
-   */
   get #minScore() {
-    return Number.isFinite(this.minScoreValue) ? this.minScoreValue : 0;
+    return this.#safeMinScore;
   }
-  /** The externally supplied score when one stands, else the heuristic's. */
   #currentScore(max) {
     if (this.#externalScore !== null) {
       return Math.min(max, Math.max(0, Math.round(this.#externalScore)));
     }
     return this.#score(this.hasInputTarget ? this.inputTarget.value : "", max);
   }
-  /** Syncs the meter target's ARIA value attributes (`0..levels.length`). */
   #reflectMeter(score, max) {
     if (!this.hasMeterTarget) return;
     this.meterTarget.setAttribute("aria-valuemin", "0");
     this.meterTarget.setAttribute("aria-valuemax", String(max));
     this.meterTarget.setAttribute("aria-valuenow", String(score));
   }
-  /**
-   * Reflects the level onto the root: the stable `data-strength` band (absent when
-   * empty), the `data-below-min` hook when the score is under `minScore`, and the
-   * `0–1` fill the consumer's CSS turns into the bar width.
-   */
   #reflectRoot(score, max, band, meetsMin) {
     this.#toggle("data-strength", band, band.length > 0);
     this.#toggle("data-below-min", "true", score > 0 && !meetsMin);
     this.element.style.setProperty("--stimeo--password-strength", String(score / max));
   }
-  /** Writes the visible readout only when its text actually changed. */
   #writeLabel(text) {
     if (!this.hasLabelTarget || this.labelTarget.textContent === text) return;
     this.labelTarget.textContent = text;
   }
-  /**
-   * Locale-independent styling band (one of {@link STRENGTH_BANDS}) for `score`
-   * out of `max`. Empty input → `""`. Maps the position within the declared scale
-   * onto the position within the fixed bands, so both ends stay anchored on any
-   * level count: the weakest score is always `weak` and the strongest `strong`,
-   * and only the middle collapses when the scales differ in size.
-   */
   #band(score, max) {
     if (score <= 0) return "";
     const index = Math.round((score - 1) / (max - 1) * (STRENGTH_BANDS.length - 1));
     return STRENGTH_BANDS[index] ?? STRENGTH_BANDS[0];
   }
-  /** Sets `name` to `value` when `on`, else removes it (value/presence data hook). */
   #toggle(name, value, on) {
     if (on) {
       this.element.setAttribute(name, value);
@@ -349,19 +319,10 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
       this.element.removeAttribute(name);
     }
   }
-  /** The declared level labels, or the defaults when the scale cannot order. */
   #readLevels() {
     const declared = parseStringList(this.levelsValue, DEFAULT_LEVELS);
     return declared.length >= MIN_LEVELS ? declared : [...DEFAULT_LEVELS];
   }
-  /**
-   * Lightweight zero-dependency strength heuristic returning an integer in
-   * `[0, max]` (`max` = number of levels). Empty input is `0` (no level); any
-   * non-empty password is at least `1`. Points accrue from length milestones and
-   * character-class variety, then bucket into the level scale. A tiny alphabet
-   * (≤ 2 distinct characters, e.g. "aaaa") is capped as the weakest, so length
-   * alone cannot mask trivial repetition.
-   */
   #score(password, max) {
     if (password.length === 0) return 0;
     let points = 0;
@@ -373,7 +334,6 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
     const bucketed = Math.round(points / MAX_POINTS * max);
     return Math.min(max, Math.max(1, bucketed));
   }
-  /** Debounces one i18n-neutral message for a level transition into the announcer. */
   #scheduleAnnouncement(reading) {
     this.#cancelAnnouncement();
     if (reading.score === 0) {
@@ -394,31 +354,10 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
       this.#announceId = null;
     }, _PasswordStrengthController.#announceDelay);
   }
-  /** Cancels the one outstanding message without touching visible output. */
   #cancelAnnouncement() {
     if (this.#announceId !== null) this.#timers.clear(this.#announceId);
     this.#announceId = null;
   }
-  /**
-   * Returns every output derived from the field value to its pristine form.
-   *
-   * The value itself is not carried in a Turbo snapshot, so a band, a fill or a
-   * readout left behind would describe a password the restored page no longer
-   * holds. The pass is silent: `connect()` derives the state again from whatever
-   * the restored field contains.
-   */
-  #rewindForCache() {
-    this.#cancelAnnouncement();
-    this.#announcedLevel = null;
-    this.#externalScore = null;
-    this.#lastDetail = null;
-    this.#reflectMeter(0, this.#levels.length);
-    this.#toggle("data-strength", "", false);
-    this.#toggle("data-below-min", "true", false);
-    this.element.style.removeProperty("--stimeo--password-strength");
-    this.#writeLabel("");
-  }
-  /** Selects the public event state from the richer internal reading. */
   #detail(reading) {
     return {
       score: reading.score,
@@ -427,12 +366,19 @@ var PasswordStrengthController = class _PasswordStrengthController extends Contr
       meetsMin: reading.meetsMin
     };
   }
-  /** Compares exactly the state carried by `change` and `reconcile`. */
   #detailsDiffer(left, right) {
     return left.score !== right.score || left.level !== right.level || left.max !== right.max || left.meetsMin !== right.meetsMin;
   }
+  get #safeMinScore() {
+    return this.#numbers.read(
+      this,
+      "minScore",
+      this.minScoreValue,
+      _PasswordStrengthController.values.minScore.default,
+      _PasswordStrengthController.valueConstraints.minScore
+    );
+  }
 };
 
 export { PasswordStrengthController };
-//# sourceMappingURL=password_strength_controller.js.map
 //# sourceMappingURL=password_strength_controller.js.map