stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/meter_controller.js

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/meter_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,10 +145,9 @@ function rangeFraction(value, min, max) {
   return Math.min(1, Math.max(0, fraction));
 }
 
-// src/controllers/meter_controller.ts
 var OWNED_VALUE_TEXT = "owns-valuetext";
-var MeterController = class extends Controller {
-  /** The marker above, in the namespace this controller is registered under. */
+var MeterController = class _MeterController extends Controller {
+  #numbers = new NumberValueReader();
   get #ownedValueText() {
     return `data-${this.identifier}-${OWNED_VALUE_TEXT}`;
   }
@@ -93,114 +162,85 @@ var MeterController = class extends Controller {
     optimum: { type: Number, default: 0 },
     valueText: { type: String, default: "" }
   };
+  static valueConstraints = {
+    value: NUMBER_BOUNDS.finite,
+    min: NUMBER_BOUNDS.finite,
+    max: NUMBER_BOUNDS.finite,
+    low: NUMBER_BOUNDS.finite,
+    high: NUMBER_BOUNDS.finite,
+    optimum: NUMBER_BOUNDS.finite
+  };
   static actions = ["setValue"];
   static events = ["change"];
-  /**
-   * 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();
   });
-  /** The segment last announced, so only a change is read out. */
-  #announcedState = null;
+  #shownState = null;
   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 measured value from an action param (`amount`) or a
-   * `detail.value` CustomEvent, syncs ARIA and `data-state`, and dispatches
-   * `change` with the value, ratio, and computed segment.
-   */
   setValue(event) {
     const next = toFiniteNumber(event.params?.amount ?? event.detail?.value);
     if (next === null) return;
     this.valueValue = this.#clamp(next);
+    const shown = this.#shownState;
     const reading = this.#render();
     this.dispatch("change", { detail: reading });
-    if (reading.state !== this.#announcedState) {
-      this.#announcedState = reading.state;
+    if (reading.state !== shown) {
       announce(
         fillTemplate(this.announceTextValue, { state: reading.state, value: reading.value })
       );
     }
   }
-  /** 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 `low` at runtime. */
   lowValueChanged() {
     this.#repaint.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `high` at runtime. */
   highValueChanged() {
     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));
   }
-  /** Whether a threshold attribute is present (absent = no threshold). */
   #hasThreshold(name) {
     return this.element.hasAttribute(`data-${this.identifier}-${name}-value`);
   }
-  /**
-   * Classifies `value` into a `low`/`medium`/`high` segment. Values at or below
-   * `low` are `low`; at or above `high` are `high`; otherwise `medium`. With
-   * neither threshold present, everything is `medium`.
-   */
   #stateOf(value) {
-    if (this.#hasThreshold("low") && value <= this.lowValue) return "low";
-    if (this.#hasThreshold("high") && value >= this.highValue) return "high";
+    if (this.#hasThreshold("low") && value <= this.#safeLow) return "low";
+    if (this.#hasThreshold("high") && value >= this.#safeHigh) return "high";
     return "medium";
   }
-  /**
-   * Reflects value/range onto ARIA, the segment onto `data-state`, and the ratio.
-   * The reading is derived once and returned, so the `change` detail reports the
-   * same numbers the DOM just received.
-   *
-   * @stimeoRenderRoot
-   */
   #render() {
-    const value = this.#clamp(this.valueValue);
+    const value = this.#clamp(this.#safeValue);
     const reading = {
       value,
-      ratio: rangeFraction(value, this.minValue, this.maxValue),
+      ratio: rangeFraction(value, this.#safeMin, this.#safeMax),
       state: this.#stateOf(value)
     };
-    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));
     this.element.setAttribute("aria-valuenow", String(reading.value));
     this.element.style.setProperty("--stimeo--meter-ratio", String(reading.ratio));
     this.element.setAttribute("data-state", reading.state);
     this.#applyValueText(reading);
+    this.#shownState = reading.state;
     return reading;
   }
-  /**
-   * Sets `aria-valuetext` from the consumer-provided template, substituting
-   * `{value}`, `{percent}`, and `{state}`. Kept 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, ratio, state }) {
     if (this.valueTextValue.length === 0) {
       if (this.element.hasAttribute(this.#ownedValueText)) {
@@ -214,8 +254,52 @@ var MeterController = class extends Controller {
     this.element.setAttribute("aria-valuetext", text);
     this.element.setAttribute(this.#ownedValueText, "");
   }
+  get #safeValue() {
+    return this.#numbers.read(
+      this,
+      "value",
+      this.valueValue,
+      _MeterController.values.value.default,
+      _MeterController.valueConstraints.value
+    );
+  }
+  get #safeMin() {
+    return this.#numbers.read(
+      this,
+      "min",
+      this.minValue,
+      _MeterController.values.min.default,
+      _MeterController.valueConstraints.min
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(
+      this,
+      "max",
+      this.maxValue,
+      _MeterController.values.max.default,
+      _MeterController.valueConstraints.max
+    );
+  }
+  get #safeLow() {
+    return this.#numbers.read(
+      this,
+      "low",
+      this.lowValue,
+      _MeterController.values.low.default,
+      _MeterController.valueConstraints.low
+    );
+  }
+  get #safeHigh() {
+    return this.#numbers.read(
+      this,
+      "high",
+      this.highValue,
+      _MeterController.values.high.default,
+      _MeterController.valueConstraints.high
+    );
+  }
 };
 
 export { MeterController };
-//# sourceMappingURL=meter_controller.js.map
 //# sourceMappingURL=meter_controller.js.map