attaform 0.28.0 → 0.29.0

package/dist/{dev/shared/attaform-dev.By4PRjt0.mjs → shared/attaform.Cvao8bW5.mjs}

@@ -1,4 +1,4 @@
-import { f as pathsEqual, i as isPathPrefix } from './attaform-dev.Dr2YzS5B.mjs';
+import { m as mapSegmentKeys, f as pathsEqual, i as isPathPrefix } from './attaform.CZYt_5N_.mjs';
 
 const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
 const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
@@ -10,12 +10,6 @@ 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 acceptedDescription = allowInfinity ? "a non-negative integer or Infinity" : "a non-negative finite integer";
-      console.warn(
-        `[attaform] ${source} must be ${acceptedDescription}; got ${String(value)}. Falling back to ${String(defaultValue)}.`
-      );
-    }
     return defaultValue;
   }
   return Math.max(min, Math.floor(value));
@@ -28,6 +22,49 @@ function pickDefined(bag) {
   return out;
 }
 
+function callConsumerSchemaFn(fn, fallback, site) {
+  try {
+    return fn();
+  } catch (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, {
@@ -47,17 +84,42 @@ 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;
 }
@@ -83,6 +145,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) {
@@ -122,46 +194,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;
@@ -230,6 +335,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++) {
@@ -245,4 +355,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, consumerHas as d, safeOwnHas 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 };

package/dist/shared/{attaform.Dq4vWxuG.mjs → attaform.D0x-qSXm.mjs}

@@ -1,4 +1,4 @@
-import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.wfY8XFvm.mjs';
+import { c as RegistryNotInstalledError, O as OutsideSetupError, g as pathKeyToDotted } from './attaform.CZYt_5N_.mjs';
 import { shallowReactive, getCurrentInstance, inject } from 'vue';
 
 function detectSSR(options = {}) {