attaform 0.20.2 → 0.21.1

package/dist/shared/{attaform.QG5TG8lB.mjs → attaform.pmtahXKy.mjs}

@@ -1,6 +1,6 @@
 import { shallowReactive, getCurrentInstance, inject, shallowRef, onBeforeMount, onBeforeUpdate, onMounted, effectScope, watch, warn, nextTick, isRef } from 'vue';
 
-const __DEV__ = typeof process !== "undefined" && process.env["NODE_ENV"] !== "production";
+const __DEV__ = (typeof process !== "undefined" ? process.env.NODE_ENV : "production") !== "production";
 
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
@@ -22,6 +22,11 @@ class InvalidUseFormConfigError extends AttaformError {
 }
 class SubmitErrorHandlerError extends AttaformError {
 }
+function toError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Submit callback threw a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
 class RegistryNotInstalledError extends AttaformError {
   constructor() {
     super(
@@ -511,6 +516,11 @@ function isBlankFileValue(value) {
     return true;
   return false;
 }
+function isMultipleInput(el, vnode) {
+  if (el.multiple) return true;
+  const authored = vnode.props?.["multiple"];
+  return authored === true || authored === "";
+}
 function readFilesFromInput(el) {
   const files = el.files;
   if (el.multiple) {
@@ -536,21 +546,25 @@ function maybeWarnPersistedFile(value) {
 }
 const fileScopeKey = Symbol.for("attaform:file-scope");
 const vRegisterFile = {
-  created(el, { value }) {
+  created(el, { value }, vnode) {
     if (!isRegisterValue(value)) return;
     const input = el;
     value.registerElement(input);
+    setAssignFunction(input, vnode, value);
     maybeWarnPersistedFile(value);
     const currentRaw = value.innerRef.value;
     if (isBlankFileValue(currentRaw)) {
-      const blankShape = input.multiple ? [] : null;
+      const blankShape = isMultipleInput(input, vnode) ? [] : null;
       value.setValueWithInternalPath(blankShape, { blank: true });
     }
     addTrackedListener(input, "change", () => {
       noteInteraction(value);
       const next = readFilesFromInput(input);
-      const blank = isBlankFileValue(next);
-      value.setValueWithInternalPath(next, blank ? { blank: true } : void 0);
+      if (isBlankFileValue(next)) {
+        value.setValueWithInternalPath(next, { blank: true });
+        return;
+      }
+      fireAssigner(input, value, next);
     });
     const scope = effectScope(true);
     scope.run(() => {
@@ -570,7 +584,7 @@ const vRegisterFile = {
     if (!isRegisterValue(value)) return;
     const input = el;
     const currentRaw = value.innerRef.value;
-    if (isBlankFileValue(currentRaw)) {
+    if (isBlankFileValue(currentRaw) && !isTransforming(value)) {
       value.setValueWithInternalPath(currentRaw, { blank: true });
       if (input.value !== "") input.value = "";
     }
@@ -839,6 +853,36 @@ function syncElementRegistration(el, value, oldValue) {
   }
 }
 
+const valueSyncScopeKey = Symbol.for("attaform:value-sync-scope");
+function isElementFocused(el) {
+  const rootNode = el.getRootNode();
+  const activeElement = rootNode instanceof Document || rootNode instanceof ShadowRoot ? rootNode.activeElement : null;
+  return activeElement === el;
+}
+function setupValueSync(el, source, apply, options = {}) {
+  const skipWhileFocused = options.skipWhileFocused === true;
+  const scope = effectScope(true);
+  scope.run(() => {
+    watch(
+      source,
+      () => {
+        if (el.composing === true) return;
+        if (skipWhileFocused && isElementFocused(el)) return;
+        apply();
+      },
+      { flush: "post" }
+    );
+  });
+  el[valueSyncScopeKey] = () => scope.stop();
+}
+function teardownValueSync(el) {
+  const carrier = el;
+  const stop = carrier[valueSyncScopeKey];
+  if (stop === void 0) return;
+  stop();
+  delete carrier[valueSyncScopeKey];
+}
+
 const INTERACTIVE_TAG_NAMES = /* @__PURE__ */ new Set(["INPUT", "SELECT", "TEXTAREA"]);
 
 const assignKey = Symbol.for("attaform:assign-key");
@@ -873,6 +917,16 @@ function fireAssigner(el, registerValue, value) {
     return fn(value, void 0);
   }
   const r = runTransforms(value, registerValue);
+  if (r.kind === "async") {
+    kickoffAsyncTransform(
+      registerValue,
+      r.holder,
+      r.run,
+      (coerced2) => fn(coerced2, registerValue),
+      void 0
+    );
+    return true;
+  }
   if (!r.ok) return false;
   const coerced = applyCoerce(r.value, registerValue);
   return fn(coerced, registerValue);
@@ -881,26 +935,68 @@ function shouldBailListener(el) {
   if (INTERACTIVE_TAG_NAMES.has(el.tagName)) return false;
   return isDefaultAssigner(el[assignKey]);
 }
+function isThenable(x) {
+  return x !== null && (typeof x === "object" || typeof x === "function") && typeof x.then === "function";
+}
+function makeTransformContext() {
+  const holder = { controller: null, aborted: false };
+  const ctx = {
+    get signal() {
+      if (holder.controller === null) {
+        holder.controller = new AbortController();
+        if (holder.aborted) holder.controller.abort();
+      }
+      return holder.controller.signal;
+    }
+  };
+  return { ctx, holder };
+}
 function runTransforms(initial, registerValue) {
   const transforms = registerValue.transforms;
   if (transforms === void 0 || transforms.length === 0) {
-    return { ok: true, value: initial };
+    return { kind: "sync", ok: true, value: initial };
   }
+  const { ctx, holder } = makeTransformContext();
   let v = initial;
   for (let i = 0; i < transforms.length; i++) {
     const fn = transforms[i];
+    let out;
     try {
-      v = fn(v);
+      out = fn(v, ctx);
     } catch (err) {
       logTransformFailure(registerValue.path, i, fn, err);
-      return { ok: false };
+      return { kind: "sync", ok: false };
     }
-  }
-  if (v instanceof Promise) {
-    logTransformAsync(registerValue.path);
-    return { ok: false };
-  }
-  return { ok: true, value: v };
+    if (isThenable(out)) {
+      const rest = transforms.slice(i + 1);
+      const seed = out;
+      const run = () => rest.reduce(
+        (acc, next) => acc.then((value) => next(value, ctx)),
+        Promise.resolve(seed)
+      );
+      return { kind: "async", run, holder };
+    }
+    v = out;
+  }
+  return { kind: "sync", ok: true, value: v };
+}
+function kickoffAsyncTransform(rv, holder, run, commit, syncDom) {
+  const token = rv.beginTransform(holder);
+  void run().then(
+    (value) => {
+      const live = rv.isCurrentTransform(token);
+      rv.endTransform(token);
+      if (!live) return;
+      const coerced = applyCoerce(value, rv);
+      const wrote = commit(coerced);
+      if (wrote === false) rv.setTransformError(transformGateRejectedError(rv.path));
+      else syncDom?.();
+    },
+    (err) => {
+      if (rv.isCurrentTransform(token)) rv.setTransformError(toTransformError(err));
+      rv.endTransform(token);
+    }
+  );
 }
 function logTransformFailure(path, index, fn, err) {
   if (__DEV__) {
@@ -921,23 +1017,37 @@ function applyCoerce(value, registerValue) {
 function applyElementCoerce(value, registerValue) {
   return registerValue.coerceElement !== void 0 ? registerValue.coerceElement(value) : value;
 }
-function logTransformAsync(path) {
-  if (__DEV__) {
-    console.error(
-      `[attaform] transform pipeline for path '${path}' returned a Promise \u2014 transforms must be sync. Use async field validation for canonicalize-before-write patterns. Write aborted.`
-    );
-  } else {
-    console.error(
-      `[attaform] transform error \u2014 write aborted (set NODE_ENV=development for details).`
-    );
-  }
+function toTransformError(value) {
+  if (value instanceof Error) return value;
+  const message = typeof value === "string" && value.length > 0 ? value : `Transform rejected with a non-Error value (${typeof value})`;
+  return new Error(message, { cause: value });
+}
+function transformGateRejectedError(path) {
+  return new Error(
+    `[attaform] transform result for path '${path}' was rejected by the field's type gate (the resolved value did not fit the schema slot).`
+  );
+}
+function isTransforming(value) {
+  return isRegisterValue(value) && value.transforming;
 }
-const getModelAssigner = (vnode, registerValue) => {
+const getModelAssigner = (el, vnode, registerValue) => {
   const fn = vnode.props?.["onUpdate:registerValue"] ?? vnode.props?.["on:update:registerValue"];
   if (isArray(fn)) {
     const fnArr = fn.filter((x) => isFunction(x));
     const wrapped = (value) => {
       const r = runTransforms(value, registerValue);
+      if (r.kind === "async") {
+        kickoffAsyncTransform(
+          registerValue,
+          r.holder,
+          r.run,
+          (coerced2) => {
+            invokeArrayFns(fnArr, coerced2, registerValue);
+          },
+          void 0
+        );
+        return true;
+      }
       if (!r.ok) return false;
       const coerced = applyCoerce(r.value, registerValue);
       invokeArrayFns(fnArr, coerced, registerValue);
@@ -950,6 +1060,16 @@ const getModelAssigner = (vnode, registerValue) => {
     const handler = fn;
     const wrapped = (value) => {
       const r = runTransforms(value, registerValue);
+      if (r.kind === "async") {
+        kickoffAsyncTransform(
+          registerValue,
+          r.holder,
+          r.run,
+          (coerced2) => handler(coerced2, registerValue),
+          void 0
+        );
+        return true;
+      }
       if (!r.ok) return false;
       const coerced = applyCoerce(r.value, registerValue);
       return handler(coerced, registerValue);
@@ -962,6 +1082,16 @@ const getModelAssigner = (vnode, registerValue) => {
       return registerValue.setValueWithInternalPath(void 0);
     }
     const r = runTransforms(value, registerValue);
+    if (r.kind === "async") {
+      kickoffAsyncTransform(
+        registerValue,
+        r.holder,
+        r.run,
+        (coerced2) => registerValue.setValueWithInternalPath(coerced2),
+        el._syncFromStorage
+      );
+      return true;
+    }
     if (!r.ok) return false;
     const coerced = applyCoerce(r.value, registerValue);
     return registerValue.setValueWithInternalPath(coerced);
@@ -1002,7 +1132,7 @@ function setAssignFunction(el, vnode, value) {
     el[assignKey] = makeNoopAssigner();
     return;
   }
-  el[assignKey] = getModelAssigner(vnode, value);
+  el[assignKey] = getModelAssigner(el, vnode, value);
 }
 const vRegisterText = {
   created(el, { value, modifiers: { lazy, trim, number } }, vnode) {
@@ -1012,6 +1142,13 @@ const vRegisterText = {
       value.registerElement(el);
       setAssignFunction(el, vnode, value);
     }
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      const storage = value.innerRef.value;
+      const display = storage == null ? "" : String(storage);
+      if (el.value !== display) el.value = display;
+      if (liveCastToNumber()) writeLastTypedForm(value, null);
+    };
     addTrackedListener(el, lazy === true ? "change" : "input", (e) => {
       if (shouldBailListener(el)) return;
       const target = e.target;
@@ -1059,7 +1196,7 @@ const vRegisterText = {
       }
       const commit = domValue === "" && isRegisterValue(value) && value.acceptsUndefined ? void 0 : domValue;
       fireAssigner(el, value, commit);
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         const storage = value.innerRef.value;
         if (storage !== domValue) {
           const display = storage == null ? "" : String(storage);
@@ -1119,6 +1256,15 @@ const vRegisterText = {
   mounted(el, { value }) {
     if (!isRegisterValue(value)) return;
     el.value = value.displayValue.value;
+    setupValueSync(
+      el,
+      value.displayValue,
+      () => {
+        const next = value.displayValue.value;
+        if (el.value !== next) el.value = next;
+      },
+      { skipWhileFocused: true }
+    );
   },
   beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim } }, vnode) {
     setAssignFunction(el, vnode, value);
@@ -1148,6 +1294,11 @@ const vRegisterCheckbox = {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
     setAssignFunction(el, vnode, value);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      setChecked(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
@@ -1190,7 +1341,7 @@ const vRegisterCheckbox = {
       } else {
         fireAssigner(el, value, getCheckboxValue(el, checked));
       }
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         setChecked(el, value);
         el._lastAppliedModel = value.innerRef.value;
       }
@@ -1199,7 +1350,12 @@ const vRegisterCheckbox = {
   // set initial checked on mount to wait for true-value/false-value
   mounted(el, { value }) {
     setChecked(el, value);
-    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+    if (!isRegisterValue(value)) return;
+    el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      setChecked(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   // Skip the DOM sync when the model is identity-unchanged from the
   // last application. Pre-fix the scalar branch in `setChecked`
@@ -1245,11 +1401,18 @@ const vRegisterRadio = {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
     setAssignFunction(el, vnode, value);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      const currentModel = value.innerRef.value;
+      const target = looseEqual(currentModel, applyCoerce(getValue(el), value));
+      if (el.checked !== target) el.checked = target;
+      el._lastAppliedModel = currentModel;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
       fireAssigner(el, value, getValue(el));
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         const currentModel = value.innerRef.value;
         const target = looseEqual(currentModel, applyCoerce(getValue(el), value));
         if (el.checked !== target) el.checked = target;
@@ -1268,6 +1431,10 @@ const vRegisterRadio = {
     if (!isRegisterValue(value)) return;
     el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
     el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      el.checked = looseEqual(value.innerRef.value, applyCoerce(getValue(el), value));
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   // Skip the DOM sync when the model is identity-unchanged from the
   // last application. Pre-fix the guard read `value.innerRef.value
@@ -1293,6 +1460,11 @@ const vRegisterSelect = {
   created(el, { value, modifiers: { number } }, vnode) {
     if (!isRegisterValue(value)) return;
     value.registerElement(el);
+    el._syncFromStorage = () => {
+      if (!isRegisterValue(value)) return;
+      setSelected(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    };
     addTrackedListener(el, "change", () => {
       if (shouldBailListener(el)) return;
       noteInteraction(value);
@@ -1309,7 +1481,7 @@ const vRegisterSelect = {
           el._assigning = false;
         });
       }
-      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
+      if (isRegisterValue(value) && isDefaultAssigner(el[assignKey]) && !isTransforming(value)) {
         setSelected(el, value);
         el._lastAppliedModel = value.innerRef.value;
       }
@@ -1320,7 +1492,13 @@ const vRegisterSelect = {
   // <option>s.
   mounted(el, { value }) {
     setSelected(el, value);
-    if (isRegisterValue(value)) el._lastAppliedModel = value.innerRef.value;
+    if (!isRegisterValue(value)) return;
+    el._lastAppliedModel = value.innerRef.value;
+    setupValueSync(el, value.innerRef, () => {
+      if (el._assigning === true) return;
+      setSelected(el, value);
+      el._lastAppliedModel = value.innerRef.value;
+    });
   },
   beforeUpdate(el, binding, vnode) {
     setAssignFunction(el, vnode, binding.value);
@@ -1463,6 +1641,7 @@ const vRegisterDynamic = {
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
     teardownAria(el);
+    teardownValueSync(el);
     if (isRegisterValue(value)) {
       value.persistOptIns.removeAllFor(getOrAssignElementId(el));
       value.unmarkNoSync?.();
@@ -1471,6 +1650,7 @@ const vRegisterDynamic = {
     value.deregisterElement(el);
     delete el.composing;
     delete el._assigning;
+    delete el._syncFromStorage;
     delete el[assignKey];
   },
   // The lifecycle hooks above don't run on the server (Vue skips
@@ -1516,7 +1696,7 @@ function installAttaformOnApp(app, options, source) {
   const registry = createRegistry(options);
   attachRegistryToApp(app, registry);
   app.directive("register", vRegister);
-  if (options.devtools !== false && !registry.ssr) {
+  if (__DEV__ && options.devtools !== false && !registry.ssr) {
     void (async () => {
       try {
         const { setupAttaformDevtools } = await import('../chunks/devtools.mjs');
@@ -1647,5 +1827,5 @@ function isPathPrefix(prefix, path) {
   return true;
 }
 
-export { AnonPersistError as A, kFormInstanceId as B, parseDottedPath as C, DEFAULT_SENSITIVE_NAMES as D, pathKeyToDotted as E, FORM_ERRORS_PATH as F, segmentsForPathKey as G, useRegister as H, INTERACTIVE_TAG_NAMES as I, useRegistry as J, vRegister as K, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, __DEV__ as _, AttaformError as a, FORM_ERRORS_PATH_KEY as b, InvalidPathError as c, InvalidUseFormConfigError as d, ROOT_PATH_KEY as e, RegistryNotInstalledError as f, ReservedFormKeyError as g, allowSensitivePersist as h, assignKey as i, canonicalizePath as j, captureUserCallSite as k, coerceToPathKey as l, createAttaform as m, createIsSensitivePath as n, createPersistOptInRegistry as o, createRegistry as p, ensureAttaformInstalled as q, getOrAssignElementId as r, getRegistryFromApp as s, isPathPrefix as t, isRegisterValue as u, isSensitivePath as v, kAttaformAncestorWizard as w, kAttaformRegistry as x, kAttaformWizardActiveStepResolver as y, kFormContext as z };
-//# sourceMappingURL=attaform.QG5TG8lB.mjs.map
+export { AnonPersistError as A, kFormInstanceId as B, parseDottedPath as C, DEFAULT_SENSITIVE_NAMES as D, pathKeyToDotted as E, FORM_ERRORS_PATH as F, segmentsForPathKey as G, toError as H, INTERACTIVE_TAG_NAMES as I, useRegister as J, useRegistry as K, vRegister as L, OutsideSetupError as O, ROOT_PATH as R, SubmitErrorHandlerError as S, __DEV__ as _, AttaformError as a, FORM_ERRORS_PATH_KEY as b, InvalidPathError as c, InvalidUseFormConfigError as d, ROOT_PATH_KEY as e, RegistryNotInstalledError as f, ReservedFormKeyError as g, allowSensitivePersist as h, assignKey as i, canonicalizePath as j, captureUserCallSite as k, coerceToPathKey as l, createAttaform as m, createIsSensitivePath as n, createPersistOptInRegistry as o, createRegistry as p, ensureAttaformInstalled as q, getOrAssignElementId as r, getRegistryFromApp as s, isPathPrefix as t, isRegisterValue as u, isSensitivePath as v, kAttaformAncestorWizard as w, kAttaformRegistry as x, kAttaformWizardActiveStepResolver as y, kFormContext as z };
+//# sourceMappingURL=attaform.pmtahXKy.mjs.map