stimeo-ui 0.15.0 → 0.17.0

data/dist/controllers/progress_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/progress_controller.ts
-
-// src/utils/announce.ts
 function announce(message, options = {}) {
   const text = message.trim();
   if (text.length === 0) return;
@@ -19,34 +16,59 @@ function fillTemplate(template, values) {
   });
 }
 
-// src/utils/coerce.ts
+var NUMBER_BOUNDS = {
+  finite: { finite: true }};
+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;
+}
+
 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;
@@ -59,7 +81,55 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/range.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;
+  }
+};
+
 function rangeFraction(value, min, max) {
   const span = max - min;
   if (!(span > 0)) return 0;
@@ -75,9 +145,12 @@ function rangeFraction(value, min, max) {
   return Math.min(1, Math.max(0, fraction));
 }
 
-// src/controllers/progress_controller.ts
-var OWNED_VALUE_TEXT = "data-stimeo--progress-owns-valuetext";
-var ProgressController = class extends Controller {
+var OWNED_VALUE_TEXT = "owns-valuetext";
+var ProgressController = class _ProgressController extends Controller {
+  #numbers = new NumberValueReader();
+  get #ownedValueText() {
+    return `data-${this.identifier}-${OWNED_VALUE_TEXT}`;
+  }
   static targets = ["bar"];
   static values = {
     value: { type: Number, default: 0 },
@@ -87,29 +160,23 @@ var ProgressController = class extends Controller {
     valueText: { type: String, default: "" },
     announceText: { type: String, default: "" }
   };
+  static valueConstraints = {
+    value: NUMBER_BOUNDS.finite,
+    min: NUMBER_BOUNDS.finite,
+    max: NUMBER_BOUNDS.finite
+  };
   static actions = ["setValue"];
   static events = ["change", "complete"];
-  /**
-   * Collapses a morph that swaps several render inputs at once into one repaint.
-   * A single update usually rewrites the whole set, and each Value would otherwise
-   * repaint on its own.
-   */
-  #repaint = new MicrotaskCoalescer(() => {
+  #repaint = new MorphRenderWatcher(() => {
     this.#render();
   });
   connect() {
-    this.#repaint.activate();
+    this.#repaint.observe(this.element);
     this.#render();
   }
-  /** Closes the window in which a queued repaint may still run. */
   disconnect() {
-    this.#repaint.cancel();
+    this.#repaint.disconnect();
   }
-  /**
-   * Updates the progress value from an action param (`amount`) or a
-   * `detail.value` CustomEvent, normalizes it into range, syncs ARIA, and
-   * dispatches `change` (always) plus `complete` when `max` is reached.
-   */
   setValue(event) {
     const next = toFiniteNumber(event.params?.amount ?? event.detail?.value);
     if (next === null) return;
@@ -118,49 +185,37 @@ var ProgressController = class extends Controller {
     this.indeterminateValue = false;
     this.#render();
     this.dispatch("change", { detail: { value, ratio: this.#ratio } });
-    if (value >= this.maxValue) {
+    if (value >= this.#safeMax) {
       this.dispatch("complete", { detail: { value } });
       announce(
         fillTemplate(this.announceTextValue, { value, percent: Math.round(this.#ratio * 100) })
       );
     }
   }
-  /** Repaints when application code (or a Turbo morph) changes `indeterminate` at runtime. */
   indeterminateValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `value` at runtime. */
   valueValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `min` at runtime. */
   minValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `max` at runtime. */
   maxValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `valueText` at runtime. */
   valueTextValueChanged() {
     this.#repaint.schedule();
   }
-  /** Clamps `raw` into the configured `[min, max]` range. */
   #clamp(raw) {
-    return Math.min(this.maxValue, Math.max(this.minValue, raw));
+    return Math.min(this.#safeMax, Math.max(this.#safeMin, raw));
   }
-  /** Current fraction of the range in `[0, 1]`; `0` when the range is empty. */
   get #ratio() {
-    return rangeFraction(this.valueValue, this.minValue, this.maxValue);
+    return rangeFraction(this.#safeValue, this.#safeMin, this.#safeMax);
   }
-  /**
-   * Reflects value/range/indeterminate onto ARIA, `data-state`, and the ratio.
-   *
-   * @stimeoRenderRoot
-   */
   #render() {
-    this.element.setAttribute("aria-valuemin", String(this.minValue));
-    this.element.setAttribute("aria-valuemax", String(this.maxValue));
+    this.element.setAttribute("aria-valuemin", String(this.#safeMin));
+    this.element.setAttribute("aria-valuemax", String(this.#safeMax));
     if (this.indeterminateValue) {
       this.element.removeAttribute("aria-valuenow");
       this.#clearOwnValueText();
@@ -168,19 +223,12 @@ var ProgressController = class extends Controller {
       this.element.setAttribute("data-state", "indeterminate");
       return;
     }
-    const value = this.#clamp(this.valueValue);
+    const value = this.#clamp(this.#safeValue);
     this.element.setAttribute("aria-valuenow", String(value));
     this.element.style.setProperty("--stimeo--progress-ratio", String(this.#ratio));
     this.element.setAttribute("data-state", "determinate");
     this.#applyValueText(value);
   }
-  /**
-   * Sets `aria-valuetext` from the consumer-provided template, substituting
-   * `{value}` and `{percent}`. Left to the consumer so the human-readable text
-   * stays i18n-neutral in the library. With no template the attribute belongs to
-   * the consumer, so only a text this controller wrote is taken back
-   * ({@link OWNED_VALUE_TEXT}).
-   */
   #applyValueText(value) {
     if (this.valueTextValue.length === 0) {
       this.#clearOwnValueText();
@@ -189,16 +237,41 @@ var ProgressController = class extends Controller {
     const percent = Math.round(this.#ratio * 100);
     const text = this.valueTextValue.replaceAll("{value}", String(value)).replaceAll("{percent}", String(percent));
     this.element.setAttribute("aria-valuetext", text);
-    this.element.setAttribute(OWNED_VALUE_TEXT, "");
+    this.element.setAttribute(this.#ownedValueText, "");
   }
-  /** Removes `aria-valuetext` only when this controller is the one that wrote it. */
   #clearOwnValueText() {
-    if (!this.element.hasAttribute(OWNED_VALUE_TEXT)) return;
+    if (!this.element.hasAttribute(this.#ownedValueText)) return;
     this.element.removeAttribute("aria-valuetext");
-    this.element.removeAttribute(OWNED_VALUE_TEXT);
+    this.element.removeAttribute(this.#ownedValueText);
+  }
+  get #safeValue() {
+    return this.#numbers.read(
+      this,
+      "value",
+      this.valueValue,
+      _ProgressController.values.value.default,
+      _ProgressController.valueConstraints.value
+    );
+  }
+  get #safeMin() {
+    return this.#numbers.read(
+      this,
+      "min",
+      this.minValue,
+      _ProgressController.values.min.default,
+      _ProgressController.valueConstraints.min
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(
+      this,
+      "max",
+      this.maxValue,
+      _ProgressController.values.max.default,
+      _ProgressController.valueConstraints.max
+    );
   }
 };
 
 export { ProgressController };
-//# sourceMappingURL=progress_controller.js.map
 //# sourceMappingURL=progress_controller.js.map