stimeo-ui 0.16.0 → 0.17.0

data/dist/controllers/relative_time_controller.js

@@ -1,37 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/relative_time_controller.ts
-
-// 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;
-  }
-  /** 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);
-    }
-  }
-  /** 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);
-  }
-};
-
-// src/utils/intl_format.ts
 var formatters = /* @__PURE__ */ new WeakMap();
 function intlFormatter(factory, locale, options, fallbackLocale) {
   const cache = cacheFor(factory);
@@ -60,32 +28,37 @@ function construct(factory, locale, options, fallbackLocale) {
   }
 }
 
-// src/utils/locale.ts
 function resolveLocale(element, declared = "") {
   return declared || element.closest("[lang]")?.getAttribute("lang") || void 0;
 }
 
-// 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. */
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -98,43 +71,96 @@ var MicrotaskCoalescer = class {
   }
 };
 
-// src/utils/safe_timeout.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 MAX_TIMER_DELAY_MS = 2147483647;
+
+var NUMBER_BOUNDS = {
+  nonNegative: { finite: true, min: 0 },
+  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;
+  }
+};
+
 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);
@@ -151,7 +177,6 @@ var SafeTimeout = class extends TimerRegistry {
   }
 };
 
-// src/controllers/relative_time_controller.ts
 var YEAR_SCALE = { limit: Number.POSITIVE_INFINITY, unit: "year", ms: 315576e5 };
 var UNITS = [
   { limit: 60, unit: "second", ms: 1e3 },
@@ -163,112 +188,105 @@ var UNITS = [
   YEAR_SCALE
 ];
 var RELATIVE_OPTIONS = { numeric: "auto" };
-var RelativeTimeController = class extends Controller {
+var TEXT_RECORD = "text";
+var RelativeTimeController = class _RelativeTimeController extends Controller {
+  #numbers = new NumberValueReader();
   static values = {
     locale: { type: String, default: "" },
     threshold: { type: Number, default: 0 },
     tickInterval: { type: Number, default: 6e4 }
   };
+  static valueConstraints = {
+    threshold: NUMBER_BOUNDS.nonNegative,
+    tickInterval: NUMBER_BOUNDS.timer
+  };
   #timers = new SafeTimeout();
-  /** Collapses a morph that swaps several render inputs at once into one repaint. */
-  #resync = new MicrotaskCoalescer(() => this.#resyncToValues());
-  #beforeCache = new BeforeCacheReset(() => this.#rewindForCache());
-  /** Epoch ms parsed from `datetime`; `NaN` when absent or invalid. */
+  #resync = new MorphRenderWatcher(() => {
+    if (this.#valuesDirty) {
+      this.#valuesDirty = false;
+      this.#resyncToValues();
+    } else if (!Number.isNaN(this.#targetMs)) {
+      this.#applyAndComputeDelay();
+    }
+  });
+  #valuesDirty = false;
   #targetMs = Number.NaN;
-  /** The authored absolute text, restored when the threshold fallback kicks in. */
   #absoluteText = "";
   connect() {
-    this.#resync.activate();
-    this.#beforeCache.activate();
+    this.#valuesDirty = false;
+    this.#resync.observe(this.element);
     if (this.element.getAttribute("data-state") !== "relative") {
       this.#absoluteText = (this.element.textContent ?? "").trim();
+    } else {
+      const recorded = this.#recordedText();
+      if (recorded !== null) this.#absoluteText = recorded;
     }
     this.#targetMs = Date.parse(this.element.getAttribute("datetime") ?? "");
     if (Number.isNaN(this.#targetMs)) return;
     this.#schedule();
   }
   disconnect() {
-    this.#resync.cancel();
-    this.#beforeCache.deactivate();
+    this.#resync.disconnect();
     this.#timers.clearAll();
   }
-  /** Repaints when application code (or a Turbo morph) changes `locale` at runtime. */
+  get #textRecord() {
+    return `data-${this.identifier}-${TEXT_RECORD}`;
+  }
+  #recordedText() {
+    try {
+      const parsed = JSON.parse(this.element.getAttribute(this.#textRecord) ?? "null");
+      return typeof parsed === "string" ? parsed : null;
+    } catch {
+      return null;
+    }
+  }
   localeValueChanged() {
+    this.#valuesDirty = true;
     this.#resync.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `threshold` at runtime. */
   thresholdValueChanged() {
+    this.#valuesDirty = true;
     this.#resync.schedule();
   }
-  /** Repaints when application code (or a Turbo morph) changes `tickInterval` at runtime. */
   tickIntervalValueChanged() {
+    this.#valuesDirty = true;
     this.#resync.schedule();
   }
-  /**
-   * Renders against the current Values and re-arms the poll from now.
-   *
-   * Render only: it emits no event, and clearing first keeps the single self-arming
-   * timer single — scheduling on top of a pending one would double the poll rate for
-   * the rest of the session. A stamp whose `datetime` never parsed has nothing to
-   * render, and one that already reached its terminal fallback simply renders it
-   * again and stops.
-   */
   #resyncToValues() {
     if (Number.isNaN(this.#targetMs)) return;
     this.#timers.clearAll();
     this.#schedule();
   }
-  /**
-   * Restores the authored absolute text and the pre-render state for the snapshot
-   * Turbo is about to take, leaving the live page's poll timer alone.
-   *
-   * With no authored text held there is nothing to restore, and `data-state` has to
-   * stay as it is: that marker is what tells the next `connect()` the visible text is
-   * a rendered relative form rather than an absolute fallback to hold on to.
-   */
-  #rewindForCache() {
-    if (!this.#absoluteText) return;
-    this.element.textContent = this.#absoluteText;
-    this.element.removeAttribute("data-state");
-  }
-  /** Renders the current representation and reschedules unless polling can stop. */
   #schedule() {
     const nextDelay = this.#applyAndComputeDelay();
     if (nextDelay !== null) {
       this.#timers.set(() => this.#schedule(), nextDelay);
     }
   }
-  /**
-   * Updates the visible text and returns the next poll delay (ms), or `null` when
-   * polling can stop: a *past* timestamp that fell back to the absolute text can
-   * never leave it again, and a locale the runtime rejects has nothing to render
-   * until that value is corrected.
-   *
-   * @stimeoRenderRoot
-   */
   #applyAndComputeDelay() {
     const deltaMs = this.#targetMs - Date.now();
     const absSeconds = Math.abs(deltaMs) / 1e3;
     const scale = UNITS.find((u) => absSeconds < u.limit) ?? YEAR_SCALE;
     const unitFloor = scale.unit === "second" || scale.unit === "minute" ? 6e4 : scale.ms;
-    const nextDelay = Math.max(this.tickIntervalValue, Math.min(unitFloor, 864e5));
-    if (this.thresholdValue > 0 && absSeconds >= this.thresholdValue && this.#absoluteText) {
+    const nextDelay = Math.max(this.#safeTickInterval, Math.min(unitFloor, 864e5));
+    if (this.#safeThreshold > 0 && absSeconds >= this.#safeThreshold && this.#absoluteText) {
       this.element.textContent = this.#absoluteText;
       this.element.setAttribute("data-state", "absolute");
+      this.element.removeAttribute(this.#textRecord);
       if (deltaMs <= 0) return null;
-      return Math.min(nextDelay, deltaMs - this.thresholdValue * 1e3 + 1);
+      return Math.max(1, Math.min(nextDelay, deltaMs - this.#safeThreshold * 1e3 + 1));
     }
     const formatter = this.#formatter;
     if (formatter === null) return null;
     const value = Math.round(deltaMs / scale.ms);
     this.element.textContent = formatter.format(value, scale.unit);
     this.element.setAttribute("data-state", "relative");
+    const record = JSON.stringify(this.#absoluteText);
+    if (this.element.getAttribute(this.#textRecord) !== record) {
+      this.element.setAttribute(this.#textRecord, record);
+    }
     return nextDelay;
   }
-  /**
-   * A `RelativeTimeFormat` for the resolved locale (`numeric: "auto"`), or `null`
-   * when the runtime rejects that locale.
-   */
   get #formatter() {
     return intlFormatter(
       Intl.RelativeTimeFormat,
@@ -276,8 +294,25 @@ var RelativeTimeController = class extends Controller {
       RELATIVE_OPTIONS
     );
   }
+  get #safeThreshold() {
+    return this.#numbers.read(
+      this,
+      "threshold",
+      this.thresholdValue,
+      _RelativeTimeController.values.threshold.default,
+      _RelativeTimeController.valueConstraints.threshold
+    );
+  }
+  get #safeTickInterval() {
+    return this.#numbers.read(
+      this,
+      "tickInterval",
+      this.tickIntervalValue,
+      _RelativeTimeController.values.tickInterval.default,
+      _RelativeTimeController.valueConstraints.tickInterval
+    );
+  }
 };
 
 export { RelativeTimeController };
-//# sourceMappingURL=relative_time_controller.js.map
 //# sourceMappingURL=relative_time_controller.js.map

data/dist/controllers/{reset_before_cache_controller.js → reset_on_restore_controller.js}

@@ -1,8 +1,5 @@
 import { Controller } from '@hotwired/stimulus';
 
-// src/controllers/reset_before_cache_controller.ts
-
-// src/utils/declared_value.ts
 function parseDeclared(raw, parse, fallback) {
   try {
     return parse(raw);
@@ -22,7 +19,94 @@ function validSelector(element, raw, fallback) {
   );
 }
 
-// src/controllers/reset_before_cache_controller.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;
+  constructor(run) {
+    this.#run = run;
+  }
+  activate() {
+    this.#active = true;
+  }
+  cancel() {
+    this.#active = false;
+    this.#queued = false;
+    this.#generation += 1;
+  }
+  schedule() {
+    if (!this.#active || this.#queued) return;
+    this.#queued = true;
+    const generation = this.#generation;
+    queueMicrotask(() => {
+      if (generation !== this.#generation || !this.#queued || !this.#active) return;
+      this.#queued = false;
+      this.#run();
+    });
+  }
+};
+
+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 LivedMark = class {
+  #name;
+  #lived = false;
+  #element = null;
+  #morph = new MorphRenderWatcher(() => this.#write());
+  constructor(identifier) {
+    this.#name = `data-${identifier}-lived`;
+  }
+  connect(element) {
+    const connection = this.#lived ? "reconnect" : element.hasAttribute(this.#name) ? "restored" : "fresh";
+    this.#lived = true;
+    this.#element = element;
+    this.#write();
+    this.#morph.observe(element);
+    return connection;
+  }
+  disconnect() {
+    this.#morph.disconnect();
+  }
+  #write() {
+    this.#element?.setAttribute(this.#name, "");
+  }
+};
+
 var STATELESS_INPUT_TYPES = /* @__PURE__ */ new Set(["hidden", "submit", "reset", "button", "image"]);
 function restoreField(element) {
   if (element instanceof HTMLTextAreaElement) {
@@ -43,48 +127,25 @@ function restoreField(element) {
     }
   }
 }
-var ResetBeforeCacheController = class extends Controller {
+var ResetOnRestoreController = class extends Controller {
   static values = {
-    scope: { type: String, default: "" },
-    dispatchReset: { type: Boolean, default: true }
+    scope: { type: String, default: "" }
   };
   static actions = ["reset"];
-  static events = ["reset", "request"];
-  /** The `scope` declaration after validation; empty when it cannot be parsed. */
+  static events = ["reset"];
   #scopeSelector = "";
-  /** Runs the reset just before Turbo caches the snapshot. */
-  #onBeforeCache = () => this.reset();
-  /**
-   * Validates the scope declaration once, keeping only a selector the engine can
-   * read.
-   *
-   * A selector reads back as an ordinary string, so a malformed one survives
-   * until it is handed to the DOM — and this part runs from a single listener
-   * whose whole job is to keep a cached page from freezing. Falling back to the
-   * default keeps that job running with a visible, findable result instead of
-   * silently taking the sweep down.
-   */
+  #lived = new LivedMark(this.identifier);
   scopeValueChanged() {
     this.#scopeSelector = validSelector(this.element, this.scopeValue, "");
   }
   connect() {
-    document.addEventListener("turbo:before-cache", this.#onBeforeCache);
+    if (this.#lived.connect(this.element) === "restored") this.reset();
   }
   disconnect() {
-    document.removeEventListener("turbo:before-cache", this.#onBeforeCache);
-  }
-  /**
-   * Resets transient UI within scope to its initial state. Asks controllers to
-   * close (via `request`) first, then applies the declarative `data-reset-*` cleanup,
-   * and finally emits `reset`. Safe to call any number of times (idempotent).
-   *
-   * `dispatchReset` decides only whether the `request` ask goes out; the cleanup
-   * and the closing `reset` run either way. Both the listener and this action
-   * reach the same sweep, so `reset` is emitted for a manual call too.
-   */
+    this.#lived.disconnect();
+  }
   reset() {
     const root = this.#scopeRoot();
-    if (this.dispatchResetValue) this.dispatch("request");
     for (const element of root.querySelectorAll("[data-reset-attr]")) {
       for (const name of (element.getAttribute("data-reset-attr") ?? "").split(/\s+/)) {
         if (name) element.removeAttribute(name);
@@ -109,13 +170,11 @@ var ResetBeforeCacheController = class extends Controller {
     }
     this.dispatch("reset");
   }
-  /** The scan root: a `scope` descendant when set, else the controller element. */
   #scopeRoot() {
     if (!this.#scopeSelector) return this.element;
     return this.element.querySelector(this.#scopeSelector) ?? this.element;
   }
 };
 
-export { ResetBeforeCacheController };
-//# sourceMappingURL=reset_before_cache_controller.js.map
-//# sourceMappingURL=reset_before_cache_controller.js.map
+export { ResetOnRestoreController };
+//# sourceMappingURL=reset_on_restore_controller.js.map