stimeo-ui 0.2.0 → 0.2.1

data/dist/controllers/scrollspy_controller.js

@@ -18,6 +18,11 @@ var IntersectionWatcher = class {
    * (Re)creates the observer and observes `targets`. Returns `false` — leaving
    * the watcher inert — without `IntersectionObserver` support (very old
    * browsers; the caller's no-JS fallback stays in charge) or with no targets.
+   *
+   * @throws Whatever the platform throws for an invalid `rootMargin`/`threshold`
+   *   or a failing `observe()`. The exception is passed through unchanged, but
+   *   the watcher rolls back first: every target observed so far is released and
+   *   `active` stays `false`, so a caller that retries starts from a clean slate.
    */
   start(targets, options = {}) {
     this.stop();
@@ -25,25 +30,42 @@ var IntersectionWatcher = class {
     const list = Array.isArray(targets) ? targets : [targets];
     if (list.length === 0) return false;
     const root = "root" in options ? options.root ?? null : options.rootSelector ? document.querySelector(options.rootSelector) : null;
-    this.#active = true;
-    this.#observer = new IntersectionObserver(
-      (entries) => {
-        if (this.#active) this.#onEntries(entries);
-      },
-      { root, rootMargin: options.rootMargin, threshold: options.threshold }
-    );
-    for (const target of list) this.#observer.observe(target);
-    return true;
+    let observer = null;
+    try {
+      observer = new IntersectionObserver(
+        (entries) => {
+          if (this.#active && this.#observer === observer) this.#onEntries(entries);
+        },
+        { root, rootMargin: options.rootMargin, threshold: options.threshold }
+      );
+      for (const target of list) observer.observe(target);
+      this.#observer = observer;
+      this.#active = true;
+      return true;
+    } catch (error) {
+      observer?.disconnect();
+      this.#observer = null;
+      this.#active = false;
+      throw error;
+    }
   }
   /**
    * Re-delivers `target`'s CURRENT intersection state: `IntersectionObserver`
    * only reports *changes*, but `observe()` always reports the present state,
    * so unobserve→observe turns "still intersecting" into a fresh callback.
+   *
+   * @throws Whatever `unobserve()`/`observe()` throws. The watcher is stopped
+   *   first, so it never stays live with a half-rearmed target.
    */
   rearm(target) {
     if (!this.#observer) return;
-    this.#observer.unobserve(target);
-    this.#observer.observe(target);
+    try {
+      this.#observer.unobserve(target);
+      this.#observer.observe(target);
+    } catch (error) {
+      this.stop();
+      throw error;
+    }
   }
   /** Severs the observer; late queued callbacks become no-ops via the guard. */
   stop() {

data/dist/controllers/separator_controller.js

@@ -0,0 +1,87 @@
+import { Controller } from '@hotwired/stimulus';
+
+// src/controllers/separator_controller.ts
+var SeparatorController = class extends Controller {
+  static values = {
+    orientation: { type: String, default: "horizontal" },
+    focusable: { type: Boolean, default: false },
+    step: { type: Number, default: 1 }
+  };
+  static actions = ["onKeydown"];
+  static events = ["change"];
+  connect() {
+    if (!this.element.hasAttribute("role")) {
+      this.element.setAttribute("role", "separator");
+    }
+    if (!this.element.hasAttribute("aria-orientation")) {
+      this.element.setAttribute("aria-orientation", this.orientationValue);
+    }
+    if (this.focusableValue) {
+      if (!this.element.hasAttribute("tabindex")) {
+        this.element.setAttribute("tabindex", "0");
+      }
+      this.#setDefault("aria-valuemin", "0");
+      this.#setDefault("aria-valuemax", "100");
+      this.#setDefault("aria-valuenow", String(this.#clamp(this.#value)));
+    }
+  }
+  /** Adjusts the value on arrow / Home / End keys (focusable variant only). */
+  onKeydown(event) {
+    if (!this.focusableValue) return;
+    const horizontal = this.element.getAttribute("aria-orientation") !== "vertical";
+    let next = null;
+    switch (event.key) {
+      case "ArrowUp":
+        if (horizontal) next = this.#value + this.stepValue;
+        break;
+      case "ArrowDown":
+        if (horizontal) next = this.#value - this.stepValue;
+        break;
+      case "ArrowRight":
+        if (!horizontal) next = this.#value + this.stepValue;
+        break;
+      case "ArrowLeft":
+        if (!horizontal) next = this.#value - this.stepValue;
+        break;
+      case "Home":
+        next = this.#min;
+        break;
+      case "End":
+        next = this.#max;
+        break;
+      default:
+        return;
+    }
+    if (next === null) return;
+    event.preventDefault();
+    const clamped = this.#clamp(next);
+    if (clamped === this.#value) return;
+    this.element.setAttribute("aria-valuenow", String(clamped));
+    this.dispatch("change", { detail: { value: clamped } });
+  }
+  get #value() {
+    return this.#numericAttr("aria-valuenow", 0);
+  }
+  get #min() {
+    return this.#numericAttr("aria-valuemin", 0);
+  }
+  get #max() {
+    return this.#numericAttr("aria-valuemax", 100);
+  }
+  #clamp(value) {
+    return Math.min(this.#max, Math.max(this.#min, value));
+  }
+  #numericAttr(name, fallback) {
+    const parsed = Number.parseFloat(this.element.getAttribute(name) ?? "");
+    return Number.isNaN(parsed) ? fallback : parsed;
+  }
+  #setDefault(name, value) {
+    if (!this.element.hasAttribute(name)) {
+      this.element.setAttribute(name, value);
+    }
+  }
+};
+
+export { SeparatorController };
+//# sourceMappingURL=separator_controller.js.map
+//# sourceMappingURL=separator_controller.js.map