attaform 0.28.0 → 0.30.0

package/dist/{shared/attaform.h0i6LijT.mjs → dev/shared/attaform-dev.BcYT6tFh.mjs}

@@ -1,4 +1,4 @@
-import { f as pathsEqual, i as isPathPrefix } from './attaform.wfY8XFvm.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform-dev.BQc5QV3Y.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -7,9 +7,13 @@ const ANONYMOUS_FORM_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon:`;
 const ANONYMOUS_WIZARD_KEY_PREFIX = `${RESERVED_KEY_PREFIX}anon-wizard:`;
 const DEFAULT_MAX_RECURSION_DEPTH = 64;
 function normalizeNumericOption(config) {
-  const { value, source, allowInfinity, min, defaultValue } = config;
-  if (allowInfinity && value === Infinity) return Infinity;
-  if (typeof value !== "number" || Number.isNaN(value) || value === Infinity || value === -Infinity) {
+  const { value, source, min, defaultValue } = config;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    {
+      console.warn(
+        `[attaform] ${source} must be a non-negative finite integer; got ${String(value)}. Falling back to ${String(defaultValue)}.`
+      );
+    }
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -22,6 +26,60 @@ function pickDefined(bag) {
   return out;
 }
 
+const reported = /* @__PURE__ */ new Set() ;
+function report(site, err) {
+  if (reported === null || reported.has(site)) return;
+  reported.add(site);
+  const advice = site === "default-factory" ? "a `.default(() => ...)` factory threw. Attaform used `undefined` for that field's initial value." : site === "catch-factory" ? "a `.catch(() => ...)` fallback threw. Attaform used `undefined` for that value." : "a `z.lazy(() => ...)` factory threw. Attaform stopped descending at that node, so paths below it will not resolve.";
+  console.error(
+    `[attaform] ${advice} A function inside your schema must not throw; wrap your own try/catch if the failure is recoverable. Original error:`,
+    err
+  );
+}
+function callConsumerSchemaFn(fn, fallback, site) {
+  try {
+    return fn();
+  } catch (err) {
+    report(site, err);
+    return fallback;
+  }
+}
+function readConsumerProp(obj, key) {
+  try {
+    return obj[key];
+  } catch {
+    return void 0;
+  }
+}
+function consumerKeys(obj) {
+  try {
+    return Object.keys(obj);
+  } catch {
+    return [];
+  }
+}
+function readConsumerIndex(arr, i) {
+  try {
+    return arr[i];
+  } catch {
+    return void 0;
+  }
+}
+function consumerSymbolKeys(obj) {
+  try {
+    return Object.getOwnPropertySymbols(obj);
+  } catch {
+    return [];
+  }
+}
+function consumerHas(obj, key) {
+  try {
+    return key in obj;
+  } catch {
+    return false;
+  }
+}
+
 function safeAssign(target, key, value) {
   if (key === "__proto__") {
     Object.defineProperty(target, key, {
@@ -34,24 +92,50 @@ function safeAssign(target, key, value) {
   }
   target[key] = value;
 }
+const SHADOWED_KEYS = new Set(Object.getOwnPropertyNames(Object.prototype));
 function isShadowedKey(key) {
-  return key in Object.prototype;
+  return SHADOWED_KEYS.has(key);
 }
 function safeOwnRead(target, key) {
   if (isShadowedKey(key)) {
     const desc = Object.getOwnPropertyDescriptor(target, key);
     if (desc === void 0) return void 0;
-    return "value" in desc ? desc.value : target[key];
+    return "value" in desc ? desc.value : readConsumerProp(target, key);
   }
-  return target[key];
+  return readConsumerProp(target, key);
 }
 function safeOwnHas(target, key) {
-  return Object.prototype.hasOwnProperty.call(target, key);
+  try {
+    return Object.prototype.hasOwnProperty.call(target, key);
+  } catch {
+    return false;
+  }
+}
+function spreadConsumerRecord(src) {
+  try {
+    return { ...src };
+  } catch {
+    const out = {};
+    for (const key of Object.keys(src)) {
+      safeAssign(out, key, readConsumerProp(src, key));
+    }
+    return out;
+  }
+}
+function copyConsumerArray(src) {
+  try {
+    return src.slice();
+  } catch {
+    const out = new Array(src.length);
+    for (let i = 0; i < src.length; i++) out[i] = readConsumerIndex(src, i);
+    return out;
+  }
 }
 
 function isDescendable(value) {
   if (value === null || typeof value !== "object") return false;
   if (Array.isArray(value)) return true;
+  if (value instanceof Map) return mapSegmentKeys(value) !== null;
   const proto = Object.getPrototypeOf(value);
   return proto === null || proto === Object.prototype;
 }
@@ -77,6 +161,16 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
     return;
   }
   if (oldIsDescendable && newIsDescendable) {
+    const oldIsMap = oldValue instanceof Map;
+    const newIsMap = newValue instanceof Map;
+    if (oldIsMap && newIsMap) {
+      diffMapsLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (oldIsMap !== newIsMap) {
+      visit({ kind: "changed", path: prefix, oldValue, newValue });
+      return;
+    }
     const oldIsArray = Array.isArray(oldValue);
     const newIsArray = Array.isArray(newValue);
     if (oldIsArray && newIsArray) {
@@ -116,46 +210,79 @@ function diffAndApply(oldValue, newValue, prefix, visit) {
 function walkNewDescendable(newValue, prefix, visit) {
   if (Array.isArray(newValue)) {
     for (let i = 0; i < newValue.length; i++) {
-      diffAndApply(void 0, newValue[i], appendSegment(prefix, i), visit);
+      diffAndApply(void 0, readConsumerIndex(newValue, i), appendSegment(prefix, i), visit);
+    }
+  } else if (newValue instanceof Map) {
+    for (const [key, entry] of newValue) {
+      diffAndApply(void 0, entry, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = newValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(void 0, rec[k], appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(void 0, readConsumerProp(rec, k), appendSegment(prefix, k), visit);
     }
   }
 }
 function walkOldDescendable(oldValue, prefix, visit) {
   if (Array.isArray(oldValue)) {
     for (let i = 0; i < oldValue.length; i++) {
-      diffAndApply(oldValue[i], void 0, appendSegment(prefix, i), visit);
+      diffAndApply(readConsumerIndex(oldValue, i), void 0, appendSegment(prefix, i), visit);
+    }
+  } else if (oldValue instanceof Map) {
+    for (const [key, entry] of oldValue) {
+      diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
     }
   } else {
     const rec = oldValue;
-    for (const k of Object.keys(rec)) {
-      diffAndApply(rec[k], void 0, appendSegment(prefix, k), visit);
+    for (const k of consumerKeys(rec)) {
+      diffAndApply(readConsumerProp(rec, k), void 0, appendSegment(prefix, k), visit);
     }
   }
 }
+function diffMapsLockstep(oldMap, newMap, prefix, visit) {
+  for (const [key, entry] of newMap) {
+    diffAndApply(oldMap.get(key), entry, appendSegment(prefix, key), visit);
+  }
+  for (const [key, entry] of oldMap) {
+    if (newMap.has(key)) continue;
+    diffAndApply(entry, void 0, appendSegment(prefix, key), visit);
+  }
+}
 function diffArraysLockstep(oldArr, newArr, prefix, visit) {
   const max = Math.max(oldArr.length, newArr.length);
   for (let i = 0; i < max; i++) {
-    diffAndApply(oldArr[i], newArr[i], appendSegment(prefix, i), visit);
+    diffAndApply(
+      readConsumerIndex(oldArr, i),
+      readConsumerIndex(newArr, i),
+      appendSegment(prefix, i),
+      visit
+    );
   }
 }
 function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
   const seen = /* @__PURE__ */ new Set();
-  for (const k of Object.keys(oldRec)) {
+  for (const k of consumerKeys(oldRec)) {
     seen.add(k);
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
-  for (const k of Object.keys(newRec)) {
+  for (const k of consumerKeys(newRec)) {
     if (seen.has(k)) continue;
-    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+    diffAndApply(
+      readConsumerProp(oldRec, k),
+      readConsumerProp(newRec, k),
+      appendSegment(prefix, k),
+      visit
+    );
   }
 }
 function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
   if (!isDescendable(target) || !isDescendable(source)) return false;
+  if (target instanceof Map || source instanceof Map) return false;
   const targetIsArray = Array.isArray(target);
   const sourceIsArray = Array.isArray(source);
   if (targetIsArray !== sourceIsArray) return false;
@@ -224,6 +351,11 @@ function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
 }
 function structuralSnapshot(value) {
   if (!isDescendable(value)) return value;
+  if (value instanceof Map) {
+    const out2 = /* @__PURE__ */ new Map();
+    for (const [k, v] of value) out2.set(k, structuralSnapshot(v));
+    return out2;
+  }
   if (Array.isArray(value)) {
     const out2 = new Array(value.length);
     for (let i = 0; i < value.length; i++) {
@@ -239,4 +371,4 @@ function structuralSnapshot(value) {
   return out;
 }
 
-export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, safeOwnHas as c, diffAndApply as d, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as e, applyChangedKeys as f, DEFAULT_MAX_RECURSION_DEPTH as g, ANONYMOUS_WIZARD_KEY_PREFIX as h, isShadowedKey as i, normalizeNumericOption as n, pickDefined as p, structuralSnapshot as s };
+export { ANONYMOUS_FORM_KEY_PREFIX as A, DEFAULT_HISTORY_MAX_SNAPSHOTS as D, RESERVED_KEY_PREFIX as R, safeOwnRead as a, safeAssign as b, callConsumerSchemaFn as c, safeOwnHas as d, consumerHas as e, spreadConsumerRecord as f, copyConsumerArray as g, consumerKeys as h, isShadowedKey as i, readConsumerProp as j, diffAndApply as k, DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS as l, consumerSymbolKeys as m, normalizeNumericOption as n, applyChangedKeys as o, pickDefined as p, DEFAULT_MAX_RECURSION_DEPTH as q, readConsumerIndex as r, structuralSnapshot as s, ANONYMOUS_WIZARD_KEY_PREFIX as t };