attaform 0.17.1 → 0.18.0

package/dist/shared/{attaform.CIEQgJnM.mjs → attaform.Xhg0AYNa.mjs}

@@ -1,4 +1,4 @@
-import { shallowReactive, getCurrentInstance, inject, shallowRef, onBeforeMount, onBeforeUpdate, onMounted, nextTick, warn, isRef } from 'vue';
+import { shallowReactive, getCurrentInstance, inject, shallowRef, onBeforeMount, onBeforeUpdate, onMounted, nextTick, warn, isRef, effectScope, watch } from 'vue';
 
 const __DEV__ = typeof process !== "undefined" && process.env["NODE_ENV"] !== "production";
 
@@ -76,43 +76,118 @@ function detectSSR(options = {}) {
 }
 
 const kAttaformRegistry = Symbol.for("attaform:registry");
+const kAttaformAncestorWizard = Symbol.for(
+  "attaform:ancestor-wizard"
+);
+const kAttaformWizardActiveStepResolver = Symbol.for(
+  "attaform:wizard-active-step-resolver"
+);
 const kFormContext = Symbol.for("attaform:form-context");
 const kFormInstanceId = Symbol.for("attaform:form-instance-id");
 function createRegistry(options = {}) {
   const ssr = detectSSR(options);
   const defaults = Object.freeze({ ...options.defaults ?? {} });
   const forms = shallowReactive(/* @__PURE__ */ new Map());
+  const wizards = shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = shallowReactive(/* @__PURE__ */ new Map());
   const consumers = /* @__PURE__ */ new Map();
   const evicting = /* @__PURE__ */ new Set();
+  const pendingEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingEviction(key) {
+    const pending = pendingEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingEvictions.delete(key);
+  }
   function trackConsumer(key) {
+    cancelPendingEviction(key);
     consumers.set(key, (consumers.get(key) ?? 0) + 1);
     let disposed = false;
     return () => {
       if (disposed) return;
       disposed = true;
       const remaining = (consumers.get(key) ?? 1) - 1;
-      if (remaining <= 0) {
+      if (remaining > 0) {
+        consumers.set(key, remaining);
+        return;
+      }
+      consumers.delete(key);
+      const token = { cancelled: false };
+      pendingEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingEvictions.get(key) !== token) return;
+        pendingEvictions.delete(key);
         const state = forms.get(key);
-        consumers.delete(key);
         forms.delete(key);
-        if (state !== void 0) {
-          evicting.add(state);
-          void state.awaitPendingWrites().catch(() => void 0).finally(() => {
-            evicting.delete(state);
-            state.dispose();
-          });
-        }
-      } else {
-        consumers.set(key, remaining);
+        if (state === void 0) return;
+        evicting.add(state);
+        void state.awaitPendingWrites().catch(() => void 0).finally(() => {
+          evicting.delete(state);
+          state.dispose();
+        });
+      });
+    };
+  }
+  const wizardConsumers = /* @__PURE__ */ new Map();
+  const pendingWizardEvictions = /* @__PURE__ */ new Map();
+  function cancelPendingWizardEviction(key) {
+    const pending = pendingWizardEvictions.get(key);
+    if (pending === void 0) return;
+    pending.cancelled = true;
+    pendingWizardEvictions.delete(key);
+  }
+  function trackWizardConsumer(key) {
+    cancelPendingWizardEviction(key);
+    wizardConsumers.set(key, (wizardConsumers.get(key) ?? 0) + 1);
+    let disposed = false;
+    return () => {
+      if (disposed) return;
+      disposed = true;
+      const remaining = (wizardConsumers.get(key) ?? 1) - 1;
+      if (remaining > 0) {
+        wizardConsumers.set(key, remaining);
+        return;
       }
+      wizardConsumers.delete(key);
+      const token = { cancelled: false };
+      pendingWizardEvictions.set(key, token);
+      queueMicrotask(() => {
+        if (token.cancelled) return;
+        if (pendingWizardEvictions.get(key) !== token) return;
+        pendingWizardEvictions.delete(key);
+        wizards.delete(key);
+      });
     };
   }
   async function shutdown() {
     const states = [...forms.values(), ...evicting];
     await Promise.allSettled(states.map((state) => state.awaitPendingWrites()));
   }
-  return { forms, pendingHydration, ssr, defaults, trackConsumer, shutdown };
+  const prefetchEnqueued = /* @__PURE__ */ new Set();
+  const prefetchSkipped = /* @__PURE__ */ new Set();
+  function enqueuePrefetch(key) {
+    prefetchEnqueued.add(key);
+  }
+  function skipPrefetch(key) {
+    prefetchSkipped.add(key);
+  }
+  function shouldPrefetch(key) {
+    return prefetchEnqueued.has(key) && !prefetchSkipped.has(key);
+  }
+  return {
+    forms,
+    wizards,
+    pendingHydration,
+    ssr,
+    defaults,
+    trackConsumer,
+    trackWizardConsumer,
+    enqueuePrefetch,
+    skipPrefetch,
+    shouldPrefetch,
+    shutdown
+  };
 }
 function useRegistry() {
   const instance = getCurrentInstance();
@@ -282,6 +357,17 @@ function useRegister() {
     if ("registerValue" in rawAttrs) {
       capturedRegisterValue.value = rawAttrs["registerValue"];
       delete rawAttrs["registerValue"];
+    } else {
+      const dirs = instance.vnode.dirs;
+      if (dirs !== null && dirs !== void 0) {
+        for (const dir of dirs) {
+          const marked = dir.dir?.[V_REGISTER_MARKER];
+          if (marked === true) {
+            capturedRegisterValue.value = dir.value;
+            break;
+          }
+        }
+      }
     }
     if ("value" in rawAttrs) delete rawAttrs["value"];
   };
@@ -632,6 +718,12 @@ const getModelAssigner = (el, vnode, registerValue) => {
     };
   }
   const defaultAssigner = (value) => {
+    if (value === void 0 && registerValue.acceptsUndefined) {
+      return registerValue.setValueWithInternalPath(
+        void 0,
+        computePersistMeta(el, registerValue)
+      );
+    }
     const r = runTransforms(value, registerValue);
     if (!r.ok) return false;
     const coerced = applyCoerce(r.value, registerValue);
@@ -640,9 +732,10 @@ const getModelAssigner = (el, vnode, registerValue) => {
   defaultAssigner[DEFAULT_ASSIGNER_TAG] = true;
   return defaultAssigner;
 };
-function syncPersistOptIn(el, value, oldValue) {
+function syncPersistOptIn(el, value, oldValue, vnodeType) {
   const wasOptedIn = isRegisterValue(oldValue) && oldValue.persist === true;
-  const wantsOptIn = isRegisterValue(value) && value.persist === true;
+  const isFileInput = el.tagName === "INPUT" && (vnodeType === "file" || el.type === "file");
+  const wantsOptIn = !isFileInput && isRegisterValue(value) && value.persist === true;
   if (!wasOptedIn && !wantsOptIn) return;
   const elementId = getOrAssignElementId(el);
   if (wasOptedIn) {
@@ -768,7 +861,13 @@ const vRegisterText = {
         }
         if (isRegisterValue(value)) writeLastTypedForm(value, typedString);
       }
-      el[assignKey]?.(domValue);
+      if (domValue === "" && isRegisterValue(value) && !value.acceptsString && !value.acceptsUndefined) {
+        writeLastTypedForm(value, null);
+        value.markBlank();
+        return;
+      }
+      const commit = domValue === "" && isRegisterValue(value) && value.acceptsUndefined ? void 0 : domValue;
+      el[assignKey]?.(commit);
       if (isRegisterValue(value) && isDefaultAssigner(el[assignKey])) {
         const storage = value.innerRef.value;
         if (storage !== domValue) {
@@ -1120,7 +1219,7 @@ const SUPPORTED_TAGS = /* @__PURE__ */ new Set(["INPUT", "TEXTAREA", "SELECT"]);
 const warnedUnsupportedElements = __DEV__ ? /* @__PURE__ */ new WeakSet() : null;
 const vRegisterDynamic = {
   created(el, binding, vnode) {
-    syncPersistOptIn(el, binding.value, void 0);
+    syncPersistOptIn(el, binding.value, void 0, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, void 0);
     callModelHook(el, binding, vnode, null, "created");
     if (__DEV__ && warnedUnsupportedElements !== null && !SUPPORTED_TAGS.has(el.tagName) && !warnedUnsupportedElements.has(el)) {
@@ -1142,7 +1241,7 @@ const vRegisterDynamic = {
     callModelHook(el, binding, vnode, null, "mounted");
   },
   beforeUpdate(el, binding, vnode, prevVNode) {
-    syncPersistOptIn(el, binding.value, binding.oldValue);
+    syncPersistOptIn(el, binding.value, binding.oldValue, vnode.props?.["type"]);
     syncMultiTabOptOut(binding.value, binding.oldValue);
     syncElementRegistration(el, binding.value, binding.oldValue);
     callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
@@ -1163,18 +1262,83 @@ const vRegisterDynamic = {
     delete el[assignKey];
   }
 };
-const vRegisterFileNoop = {
+function isBlankFileValue(value) {
+  if (value === null || value === void 0) return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  if (typeof FileList !== "undefined" && value instanceof FileList && value.length === 0)
+    return true;
+  return false;
+}
+function readFilesFromInput(el) {
+  const files = el.files;
+  if (el.multiple) {
+    return files === null ? [] : Array.from(files);
+  }
+  if (files === null || files.length === 0) return null;
+  return files.item(0);
+}
+const warnedPersistedFileForms = __DEV__ ? /* @__PURE__ */ new WeakMap() : null;
+function maybeWarnPersistedFile(value) {
+  if (!__DEV__ || warnedPersistedFileForms === null) return;
+  if (value.persist !== true) return;
+  let warnedPaths = warnedPersistedFileForms.get(value.persistOptIns);
+  if (warnedPaths === void 0) {
+    warnedPaths = /* @__PURE__ */ new Set();
+    warnedPersistedFileForms.set(value.persistOptIns, warnedPaths);
+  }
+  if (warnedPaths.has(value.path)) return;
+  warnedPaths.add(value.path);
+  warn(
+    `[attaform] register('${value.path}', { persist: true }) on <input type="file"> \u2014 files can't ride a refresh (browsers block programmatic writes to <input type="file">), so this path won't be saved. For long-lived flows, upload on selection and persist the resulting URL or ID in a sibling string field.`
+  );
+}
+const fileScopeKey = Symbol.for("attaform:file-scope");
+const vRegisterFile = {
   created(el, { value }) {
     if (!isRegisterValue(value)) return;
-    value.registerElement(el);
-    if (__DEV__) {
-      warn(
-        '[attaform] v-register on <input type="file"> is not supported. Handle uploads with a manual @change listener.'
+    const input = el;
+    value.registerElement(input);
+    maybeWarnPersistedFile(value);
+    const currentRaw = value.innerRef.value;
+    if (isBlankFileValue(currentRaw)) {
+      const blankShape = input.multiple ? [] : null;
+      value.setValueWithInternalPath(blankShape, { blank: true });
+    }
+    addEventListener(input, "change", () => {
+      const next = readFilesFromInput(input);
+      const blank = isBlankFileValue(next);
+      value.setValueWithInternalPath(next, blank ? { blank: true } : void 0);
+    });
+    const scope = effectScope(true);
+    scope.run(() => {
+      watch(
+        value.innerRef,
+        (next) => {
+          if (!isBlankFileValue(next)) return;
+          value.setValueWithInternalPath(next, { blank: true });
+          if (input.value !== "") input.value = "";
+        },
+        { flush: "post" }
       );
+    });
+    input[fileScopeKey] = () => scope.stop();
+  },
+  beforeUpdate(el, { value }) {
+    if (!isRegisterValue(value)) return;
+    const input = el;
+    const currentRaw = value.innerRef.value;
+    if (isBlankFileValue(currentRaw)) {
+      value.setValueWithInternalPath(currentRaw, { blank: true });
+      if (input.value !== "") input.value = "";
     }
   },
   beforeUnmount(el, { value }) {
     removeTrackedListeners(el);
+    const stop = el[fileScopeKey];
+    if (stop !== void 0) {
+      stop();
+      delete el[fileScopeKey];
+    }
     if (!isRegisterValue(value)) return;
     value.deregisterElement(el);
   }
@@ -1183,7 +1347,7 @@ function resolveDynamicModel(tagName, type) {
   if (tagName === "SELECT") return vRegisterSelect;
   if (tagName === "TEXTAREA") return vRegisterText;
   if (typeof type !== "string") return vRegisterText;
-  if (type === "file") return vRegisterFileNoop;
+  if (type === "file") return vRegisterFile;
   if (type === "checkbox") return vRegisterCheckbox;
   if (type === "radio") return vRegisterRadio;
   return vRegisterText;
@@ -1193,7 +1357,9 @@ function callModelHook(el, binding, vnode, prevVNode, hook) {
   const fn = modelToUse[hook];
   fn?.(el, binding, vnode, prevVNode);
 }
+const V_REGISTER_MARKER = Symbol.for("attaform:v-register-directive");
 const vRegister = vRegisterDynamic;
+vRegisterDynamic[V_REGISTER_MARKER] = true;
 
 function installAttaformOnApp(app, options, source) {
   if (app._attaform !== void 0) {
@@ -1230,5 +1396,113 @@ function createAttaform(options = {}) {
   return plugin;
 }
 
-export { AnonPersistError as A, DEFAULT_SENSITIVE_NAMES as D, InvalidPathError as I, OutsideSetupError as O, RegistryNotInstalledError as R, SensitivePersistFieldError as S, __DEV__ as _, AttaformError as a, InvalidUseFormConfigError as b, createAttaform as c, ReservedFormKeyError as d, SubmitErrorHandlerError as e, assignKey as f, getRegistryFromApp as g, createRegistry as h, isRegisterValue as i, useRegistry as j, kAttaformRegistry as k, captureUserCallSite as l, enforceSensitiveCheck as m, isSensitivePath as n, createPersistOptInRegistry as o, ensureAttaformInstalled as p, kFormContext as q, kFormInstanceId as r, segmentMatchesSensitive as s, createIsSensitivePath as t, useRegister as u, vRegister as v, createSegmentMatchesSensitive as w };
-//# sourceMappingURL=attaform.CIEQgJnM.mjs.map
+const INTEGER_SEGMENT = /^(?:0|[1-9]\d*)$/;
+function normalizeSegment(raw) {
+  if (typeof raw === "number") {
+    if (!Number.isInteger(raw) || raw < 0) {
+      throw new InvalidPathError(
+        `Path segments must be non-negative integers when numeric; got ${String(raw)}`
+      );
+    }
+    return raw;
+  }
+  if (INTEGER_SEGMENT.test(raw)) return Number(raw);
+  return raw;
+}
+function parseDottedPath(path) {
+  if (path.length === 0) return [""];
+  const rawSegments = path.split(".");
+  const segments = [];
+  for (const raw of rawSegments) {
+    if (raw.length === 0) {
+      throw new InvalidPathError(
+        `Path '${path}' has an empty segment; use the array form for empty keys.`
+      );
+    }
+    segments.push(normalizeSegment(raw));
+  }
+  return segments;
+}
+const CANONICAL_STRING_CACHE_MAX = 128;
+const canonicalStringCache = /* @__PURE__ */ new Map();
+const PATHKEY_TO_SEGMENTS_MAX = 4096;
+const pathKeyToSegments = /* @__PURE__ */ new Map();
+function rememberSegmentsForPathKey(key, segments) {
+  if (!pathKeyToSegments.has(key) && pathKeyToSegments.size >= PATHKEY_TO_SEGMENTS_MAX) {
+    const oldest = pathKeyToSegments.keys().next().value;
+    if (oldest !== void 0) pathKeyToSegments.delete(oldest);
+  }
+  pathKeyToSegments.set(key, segments);
+}
+function segmentsForPathKey(key) {
+  const cached = pathKeyToSegments.get(key);
+  if (cached !== void 0) return cached;
+  let parsed;
+  try {
+    parsed = JSON.parse(key);
+  } catch {
+    return null;
+  }
+  if (!Array.isArray(parsed)) return null;
+  const segments = [];
+  for (const raw of parsed) {
+    if (typeof raw !== "string" && typeof raw !== "number") return null;
+    segments.push(normalizeSegment(raw));
+  }
+  rememberSegmentsForPathKey(key, segments);
+  return segments;
+}
+function canonicalizePath(input) {
+  if (typeof input === "string") {
+    const cached = canonicalStringCache.get(input);
+    if (cached !== void 0) return cached;
+    const segments2 = parseDottedPath(input);
+    const key2 = JSON.stringify(segments2);
+    const entry = { segments: segments2, key: key2 };
+    if (canonicalStringCache.size >= CANONICAL_STRING_CACHE_MAX) {
+      const oldest = canonicalStringCache.keys().next().value;
+      if (oldest !== void 0) canonicalStringCache.delete(oldest);
+    }
+    canonicalStringCache.set(input, entry);
+    rememberSegmentsForPathKey(key2, segments2);
+    return entry;
+  }
+  const segments = Array.from(input).map(normalizeSegment);
+  const key = JSON.stringify(segments);
+  rememberSegmentsForPathKey(key, segments);
+  return { segments, key };
+}
+function segmentsToDotted(segments) {
+  return segments.join(".");
+}
+function pathKeyToDotted(key) {
+  const segments = segmentsForPathKey(key);
+  if (segments === null) return null;
+  return segmentsToDotted(segments);
+}
+function coerceToPathKey(input) {
+  if (input.length > 0 && input.charCodeAt(0) === 91) {
+    try {
+      const parsed = JSON.parse(input);
+      if (Array.isArray(parsed) && parsed.every((s) => typeof s === "string" || typeof s === "number")) {
+        return input;
+      }
+    } catch {
+    }
+  }
+  return canonicalizePath(input).key;
+}
+const ROOT_PATH = Object.freeze([]);
+const ROOT_PATH_KEY = "[]";
+const FORM_ERRORS_PATH = Object.freeze([""]);
+const FORM_ERRORS_PATH_KEY = '[""]';
+function isPathPrefix(prefix, path) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+
+export { AnonPersistError as A, isSensitivePath as B, createPersistOptInRegistry as C, DEFAULT_SENSITIVE_NAMES as D, ensureAttaformInstalled as E, FORM_ERRORS_PATH_KEY as F, kFormContext as G, kFormInstanceId as H, InvalidPathError as I, createIsSensitivePath as J, createSegmentMatchesSensitive as K, kAttaformAncestorWizard as L, OutsideSetupError as O, ROOT_PATH as R, SensitivePersistFieldError as S, __DEV__ as _, canonicalizePath as a, AttaformError as b, createAttaform as c, InvalidUseFormConfigError as d, ROOT_PATH_KEY as e, RegistryNotInstalledError as f, getRegistryFromApp as g, ReservedFormKeyError as h, SubmitErrorHandlerError as i, assignKey as j, kAttaformWizardActiveStepResolver as k, createRegistry as l, isPathPrefix as m, isRegisterValue as n, kAttaformRegistry as o, parseDottedPath as p, useRegistry as q, pathKeyToDotted as r, segmentsForPathKey as s, captureUserCallSite as t, useRegister as u, vRegister as v, enforceSensitiveCheck as w, FORM_ERRORS_PATH as x, coerceToPathKey as y, segmentMatchesSensitive as z };
+//# sourceMappingURL=attaform.Xhg0AYNa.mjs.map