stimeo-ui 0.17.0 → 0.18.0

data/dist/controllers/input_mask_controller.js

@@ -6,63 +6,182 @@ var COMPOSITION_INPUT_TYPES = /* @__PURE__ */ new Set([
   "deleteCompositionText",
   "deleteByComposition"
 ]);
+function isCompositionInputType(inputType) {
+  return inputType !== void 0 && COMPOSITION_INPUT_TYPES.has(inputType);
+}
+var BEFORE_MORPH_ATTRIBUTE = "turbo:before-morph-attribute";
+var textOf = (element) => element.value;
+var holdsFocus = (element) => element instanceof Node && element.getRootNode().activeElement === element;
 var CompositionTracker = class {
   #observedTargets = /* @__PURE__ */ new Set();
-  #activeTargets = /* @__PURE__ */ new Set();
+  #composition = null;
   #onStart;
   #onEnd;
+  #onAbandon;
   #confirmedTarget = null;
+  #keyComposing = false;
+  #connected = false;
+  #abandoned = null;
   constructor(options = {}) {
     this.#onStart = options.onStart;
     this.#onEnd = options.onEnd;
+    this.#onAbandon = options.onAbandon;
   }
   observe(target) {
+    this.#connected = true;
     if (this.#observedTargets.has(target)) return;
     target.addEventListener("compositionstart", this.#handleStart);
     target.addEventListener("compositionend", this.#handleEnd);
-    target.addEventListener("keydown", this.#handleKeydown);
+    target.addEventListener("keydown", this.#handleKeydown, true);
+    target.addEventListener("beforeinput", this.#handleBeforeInput, true);
+    target.addEventListener("input", this.#handleInput, true);
+    target.addEventListener("blur", this.#handleBlur, true);
+    target.addEventListener(BEFORE_MORPH_ATTRIBUTE, this.#handleBeforeMorphAttribute);
     this.#observedTargets.add(target);
   }
   unobserve(target) {
     if (!this.#observedTargets.delete(target)) return;
-    target.removeEventListener("compositionstart", this.#handleStart);
-    target.removeEventListener("compositionend", this.#handleEnd);
-    target.removeEventListener("keydown", this.#handleKeydown);
-    this.#activeTargets.delete(target);
+    this.#release(target);
+    if (this.#composition?.target === target) this.#letGo();
     if (this.#confirmedTarget === target) this.#confirmedTarget = null;
   }
   disconnect() {
-    for (const target of this.#observedTargets) {
-      target.removeEventListener("compositionstart", this.#handleStart);
-      target.removeEventListener("compositionend", this.#handleEnd);
-      target.removeEventListener("keydown", this.#handleKeydown);
-    }
+    this.#connected = false;
+    for (const target of this.#observedTargets) this.#release(target);
     this.#observedTargets.clear();
-    this.#activeTargets.clear();
+    this.#letGo();
     this.#confirmedTarget = null;
+    this.#keyComposing = false;
+    this.#abandoned = null;
   }
   isComposing(event) {
-    return this.#activeTargets.size > 0 || event?.isComposing === true;
+    this.#settle();
+    return event?.isComposing === true || this.#composition !== null;
+  }
+  composingElement() {
+    this.#settle();
+    return this.#composition?.element ?? null;
+  }
+  owns(event) {
+    const element = this.composingElement();
+    return event.isComposing === true || element !== null && element === event.target;
   }
   consumesConfirmedInput(event) {
     const confirmed = this.#confirmedTarget;
     this.#confirmedTarget = null;
     if (confirmed === null || confirmed !== event.target) return false;
     const inputType = event.inputType;
-    return !inputType || COMPOSITION_INPUT_TYPES.has(inputType);
+    return !inputType || isCompositionInputType(inputType);
+  }
+  #release(target) {
+    target.removeEventListener("compositionstart", this.#handleStart);
+    target.removeEventListener("compositionend", this.#handleEnd);
+    target.removeEventListener("keydown", this.#handleKeydown, true);
+    target.removeEventListener("beforeinput", this.#handleBeforeInput, true);
+    target.removeEventListener("input", this.#handleInput, true);
+    target.removeEventListener("blur", this.#handleBlur, true);
+    target.removeEventListener(BEFORE_MORPH_ATTRIBUTE, this.#handleBeforeMorphAttribute);
+  }
+  #letGo() {
+    const composition = this.#composition;
+    if (composition === null) return;
+    if (!holdsFocus(composition.element)) {
+      this.#composition = null;
+      return;
+    }
+    queueMicrotask(() => {
+      if (this.#composition !== composition || this.#observedTargets.has(composition.target)) {
+        return;
+      }
+      this.#composition = null;
+      if (!this.#connected) return;
+      this.#abandoned = { element: composition.element, inPlace: true };
+      this.#runAbandon();
+    });
+  }
+  #settle() {
+    const composition = this.#composition;
+    if (composition === null) return;
+    const { target, element, text } = composition;
+    if (target instanceof Node && element instanceof Node && !target.contains(element)) {
+      this.#composition = null;
+    } else if (textOf(element) !== text) {
+      this.#abandon(false);
+    }
+  }
+  #abandon(inPlace) {
+    this.#owe(inPlace);
+    this.#composition = null;
+    queueMicrotask(this.#runAbandon);
+  }
+  #owe(inPlace) {
+    const composition = this.#composition;
+    if (composition !== null) this.#abandoned = { element: composition.element, inPlace };
   }
+  #runAbandon = () => {
+    const abandoned = this.#abandoned;
+    if (abandoned === null) return;
+    this.#abandoned = null;
+    this.#onAbandon?.(abandoned.element, abandoned.inPlace);
+  };
   #handleStart = (event) => {
     this.#confirmedTarget = null;
-    if (event.currentTarget) this.#activeTargets.add(event.currentTarget);
+    this.#settle();
+    this.#owe(true);
+    const target = event.currentTarget;
+    const element = event.target;
+    this.#composition = { target, element, text: textOf(element) };
+    this.#runAbandon();
     this.#onStart?.(event);
   };
   #handleEnd = (event) => {
-    if (event.currentTarget) this.#activeTargets.delete(event.currentTarget);
+    this.#runAbandon();
+    if (this.#composition?.target === event.currentTarget) this.#composition = null;
     this.#confirmedTarget = event.target;
     this.#onEnd?.(event);
   };
-  #handleKeydown = () => {
+  #handleKeydown = (event) => {
+    this.#settle();
+    this.#runAbandon();
     this.#confirmedTarget = null;
+    this.#keyComposing = event.isComposing === true;
+  };
+  #handleBeforeInput = (event) => {
+    const keyComposing = this.#keyComposing;
+    this.#keyComposing = false;
+    this.#settle();
+    const { isComposing, inputType } = event;
+    if (this.#composition !== null && !keyComposing && !isComposing && inputType && !isCompositionInputType(inputType)) {
+      this.#abandon(true);
+    }
+    this.#runAbandon();
+  };
+  #handleInput = (event) => {
+    const composition = this.#composition;
+    const { isTrusted, isComposing, inputType } = event;
+    if (composition !== null && event.target === composition.element && (isTrusted || isComposing || isCompositionInputType(inputType))) {
+      composition.text = textOf(composition.element);
+    } else {
+      this.#settle();
+    }
+    this.#runAbandon();
+  };
+  #handleBlur = (event) => {
+    this.#settle();
+    this.#runAbandon();
+    const composition = this.#composition;
+    if (composition === null || composition.target === composition.element) return;
+    const { element } = composition;
+    if (!(element instanceof Node) || event.target !== element) return;
+    const root = element.getRootNode();
+    if (root.activeElement !== element) this.#composition = null;
+  };
+  #handleBeforeMorphAttribute = (event) => {
+    this.#settle();
+    const composition = this.#composition;
+    if (composition?.target !== event.currentTarget || event.target !== composition.element) return;
+    const detail = event.detail;
+    if (detail?.attributeName === "value") event.preventDefault();
   };
 };
 
@@ -89,6 +208,43 @@ function parseJsonObject(raw) {
   return parsed;
 }
 
+var DetachGate = class _DetachGate {
+  #pending = false;
+  get pending() {
+    return this.#pending;
+  }
+  static isDetached(host) {
+    return !host.element.isConnected || !_DetachGate.#listed(host);
+  }
+  disconnected(host, teardown) {
+    const carried = _DetachGate.#carried(host);
+    if (!carried && _DetachGate.isDetached(host)) {
+      this.#pending = false;
+      teardown();
+      return;
+    }
+    this.#pending = true;
+    const probe = () => {
+      if (!this.#pending) return;
+      this.#pending = false;
+      teardown();
+    };
+    if (carried) setTimeout(probe, 0);
+    else queueMicrotask(probe);
+  }
+  static #carried(host) {
+    const element = host.element;
+    return !element.isConnected && element.closest("[data-turbo-permanent]") !== null && _DetachGate.#listed(host);
+  }
+  static #listed(host) {
+    const tokens = (host.element.getAttribute("data-controller") ?? "").split(/\s+/);
+    return tokens.includes(host.identifier);
+  }
+  cancel() {
+    this.#pending = false;
+  }
+};
+
 function inheritsFieldsetDisabled(control) {
   let fieldset = control.closest("fieldset[disabled]");
   while (fieldset) {
@@ -99,6 +255,120 @@ function inheritsFieldsetDisabled(control) {
   return false;
 }
 
+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 PREFIX = "__stimeo_raw_v1_";
+var documents = sharedRegistry(
+  "stimeo-ui.form-data-projection.registry.v1",
+  () => /* @__PURE__ */ new WeakMap()
+);
+function decodedName(key) {
+  if (!key.startsWith(PREFIX)) return null;
+  const separator = PREFIX.length + 32;
+  if (key[separator] !== ":") return null;
+  try {
+    const name = JSON.parse(key.slice(separator + 1));
+    return typeof name === "string" ? name : null;
+  } catch {
+    return null;
+  }
+}
+function projectedFieldName(name) {
+  return decodedName(name) ?? name;
+}
+function forDocument(document2) {
+  const existing = documents.get(document2);
+  if (existing) return existing;
+  const state = {
+    fields: /* @__PURE__ */ new Map(),
+    byField: /* @__PURE__ */ new WeakMap(),
+    handle: (event) => {
+      const data = event.formData;
+      if (!data) return;
+      const entries = [...data.entries()];
+      let changed = false;
+      const projected = entries.map(([key, value]) => {
+        const name = decodedName(key);
+        if (name === null) return [key, value];
+        changed = true;
+        const field = state.fields.get(key);
+        const live = field && field.field.name === key && field.field.form === event.target;
+        return [name, live ? field.project(value) : ""];
+      });
+      if (!changed) return;
+      for (const key of new Set(data.keys())) data.delete(key);
+      for (const [name, value] of projected) data.append(name, value);
+    }
+  };
+  documents.set(document2, state);
+  document2.addEventListener("formdata", state.handle, { capture: true });
+  return state;
+}
+function prepareFormDataProjection(form) {
+  const state = forDocument(form.ownerDocument);
+  form.addEventListener("formdata", state.handle, { capture: true });
+}
+var FormDataProjection = class {
+  #held = null;
+  hold(field, project) {
+    const held = this.#held;
+    if (held?.field === field && held.key === field.name && held.document === field.ownerDocument) {
+      if (field.form) prepareFormDataProjection(field.form);
+      return;
+    }
+    this.release();
+    const name = projectedFieldName(field.name);
+    if (name === "" || field.type === "hidden" && name.toLowerCase() === "_charset_") return;
+    const state = forDocument(field.ownerDocument);
+    if (field.form) prepareFormDataProjection(field.form);
+    const previous = state.byField.get(field);
+    if (previous) {
+      state.fields.delete(previous.key);
+      field.removeEventListener("turbo:morph-element", previous.restore);
+    }
+    const nonce = Array.from(
+      crypto.getRandomValues(new Uint8Array(16)),
+      (value) => value.toString(16).padStart(2, "0")
+    ).join("");
+    const key = `${PREFIX}${nonce}:${JSON.stringify(name)}`;
+    const projection = {
+      field,
+      key,
+      name,
+      project,
+      document: field.ownerDocument,
+      state,
+      restore: () => {
+        if (field.name === name) field.name = key;
+      }
+    };
+    state.fields.set(key, projection);
+    state.byField.set(field, projection);
+    this.#held = projection;
+    field.name = key;
+    field.addEventListener("turbo:morph-element", projection.restore);
+  }
+  release() {
+    const held = this.#held;
+    this.#held = null;
+    if (held === null) return;
+    held.field.removeEventListener("turbo:morph-element", held.restore);
+    const state = held.state;
+    if (state.byField.get(held.field) !== held) return;
+    state.fields.delete(held.key);
+    state.byField.delete(held.field);
+    if (held.field.name === held.key) held.field.name = held.name;
+  }
+};
+
 var FULL_WIDTH_SHIFT = 65248;
 function halfWidthChar(char) {
   if (char >= "\uFF01" && char <= "\uFF5E") {
@@ -134,6 +404,9 @@ var MicrotaskCoalescer = class {
     this.#queued = false;
     this.#generation += 1;
   }
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;
@@ -164,6 +437,9 @@ var MorphRenderWatcher = class {
   schedule() {
     this.#pass.schedule();
   }
+  get pending() {
+    return this.#pass.pending;
+  }
   disconnect() {
     this.#listeners.dispose();
     this.#pass.cancel();
@@ -171,12 +447,53 @@ var MorphRenderWatcher = class {
   }
 };
 
+var TimerRegistry = class {
+  ids = /* @__PURE__ */ new Set();
+  clear(id) {
+    if (this.ids.delete(id)) {
+      this.cancel(id);
+    }
+  }
+  clearAll() {
+    for (const id of this.ids) {
+      this.cancel(id);
+    }
+    this.ids.clear();
+  }
+  get size() {
+    return this.ids.size;
+  }
+};
+var SafeTimeout = class extends TimerRegistry {
+  set(callback, delay) {
+    const id = this.schedule(() => {
+      this.ids.delete(id);
+      callback();
+    }, delay);
+    this.ids.add(id);
+    return id;
+  }
+  schedule(callback, delay) {
+    return window.setTimeout(callback, delay);
+  }
+  cancel(id) {
+    window.clearTimeout(id);
+  }
+};
+
+function prepareInputMaskForm(form) {
+  prepareFormDataProjection(form);
+}
 var DEFAULT_TOKENS = {
   "9": "\\d",
   a: "[A-Za-z]",
   "*": "[A-Za-z0-9]"
 };
 var UNMASK_ATTR = "unmask";
+var rawWriters = sharedRegistry(
+  "stimeo-ui.input-mask-raw-writer.registry.v1",
+  () => /* @__PURE__ */ new WeakMap()
+);
 function acceptedForm(regex, char) {
   if (regex.test(char)) return char;
   const half = halfWidthChar(char);
@@ -265,8 +582,14 @@ var InputMaskController = class extends Controller {
   static events = ["change", "reconcile"];
   #lastValue = null;
   #started = false;
+  #rawSink = null;
+  #rawValue = "";
+  #rawSourceForm = null;
+  #submission = new FormDataProjection();
   #tokens = compileTokens("");
   #textBeforeComposition = "";
+  #formatted = null;
+  #shown = { result: null, empty: true };
   #composition = new CompositionTracker({
     onStart: () => {
       this.#textBeforeComposition = this.element.value;
@@ -274,6 +597,9 @@ var InputMaskController = class extends Controller {
     onEnd: () => {
       const committedNothing = this.element.value === this.#textBeforeComposition;
       this.#reformat(committedNothing ? "reconcile" : "edit");
+    },
+    onAbandon: () => {
+      if (this.#formatted !== this.#declared) this.#reformat("reconcile");
     }
   });
   tokensValueChanged() {
@@ -285,34 +611,53 @@ var InputMaskController = class extends Controller {
   }
   unmaskToHiddenValueChanged() {
     if (!this.#started) return;
-    if (!this.unmaskToHiddenValue) {
-      const sink = this.#resolveSink();
-      if (sink) sink.value = "";
-    }
+    if (!this.unmaskToHiddenValue) this.#withdraw();
     this.#reformat("reconcile");
   }
+  #withdraw() {
+    if (this.#retractRaw() && this.#composition.isComposing()) this.#formatted = null;
+  }
   #morph = new MorphRenderWatcher(() => this.#reformat("reconcile"));
+  #gate = new DetachGate();
+  #adoption = new SafeTimeout();
   connect() {
+    this.#gate.cancel();
     this.#morph.observe(this.element);
     this.#started = true;
     this.#composition.observe(this.element);
+    if (!this.unmaskToHiddenValue) this.#withdraw();
+    if (this.#composition.isComposing()) {
+      this.#reformat("reconcile");
+      return;
+    }
     this.#lastValue = this.element.value;
     this.#reformat("reconcile");
+    if (this.unmaskToHiddenValue && this.#rawSink === null) {
+      this.#adoption.set(() => this.#adoptSink(), 0);
+    }
   }
   disconnect() {
     this.#morph.disconnect();
     this.#started = false;
     this.#composition.disconnect();
+    this.#adoption.clearAll();
+    this.#gate.disconnected(this, () => this.#retractRaw());
   }
   format(event) {
     if (this.#composition.isComposing(event)) return;
     this.#reformat("edit", deletionOf(event));
   }
   #reformat(cause, deletion = null) {
-    if (this.#composition.isComposing()) return;
+    if (this.#composition.isComposing()) {
+      this.#showAgain();
+      return;
+    }
+    this.#formatted = this.#declared;
     const input = this.element;
     const raw = input.value;
     if (this.patternValue === "") {
+      this.#retractRaw();
+      this.#shown = { result: null, empty: raw.length === 0 };
       this.#flag("data-mask-complete", false);
       this.#flag("data-mask-empty", raw.length === 0);
       this.#lastValue = raw;
@@ -349,14 +694,56 @@ var InputMaskController = class extends Controller {
     if (cause === "edit") this.dispatch("change", { detail });
     else this.dispatch("reconcile", { detail });
   }
+  get #declared() {
+    return JSON.stringify([this.patternValue, this.tokensValue, this.unmaskToHiddenValue]);
+  }
   #publish(result, shown) {
+    this.#shown = { result, empty: shown.length === 0 };
     if (this.unmaskToHiddenValue) {
       const sink = this.#resolveSink();
-      if (sink) sink.value = result.unmasked;
+      if (sink !== this.#rawSink) this.#retractRaw();
+      if (sink) {
+        sink.value = result.unmasked;
+        rawWriters.set(sink, this);
+        this.#rawSink = sink;
+        this.#rawValue = result.unmasked;
+        this.#rawSourceForm = this.element.form;
+        this.#submission.hold(sink, (value) => this.#submittedValue(sink, value));
+      }
     }
     this.#flag("data-mask-complete", result.complete);
     this.#flag("data-mask-empty", shown.length === 0);
   }
+  #showAgain() {
+    const shown = this.#shown;
+    const sink = this.#rawSink;
+    if (shown.result !== null && this.unmaskToHiddenValue && sink !== null && rawWriters.get(sink) === this && this.#resolveSink() === sink) {
+      sink.value = shown.result.unmasked;
+    }
+    this.#flag("data-mask-complete", shown.result?.complete ?? false);
+    this.#flag("data-mask-empty", shown.empty);
+  }
+  #retractRaw() {
+    const sink = this.#rawSink;
+    this.#rawSink = null;
+    this.#submission.release();
+    if (sink === null || rawWriters.get(sink) !== this) return false;
+    rawWriters.delete(sink);
+    if (sink.value === this.#rawValue) sink.value = "";
+    return true;
+  }
+  #submittedValue(sink, value) {
+    if (rawWriters.get(sink) !== this || sink.value !== this.#rawValue || value !== this.#rawValue)
+      return value;
+    const source = this.element;
+    const listed = (source.getAttribute("data-controller") ?? "").split(/\s+/).includes(this.identifier);
+    const associated = source.form === null ? this.#rawSourceForm === null : source.form === sink.form;
+    const eligible = source.isConnected && this.application.element.contains(source) && listed && this.unmaskToHiddenValue && associated;
+    return eligible ? value : "";
+  }
+  #adoptSink() {
+    if (this.#resolveSink() !== null) this.#reformat("reconcile");
+  }
   #significantBefore(prefix) {
     return applyMask(prefix, this.patternValue, this.#tokens).unmasked.length;
   }
@@ -413,5 +800,5 @@ var InputMaskController = class extends Controller {
   }
 };
 
-export { InputMaskController, applyMask };
+export { InputMaskController, applyMask, prepareInputMaskForm };
 //# sourceMappingURL=input_mask_controller.js.map

data/dist/controllers/intersection_controller.js

@@ -114,6 +114,9 @@ var MicrotaskCoalescer = class {
     this.#queued = false;
     this.#generation += 1;
   }
+  get pending() {
+    return this.#queued;
+  }
   schedule() {
     if (!this.#active || this.#queued) return;
     this.#queued = true;

data/dist/controllers/lazy_frame_controller.js

@@ -81,6 +81,17 @@ var IntersectionWatcher = class {
   }
 };
 
+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 LazyFrameController = class extends Controller {
   static values = {
     url: { type: String, default: "" },
@@ -93,6 +104,7 @@ var LazyFrameController = class extends Controller {
   #loaded = false;
   #inside = null;
   #onFocus = () => this.#load();
+  #focusListeners = new ListenerSet();
   urlValueChanged() {
     if (!this.#connected || this.#loaded) return;
     if (this.urlValue) this.#arm();
@@ -123,7 +135,7 @@ var LazyFrameController = class extends Controller {
   }
   #arm() {
     if (!this.urlValue) return;
-    if (!this.#loaded) this.element.addEventListener("focusin", this.#onFocus);
+    if (!this.#loaded) this.#focusListeners.add(this.element, "focusin", this.#onFocus);
     this.#observe();
   }
   #observe() {
@@ -154,7 +166,7 @@ var LazyFrameController = class extends Controller {
     this.element.setAttribute("src", this.urlValue);
     this.element.setAttribute("data-lazy-loaded", "true");
     this.dispatch("load", { detail: { url: this.urlValue } });
-    this.element.removeEventListener("focusin", this.#onFocus);
+    this.#focusListeners.dispose();
     if (this.onceValue) this.#watcher.stop();
   }
   #reload() {
@@ -171,7 +183,7 @@ var LazyFrameController = class extends Controller {
   }
   #stopObserving() {
     this.#watcher.stop();
-    this.element.removeEventListener("focusin", this.#onFocus);
+    this.#focusListeners.dispose();
   }
 };