stimeo-ui 0.16.0 → 0.18.0

data/dist/controllers/highlight_controller.js

@@ -1,44 +1,25 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/highlight_controller.ts
+var MAX_TIMER_DELAY_MS = 2147483647;
 
-// src/utils/safe_timeout.ts
 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);
@@ -55,16 +36,9 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/utils/keyed_timers.ts
 var KeyedTimers = class {
   #timers = new SafeTimeout();
-  /** The pending timer of each key; an entry lives exactly as long as its timer. */
   #pending = /* @__PURE__ */ new Map();
-  /**
-   * Arms `callback` after `delay` ms for `key`, cancelling the timer `key` had
-   * pending. The entry is dropped before the callback runs, so the callback sees
-   * the key unarmed and may arm it again for the next round.
-   */
   set(key, callback, delay) {
     this.clear(key);
     const id = this.#timers.set(() => {
@@ -73,86 +47,145 @@ var KeyedTimers = class {
     }, delay);
     this.#pending.set(key, id);
   }
-  /**
-   * Cancels `key`'s pending timer, if it has one.
-   *
-   * A timer id is a positive integer, so `-1` stands for "nothing pending" and
-   * the registry ignores an id it does not own — the unarmed case needs no
-   * branch of its own, and no other key's timer can be reached from here.
-   */
   clear(key) {
     this.#timers.clear(this.#pending.get(key) ?? -1);
     this.#pending.delete(key);
   }
-  /**
-   * Cancels every pending timer and forgets every key. Call this from a
-   * controller's `disconnect()` so no timer, and no entry, outlives the element.
-   */
   clearAll() {
     this.#timers.clearAll();
     this.#pending.clear();
   }
-  /** Whether `key` has a timer pending. */
   has(key) {
     return this.#pending.has(key);
   }
 };
 
-// src/utils/reduced_motion.ts
+var NUMBER_BOUNDS = {
+  timer: { finite: true, min: 0, max: MAX_TIMER_DELAY_MS }};
+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 readNumber(raw, fallback, bounds) {
+  return matchesNumberBounds(raw, bounds) ? raw : fallback;
+}
+
+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 prefersReducedMotion() {
   return typeof window.matchMedia === "function" && window.matchMedia("(prefers-reduced-motion: reduce)").matches;
 }
 
-// src/utils/transient_hooks.ts
+function sharedRegistry(key, create) {
+  const symbol = Symbol.for(key);
+  const scope = globalThis;
+  const existing = scope[symbol];
+  if (existing !== void 0) return existing;
+  const registry = create();
+  Object.defineProperty(globalThis, symbol, { value: registry });
+  return registry;
+}
+
 var TransientHooks = class {
   #attributes;
   constructor(options) {
     this.#attributes = options.attributes;
   }
-  /** Drops the declared hooks from `element`; what it carries besides stays. */
   reset(element) {
     for (const attribute of this.#attributes) element.removeAttribute(attribute);
   }
 };
 
-// src/controllers/highlight_controller.ts
 var TRANSIENT = new TransientHooks({ attributes: ["data-highlight"] });
-var hookOwners = /* @__PURE__ */ new WeakMap();
-var HighlightController = class extends Controller {
+var hookOwners = sharedRegistry(
+  "stimeo-ui.highlight.registry.v1",
+  () => /* @__PURE__ */ new WeakMap()
+);
+var HighlightController = class _HighlightController extends Controller {
+  #numbers = new NumberValueReader();
   static values = {
     duration: { type: Number, default: 1500 },
     observe: { type: Boolean, default: false }
   };
+  static valueConstraints = {
+    duration: NUMBER_BOUNDS.timer
+  };
   static events = ["start", "end"];
-  /**
-   * The removal timer this connection has outstanding for each element. Which
-   * connection owns an element's hook is answered by the shared owner registry above.
-   */
   #removal = new KeyedTimers();
   #observer = null;
+  #watching = false;
+  #connected = false;
   connect() {
     this.#clearArrivedHook(this.element);
+    this.#connected = true;
     if (this.observeValue) {
-      for (const child of this.element.children) this.#clearArrivedHook(child);
-      if (typeof MutationObserver !== "undefined") {
-        this.#observer = new MutationObserver((mutations) => this.#onMutations(mutations));
-        this.#observer.observe(this.element, { childList: true });
-      }
+      this.#watchChildren();
       return;
     }
     this.#highlight(this.element);
   }
   disconnect() {
+    this.#connected = false;
+    this.#stopWatching();
+    this.#removal.clearAll();
+  }
+  observeValueChanged() {
+    if (!this.#connected || this.observeValue === this.#watching) return;
+    if (this.#watching) this.#stopWatching();
+    else this.#watchChildren();
+  }
+  #watchChildren() {
+    this.#watching = true;
+    for (const child of this.element.children) {
+      const owner = hookOwners.get(child);
+      if (owner === void 0 || !owner.pending()) this.#clearArrivedHook(child);
+    }
+    if (typeof MutationObserver !== "undefined") {
+      this.#observer = new MutationObserver((mutations) => this.#onMutations(mutations));
+      this.#observer.observe(this.element, { childList: true });
+    }
+  }
+  #stopWatching() {
+    this.#watching = false;
     this.#observer?.disconnect();
     this.#observer = null;
-    this.#removal.clearAll();
   }
-  /** Drops a hook that arrived with the DOM, along with this connection's claim on it. */
   #clearArrivedHook(el) {
-    if (hookOwners.get(el) === this) hookOwners.delete(el);
+    if (hookOwners.get(el)?.owner === this) hookOwners.delete(el);
     TRANSIENT.reset(el);
   }
-  /** Highlights every element child added by a childList mutation. */
   #onMutations(mutations) {
     for (const mutation of mutations) {
       for (const node of mutation.addedNodes) {
@@ -160,11 +193,6 @@ var HighlightController = class extends Controller {
       }
     }
   }
-  /**
-   * Flags `el` with `data-highlight` and schedules its removal (unless reduced-motion).
-   *
-   * @stimeoRuntimeOnly `duration` is the length of the one emphasis this call arms.
-   */
   #highlight(el) {
     if (prefersReducedMotion()) return;
     this.#releasePending(el);
@@ -177,27 +205,31 @@ var HighlightController = class extends Controller {
         el.removeAttribute("data-highlight");
         this.dispatch("end", { target: el, detail: { element: el } });
       },
-      this.durationValue
+      this.#safeDuration
     );
-    hookOwners.set(el, this);
+    hookOwners.set(el, {
+      owner: this,
+      pending: () => this.#removal.has(el),
+      cancel: () => this.#cancelPending(el)
+    });
   }
-  /**
-   * Releases whichever removal timer holds `el`'s hook. The row may have been
-   * highlighted inside a different watched container before it moved here, and that
-   * container's timer is reachable only through the shared owner registry.
-   */
   #releasePending(el) {
     const owner = hookOwners.get(el);
-    if (owner !== void 0 && owner !== this) owner.#cancelPending(el);
-    this.#cancelPending(el);
+    if (owner !== void 0 && owner.owner !== this) owner.cancel();
   }
-  /** Releases `el`'s pending removal timer, if it has one, and this connection's claim. */
   #cancelPending(el) {
     this.#removal.clear(el);
-    hookOwners.delete(el);
+  }
+  get #safeDuration() {
+    return this.#numbers.read(
+      this,
+      "duration",
+      this.durationValue,
+      _HighlightController.values.duration.default,
+      _HighlightController.valueConstraints.duration
+    );
   }
 };
 
 export { HighlightController };
-//# sourceMappingURL=highlight_controller.js.map
 //# sourceMappingURL=highlight_controller.js.map