attaform 0.20.2 → 0.21.1

package/dist/shared/{attaform.z5j3LwJz.cjs → attaform.D32WwKk6.cjs}

@@ -2,7 +2,7 @@
 
 const vue = require('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;
@@ -24,6 +24,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(
@@ -513,6 +518,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) {
@@ -538,21 +548,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 = vue.effectScope(true);
     scope.run(() => {
@@ -572,7 +586,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 = "";
     }
@@ -841,6 +855,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 = vue.effectScope(true);
+  scope.run(() => {
+    vue.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");
@@ -875,6 +919,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);
@@ -883,26 +937,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__) {
@@ -923,23 +1019,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);
@@ -952,6 +1062,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);
@@ -964,6 +1084,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);
@@ -1004,7 +1134,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) {
@@ -1014,6 +1144,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;
@@ -1061,7 +1198,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);
@@ -1121,6 +1258,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);
@@ -1150,6 +1296,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);
@@ -1192,7 +1343,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;
       }
@@ -1201,7 +1352,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`
@@ -1247,11 +1403,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;
@@ -1270,6 +1433,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
@@ -1295,6 +1462,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);
@@ -1311,7 +1483,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;
       }
@@ -1322,7 +1494,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);
@@ -1465,6 +1643,7 @@ const vRegisterDynamic = {
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
     teardownAria(el);
+    teardownValueSync(el);
     if (isRegisterValue(value)) {
       value.persistOptIns.removeAllFor(getOrAssignElementId(el));
       value.unmarkNoSync?.();
@@ -1473,6 +1652,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
@@ -1518,7 +1698,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.cjs');
@@ -1687,7 +1867,8 @@ exports.kFormInstanceId = kFormInstanceId;
 exports.parseDottedPath = parseDottedPath;
 exports.pathKeyToDotted = pathKeyToDotted;
 exports.segmentsForPathKey = segmentsForPathKey;
+exports.toError = toError;
 exports.useRegister = useRegister;
 exports.useRegistry = useRegistry;
 exports.vRegister = vRegister;
-//# sourceMappingURL=attaform.z5j3LwJz.cjs.map
+//# sourceMappingURL=attaform.D32WwKk6.cjs.map