stimeo-ui 0.16.0 → 0.18.0

package/dist/controllers/resizable_controller.js

@@ -1,40 +1,48 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/resizable_controller.ts
-
-// src/utils/arrow_step.ts
 function isReservedArrowChord(event, allow = []) {
   if (!event.key.startsWith("Arrow")) return false;
   return event.altKey && !allow.includes("alt") || event.ctrlKey && !allow.includes("ctrl") || event.metaKey && !allow.includes("meta") || event.shiftKey && !allow.includes("shift");
 }
+function hasModifierChord(event) {
+  return event.altKey || event.ctrlKey || event.metaKey || event.shiftKey;
+}
 
-// src/utils/event_owner.ts
 function ownerIndex(candidates, node) {
   if (!(node instanceof Node)) return -1;
   return candidates.findIndex((candidate) => candidate.contains(node));
 }
 
-// src/utils/microtask_coalescer.ts
+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();
+  }
+};
+
 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. */
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -47,85 +55,227 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// 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;
+var MorphRenderWatcher = class {
+  #listeners = new ListenerSet();
+  #pass;
+  #element = null;
+  #onMorph = () => this.#pass.schedule();
+  constructor(run) {
+    this.#pass = new MicrotaskCoalescer(run);
   }
-  /** 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);
-    }
+  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();
+  }
+  get pending() {
+    return this.#pass.pending;
+  }
+  disconnect() {
+    this.#listeners.dispose();
+    this.#pass.cancel();
+    this.#element = null;
   }
-  /** 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 = {
+  finite: { finite: true },
+  positive: { finite: true, exclusiveMin: 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;
+}
+
+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;
   }
 };
 
-// src/utils/tabindex_loan.ts
-var TabindexLoan = class {
+function setAttributeIfChanged(element, name, value, beforeWrite) {
+  if (element.getAttribute(name) === value) return false;
+  if (value === null) element.removeAttribute(name);
+  else element.setAttribute(name, value);
+  return true;
+}
+function deepActiveElement(ownerDocument) {
+  let active = ownerDocument.activeElement;
+  while (active?.shadowRoot?.activeElement) active = active.shadowRoot.activeElement;
+  return active;
+}
+
+function queryOpenDescendants(root, selector) {
+  const matches = [];
+  const roots = [root];
+  for (const scope of roots) {
+    matches.push(...scope.querySelectorAll(selector));
+    if (scope.nodeType === Node.ELEMENT_NODE) {
+      const shadow = scope.shadowRoot;
+      if (shadow) roots.push(shadow);
+    }
+    for (const element of scope.querySelectorAll("*")) {
+      if (element.shadowRoot) roots.push(element.shadowRoot);
+    }
+  }
+  return matches;
+}
+
+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;
+}
+
+function holdsFocus(element) {
+  return element.matches(":focus") || deepActiveElement(element.ownerDocument) === element;
+}
+var TabindexLoan = class _TabindexLoan {
+  static #registry = sharedRegistry(
+    "stimeo-ui.tabindex-loan.registry.v1",
+    () => ({ stacks: /* @__PURE__ */ new WeakMap(), names: /* @__PURE__ */ new Set() })
+  );
   #value;
+  #record;
+  #preserveFocus;
   #lent = /* @__PURE__ */ new Set();
-  /** Returns live loans before Turbo can copy them into its page snapshot. */
-  #beforeCache = new BeforeCacheReset(() => this.returnAll());
-  /**
-   * @param value - the `tabindex` to lend. `"-1"` (the default) is
-   *   programmatically focusable but not a Tab stop; `"0"` is a real Tab stop,
-   *   which a scroll region with no focusable content of its own needs.
-   */
-  constructor(value = "-1") {
+  constructor(value, owner, options = {}) {
     this.#value = value;
+    this.#record = `data-${owner}-tabindex-loan`;
+    this.#preserveFocus = options.preserveFocus === true;
+    _TabindexLoan.#registry.names.add(this.#record);
   }
-  /** Lends `element` the value; no-ops when it already carries a `tabindex`. */
-  lend(element) {
-    if (element.hasAttribute("tabindex")) return;
-    element.setAttribute("tabindex", this.#value);
+  lend(element, options = {}) {
+    const stack = this.#stack(element);
+    const current = element.getAttribute("tabindex");
+    const held = stack.find((hold) => hold.loan === this) ?? stack.find(
+      (hold) => hold.loan === null && hold.record === this.#record && hold.value === this.#value
+    );
+    const linked = stack.at(-1)?.value === current;
+    if (!held && options.onlyIfUnfocusable && (current !== null || element.tabIndex >= 0)) return;
+    if (!held && current !== null && !linked) return;
     this.#lent.add(element);
-    this.#beforeCache.activate();
+    if (held) held.loan = this;
+    else stack.push({ loan: this, record: this.#record, value: this.#value, linked });
+    this.#mark(element, stack);
+    if (current === null || !held && current !== this.#value) {
+      element.setAttribute("tabindex", this.#value);
+    }
+  }
+  return(element) {
+    const stack = this.#stack(element);
+    const hold = stack.find((held) => held.loan === this) ?? stack.find(
+      (held) => held.loan === null && held.record === this.#record && held.value === this.#value
+    );
+    if (!hold) return false;
+    if (!this.#release(element, stack, hold, this.#preserveFocus)) {
+      hold.loan = this;
+      this.#lent.add(element);
+      return false;
+    }
+    this.#lent.delete(element);
+    return true;
   }
-  /** Takes back every loan whose value is still the one that was lent. */
   returnAll() {
-    for (const element of this.#lent) {
-      if (element.getAttribute("tabindex") === this.#value) element.removeAttribute("tabindex");
+    for (const element of Array.from(this.#lent)) this.return(element);
+  }
+  reclaim(element) {
+    if (element.getAttribute(this.#record) !== this.#value) return;
+    const stack = this.#stack(element);
+    const hold = stack.find((held) => held.loan === null && held.record === this.#record);
+    if (hold && !holdsFocus(element)) this.#release(element, stack, hold);
+  }
+  reclaimWithin(root) {
+    for (const element of queryOpenDescendants(root, `[${this.#record}]`)) {
+      this.reclaim(element);
     }
-    this.#lent.clear();
-    this.#beforeCache.deactivate();
   }
-};
-
-// src/utils/transient_hooks.ts
-var TransientHooks = class {
-  #attributes;
-  constructor(options) {
-    this.#attributes = options.attributes;
+  #stack(element) {
+    const stacks = _TabindexLoan.#registry.stacks;
+    const stack = stacks.get(element) ?? this.#seed(element);
+    stacks.set(element, stack);
+    return stack;
   }
-  /** Drops the declared hooks from `element`; what it carries besides stays. */
-  reset(element) {
-    for (const attribute of this.#attributes) element.removeAttribute(attribute);
+  #seed(element) {
+    const current = element.getAttribute("tabindex");
+    const holds = [];
+    for (const record of _TabindexLoan.#registry.names) {
+      const value = element.getAttribute(record);
+      if (value !== null) holds.push({ loan: null, record, value, linked: true });
+    }
+    holds.sort((one, other) => Number(one.value === current) - Number(other.value === current));
+    for (const [index, hold] of holds.entries()) hold.linked = index > 0;
+    return holds;
+  }
+  #release(element, stack, hold, preserveFocus = false) {
+    const current = element.getAttribute("tabindex");
+    const index = stack.indexOf(hold);
+    const owns = current === hold.value && !stack.slice(index + 1).some((above2) => above2.value === current);
+    if (owns && preserveFocus && holdsFocus(element)) return false;
+    stack.splice(index, 1);
+    const above = stack[index];
+    if (above) above.linked &&= hold.linked;
+    this.#mark(element, stack);
+    if (!owns) return true;
+    const below = hold.linked ? stack[index - 1] : void 0;
+    if (!below) element.removeAttribute("tabindex");
+    else if (below.value !== current) element.setAttribute("tabindex", below.value);
+    return true;
+  }
+  #mark(element, stack) {
+    const records = /* @__PURE__ */ new Map([[this.#record, null]]);
+    for (const hold of stack) records.set(hold.record, hold.value);
+    for (const [name, recorded] of records) {
+      setAttributeIfChanged(element, name, recorded);
+    }
   }
 };
 
-// src/controllers/resizable_controller.ts
-var TRANSIENT = new TransientHooks({ attributes: ["data-dragging"] });
 var DEFAULT_MIN = 0;
 var DEFAULT_MAX = 100;
 var DEFAULT_VALUE = 50;
 var DEFAULT_STEP = 1;
-var ResizableController = class extends Controller {
+var ResizableController = class _ResizableController extends Controller {
+  #numbers = new NumberValueReader();
   static targets = ["primary", "secondary", "separator"];
   static values = {
     min: { type: Number, default: DEFAULT_MIN },
@@ -133,55 +283,39 @@ var ResizableController = class extends Controller {
     step: { type: Number, default: DEFAULT_STEP },
     value: { type: Number, default: DEFAULT_VALUE }
   };
+  static valueConstraints = {
+    min: NUMBER_BOUNDS.finite,
+    max: NUMBER_BOUNDS.finite,
+    step: NUMBER_BOUNDS.positive,
+    value: NUMBER_BOUNDS.finite
+  };
   static actions = ["onKeydown", "onPointerDown", "toggle"];
   static events = ["change", "reconcile"];
-  /** Where the divider sat before the current collapse; `null` when unknown. */
   #valueBeforeCollapse = null;
-  /**
-   * The position last painted: moved by each move the user makes — every step of
-   * a drag included — and by each repaint that finds a page-driven move.
-   */
   #painted = DEFAULT_VALUE;
-  /**
-   * The position last confirmed: the one connecting published, then moved by
-   * each `change` and `reconcile`. A drag moves the painted position step by
-   * step and this one only when it ends.
-   */
   #confirmed = DEFAULT_VALUE;
-  /** Aborts in-progress pointer-drag listeners when the drag ends or on teardown. */
-  #dragAbort = null;
-  /** `tabindex` lent to a pane so `F6` can put focus on it; panes carry none. */
-  #paneTabindex = new TabindexLoan();
-  /** Releases the pane cycle listener bound in {@link connect}. */
-  #cycleAbort = null;
-  /** Folds the range and position inputs of one morph batch into a single paint. */
-  #repaint = new MicrotaskCoalescer(() => this.#render());
+  #drag = null;
+  #paneTabindex = new TabindexLoan("-1", this.identifier);
+  #listeners = new ListenerSet();
+  #repaint = new MorphRenderWatcher(() => this.#render());
   connect() {
-    TRANSIENT.reset(this.element);
-    this.#repaint.activate();
+    this.#paneTabindex.reclaimWithin(this.element);
+    this.#repaint.observe(this.element);
     this.#confirmed = this.#position;
     this.#render();
-    this.#cycleAbort = new AbortController();
-    this.element.addEventListener("keydown", this.#onCycleKeydown, {
-      signal: this.#cycleAbort.signal
-    });
+    this.#listeners.add(this.element, "keydown", this.#onCycleKeydown);
   }
-  /** Cancels any active pointer drag so listeners never leak past disconnect. */
   disconnect() {
-    this.#dragAbort?.abort();
-    this.#dragAbort = null;
-    this.#cycleAbort?.abort();
-    this.#cycleAbort = null;
-    this.#repaint.cancel();
+    this.#endDrag();
+    this.#listeners.dispose();
+    this.#repaint.disconnect();
     this.#paneTabindex.returnAll();
-    this.element.removeAttribute("data-dragging");
   }
-  /** Moves focus to the next pane on `F6`, wrapping; entering at the first one. */
   #onCycleKeydown = (event) => {
     if (event.key !== "F6") return;
     if (event.isComposing) return;
     if (event.defaultPrevented) return;
-    if (event.altKey || event.ctrlKey || event.metaKey || event.shiftKey) return;
+    if (hasModifierChord(event)) return;
     const panes = [];
     if (this.hasPrimaryTarget) panes.push(this.primaryTarget);
     if (this.hasSecondaryTarget) panes.push(this.secondaryTarget);
@@ -192,40 +326,42 @@ var ResizableController = class extends Controller {
     this.#paneTabindex.lend(next);
     next.focus();
   };
-  /** Re-renders when application code (or a Turbo morph) changes `value` at runtime. */
   valueValueChanged() {
     this.#repaint.schedule();
   }
-  /** Re-renders when application code (or a Turbo morph) changes `min` at runtime. */
   minValueChanged() {
     this.#repaint.schedule();
   }
-  /** Re-renders when application code (or a Turbo morph) changes `max` at runtime. */
   maxValueChanged() {
     this.#repaint.schedule();
   }
-  /** Re-publishes range and position onto a separator swapped in after connect. */
   separatorTargetConnected() {
     this.#repaint.schedule();
   }
-  /** Starts active pointer drag tracking and locks capture. */
+  separatorTargetDisconnected(separator) {
+    if (this.#drag?.separator === separator && !this.separatorTargets.includes(separator)) {
+      this.#endDrag();
+    }
+    this.#repaint.schedule();
+  }
   onPointerDown(event) {
     if (!this.hasSeparatorTarget || event.button !== 0) return;
     event.preventDefault();
-    const separator = this.separatorTarget;
+    const separators = this.separatorTargets;
+    const separator = separators[ownerIndex(separators, event.target)] ?? this.separatorTarget;
     separator.setPointerCapture(event.pointerId);
     separator.focus();
     this.element.setAttribute("data-dragging", "true");
-    this.#dragAbort?.abort();
+    this.#drag?.abort.abort();
     const abort = new AbortController();
-    this.#dragAbort = abort;
+    this.#drag = { separator, pointerId: event.pointerId, abort };
     separator.addEventListener("pointermove", this.#onPointerMove, { signal: abort.signal });
     separator.addEventListener("pointerup", this.#onPointerUp, { signal: abort.signal });
     separator.addEventListener("pointercancel", this.#onPointerUp, { signal: abort.signal });
   }
-  /** Keydown adjustments for ArrowUp/Down/Left/Right and Home/End. */
   onKeydown(event) {
     if (isReservedArrowChord(event)) return;
+    if ((event.key === "Home" || event.key === "End") && hasModifierChord(event)) return;
     if (!this.hasSeparatorTarget) return;
     const { min, max } = this.#range;
     const isVertical = this.#isVertical;
@@ -279,7 +415,6 @@ var ResizableController = class extends Controller {
       this.#commit(nextValue);
     }
   }
-  /** Collapses the primary pane to its minimum, or returns it to the last position. */
   toggle() {
     const { min, max } = this.#range;
     if (this.#position > min) {
@@ -298,26 +433,25 @@ var ResizableController = class extends Controller {
     const fraction = Number.isFinite(raw) ? Math.max(0, Math.min(raw, 1)) : 0;
     this.#move(Math.round(fraction * 100));
   };
-  #onPointerUp = (event) => {
-    this.element.removeAttribute("data-dragging");
-    this.#dragAbort?.abort();
-    this.#dragAbort = null;
-    if (this.hasSeparatorTarget) {
-      this.separatorTarget.releasePointerCapture(event.pointerId);
-    }
+  #onPointerUp = () => {
+    this.#endDrag();
     this.#confirm();
   };
-  /** Moves to a position the user chose and reports it if it moved. */
+  #endDrag() {
+    this.element.removeAttribute("data-dragging");
+    const drag = this.#drag;
+    this.#drag = null;
+    if (!drag) return;
+    drag.abort.abort();
+    try {
+      drag.separator.releasePointerCapture?.(drag.pointerId);
+    } catch {
+    }
+  }
   #commit(raw) {
     this.#move(raw);
     this.#confirm();
   }
-  /**
-   * Stores the clamped position the user moved to and paints it. The painted
-   * position moves with it before anything is reported, so the repaint the Value
-   * write schedules — and any move a subscriber makes while `change` is
-   * dispatched — is measured from this position.
-   */
   #move(raw) {
     const { min, max } = this.#range;
     const position = Math.max(min, Math.min(raw, max));
@@ -325,14 +459,6 @@ var ResizableController = class extends Controller {
     this.#painted = position;
     this.#paint();
   }
-  /**
-   * Publishes the position the Values declare without writing it back. A
-   * position the user did not paint is the page's move, reported once as
-   * `reconcile` unless it lands on the position last confirmed — a drag the page
-   * puts back where it started has nothing new to report.
-   *
-   * @stimeoRenderRoot
-   */
   #render() {
     this.#paint();
     const position = this.#position;
@@ -342,11 +468,9 @@ var ResizableController = class extends Controller {
     this.#confirmed = position;
     this.dispatch("reconcile", { detail: this.#detail(position) });
   }
-  /**
-   * Publishes the position: the fraction consumer CSS multiplies a pane by, and
-   * the range assistive tech reads off the separator.
-   */
   #paint() {
+    if (this.#drag) this.element.setAttribute("data-dragging", "true");
+    else this.element.removeAttribute("data-dragging");
     const { min, max } = this.#range;
     const position = this.#position;
     this.element.style.setProperty("--stimeo--resizable-fraction", String(position / 100));
@@ -356,43 +480,68 @@ var ResizableController = class extends Controller {
       this.separatorTarget.setAttribute("aria-valuemax", String(max));
     }
   }
-  /**
-   * Reports the published position as `change` when the user's operation moved
-   * it from the position last confirmed. A key at an edge, a press released
-   * without moving and a drag released where it started report nothing.
-   */
   #confirm() {
     const position = this.#position;
     if (position === this.#confirmed) return;
     this.#confirmed = position;
     this.dispatch("change", { detail: this.#detail(position) });
   }
-  /** The detail both events carry for `position`. */
   #detail(position) {
     return { value: position, fraction: position / 100 };
   }
-  /** The declared range after validation; an unreadable bound uses its default. */
   get #range() {
-    const min = Number.isFinite(this.minValue) ? this.minValue : DEFAULT_MIN;
-    const max = Number.isFinite(this.maxValue) ? this.maxValue : DEFAULT_MAX;
+    const min = this.#safeMin;
+    const max = this.#safeMax;
     return { min, max: Math.max(min, max) };
   }
-  /** The declared position, clamped into the validated range. */
   get #position() {
     const { min, max } = this.#range;
-    const value = Number.isFinite(this.valueValue) ? this.valueValue : DEFAULT_VALUE;
+    const value = this.#safeValue;
     return Math.max(min, Math.min(value, max));
   }
-  /** The keyboard increment; a non-positive or unreadable one uses the default. */
   get #step() {
-    return Number.isFinite(this.stepValue) && this.stepValue > 0 ? this.stepValue : DEFAULT_STEP;
+    return this.#safeStep;
   }
-  /** Whether the divider runs vertically; a separator that does not say is horizontal. */
   get #isVertical() {
     return this.hasSeparatorTarget && this.separatorTarget.getAttribute("aria-orientation") === "vertical";
   }
+  get #safeMin() {
+    return this.#numbers.read(
+      this,
+      "min",
+      this.minValue,
+      _ResizableController.values.min.default,
+      _ResizableController.valueConstraints.min
+    );
+  }
+  get #safeMax() {
+    return this.#numbers.read(
+      this,
+      "max",
+      this.maxValue,
+      _ResizableController.values.max.default,
+      _ResizableController.valueConstraints.max
+    );
+  }
+  get #safeStep() {
+    return this.#numbers.read(
+      this,
+      "step",
+      this.stepValue,
+      _ResizableController.values.step.default,
+      _ResizableController.valueConstraints.step
+    );
+  }
+  get #safeValue() {
+    return this.#numbers.read(
+      this,
+      "value",
+      this.valueValue,
+      _ResizableController.values.value.default,
+      _ResizableController.valueConstraints.value
+    );
+  }
 };
 
 export { ResizableController };
-//# sourceMappingURL=resizable_controller.js.map
 //# sourceMappingURL=resizable_controller.js.map