attaform 0.17.2 → 0.18.0

package/dist/shared/{attaform.Dee2rU1P.cjs → attaform.BqK_L4gK.cjs}

@@ -78,43 +78,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 = vue.shallowReactive(/* @__PURE__ */ new Map());
+  const wizards = vue.shallowReactive(/* @__PURE__ */ new Map());
   const pendingHydration = vue.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 = vue.getCurrentInstance();
@@ -284,6 +359,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"];
   };
@@ -634,6 +720,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);
@@ -642,9 +734,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) {
@@ -770,7 +863,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) {
@@ -1122,7 +1221,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)) {
@@ -1144,7 +1243,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");
@@ -1165,18 +1264,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);
+  vue.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__) {
-      vue.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 = vue.effectScope(true);
+    scope.run(() => {
+      vue.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);
   }
@@ -1185,7 +1349,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;
@@ -1195,7 +1359,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) {
@@ -1232,19 +1398,133 @@ function createAttaform(options = {}) {
   return plugin;
 }
 
+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;
+}
+
 exports.AnonPersistError = AnonPersistError;
 exports.AttaformError = AttaformError;
 exports.DEFAULT_SENSITIVE_NAMES = DEFAULT_SENSITIVE_NAMES;
+exports.FORM_ERRORS_PATH = FORM_ERRORS_PATH;
+exports.FORM_ERRORS_PATH_KEY = FORM_ERRORS_PATH_KEY;
 exports.InvalidPathError = InvalidPathError;
 exports.InvalidUseFormConfigError = InvalidUseFormConfigError;
 exports.OutsideSetupError = OutsideSetupError;
+exports.ROOT_PATH = ROOT_PATH;
+exports.ROOT_PATH_KEY = ROOT_PATH_KEY;
 exports.RegistryNotInstalledError = RegistryNotInstalledError;
 exports.ReservedFormKeyError = ReservedFormKeyError;
 exports.SensitivePersistFieldError = SensitivePersistFieldError;
 exports.SubmitErrorHandlerError = SubmitErrorHandlerError;
 exports.__DEV__ = __DEV__;
 exports.assignKey = assignKey;
+exports.canonicalizePath = canonicalizePath;
 exports.captureUserCallSite = captureUserCallSite;
+exports.coerceToPathKey = coerceToPathKey;
 exports.createAttaform = createAttaform;
 exports.createIsSensitivePath = createIsSensitivePath;
 exports.createPersistOptInRegistry = createPersistOptInRegistry;
@@ -1253,13 +1533,19 @@ exports.createSegmentMatchesSensitive = createSegmentMatchesSensitive;
 exports.enforceSensitiveCheck = enforceSensitiveCheck;
 exports.ensureAttaformInstalled = ensureAttaformInstalled;
 exports.getRegistryFromApp = getRegistryFromApp;
+exports.isPathPrefix = isPathPrefix;
 exports.isRegisterValue = isRegisterValue;
 exports.isSensitivePath = isSensitivePath;
+exports.kAttaformAncestorWizard = kAttaformAncestorWizard;
 exports.kAttaformRegistry = kAttaformRegistry;
+exports.kAttaformWizardActiveStepResolver = kAttaformWizardActiveStepResolver;
 exports.kFormContext = kFormContext;
 exports.kFormInstanceId = kFormInstanceId;
+exports.parseDottedPath = parseDottedPath;
+exports.pathKeyToDotted = pathKeyToDotted;
 exports.segmentMatchesSensitive = segmentMatchesSensitive;
+exports.segmentsForPathKey = segmentsForPathKey;
 exports.useRegister = useRegister;
 exports.useRegistry = useRegistry;
 exports.vRegister = vRegister;
-//# sourceMappingURL=attaform.Dee2rU1P.cjs.map
+//# sourceMappingURL=attaform.BqK_L4gK.cjs.map