attaform 0.20.0 → 0.20.1

package/dist/shared/{attaform.CKFbKFb6.mjs → attaform.BqZuwLTK.mjs}

@@ -1,6 +1,29 @@
 import { computed, ref, watchEffect, getCurrentScope, onScopeDispose, shallowReadonly, readonly, reactive, toRaw, watch, markRaw, shallowRef, getCurrentInstance, onServerPrefetch, provide, useId, inject, effectScope, nextTick } from 'vue';
 import { _ as __DEV__, j as canonicalizePath, E as segmentsForPathKey, s as isPathPrefix, b as FORM_ERRORS_PATH_KEY, S as SubmitErrorHandlerError, A as AnonPersistError, k as captureUserCallSite, I as INTERACTIVE_TAG_NAMES, e as ROOT_PATH_KEY, R as ROOT_PATH, h as allowSensitivePersist, F as FORM_ERRORS_PATH, l as coerceToPathKey, u as isSensitivePath, o as createPersistOptInRegistry, d as InvalidUseFormConfigError, q as ensureAttaformInstalled, H as useRegistry, y as kFormContext, z as kFormInstanceId, g as ReservedFormKeyError, n as createIsSensitivePath, x as kAttaformWizardActiveStepResolver, v as kAttaformAncestorWizard } from './attaform.BKozEdTr.mjs';
 
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function safeOwnRead(target, key) {
+  if (key === "__proto__") {
+    const desc = Object.getOwnPropertyDescriptor(target, "__proto__");
+    return desc?.value;
+  }
+  return target[key];
+}
+function safeOwnHas(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+
 const NOT_FOUND = Symbol("NOT_FOUND");
 function descendStep(value, segment) {
   if (value === null || value === void 0) return NOT_FOUND;
@@ -62,8 +85,8 @@ function setAtPathOffset(root, path, value, offset) {
     arr[head] = setAtPathOffset(arr[head], path, value, nextOffset);
     return arr;
   }
-  const rec = isPlainRecord(root) ? Object.assign(/* @__PURE__ */ Object.create(null), root) : /* @__PURE__ */ Object.create(null);
-  rec[head] = setAtPathOffset(rec[head], path, value, nextOffset);
+  const rec = isPlainRecord(root) ? { ...root } : {};
+  safeAssign(rec, head, setAtPathOffset(safeOwnRead(rec, head), path, value, nextOffset));
   return rec;
 }
 function deleteAtPath(root, path) {
@@ -92,9 +115,9 @@ function deleteAtPathOffset(root, path, offset) {
     delete rec2[head];
     return rec2;
   }
-  if (!(head in root)) return root;
+  if (!safeOwnHas(root, head)) return root;
   const rec = { ...root };
-  rec[head] = deleteAtPathOffset(rec[head], path, nextOffset);
+  safeAssign(rec, head, deleteAtPathOffset(safeOwnRead(rec, head), path, nextOffset));
   return rec;
 }
 function resolveArrayShape(schema, scratch) {
@@ -163,27 +186,27 @@ function mergeStructuralImpl(schema, scratch, consumer, defaultValue) {
       return consumer;
     }
     let mutated = false;
-    const out = Object.assign(/* @__PURE__ */ Object.create(null), consumer);
+    const out = { ...consumer };
     for (const key of Object.keys(defaultValue)) {
-      if (!(key in consumer)) {
-        const defAtKey = defaultValue[key];
+      if (!safeOwnHas(consumer, key)) {
+        const defAtKey = safeOwnRead(defaultValue, key);
         scratch.push(key);
         const filled = mergeStructuralImpl(schema, scratch, void 0, defAtKey);
         scratch.pop();
         if (filled !== void 0) {
-          out[key] = filled;
+          safeAssign(out, key, filled);
           mutated = true;
         }
       }
     }
     for (const key of Object.keys(consumer)) {
-      const cVal = consumer[key];
+      const cVal = safeOwnRead(consumer, key);
       if (cVal === void 0) continue;
       scratch.push(key);
-      const merged = mergeStructuralImpl(schema, scratch, cVal, defaultValue[key]);
+      const merged = mergeStructuralImpl(schema, scratch, cVal, safeOwnRead(defaultValue, key));
       scratch.pop();
       if (merged !== cVal) {
-        out[key] = merged;
+        safeAssign(out, key, merged);
         mutated = true;
       }
     }
@@ -377,7 +400,8 @@ function applyChangedKeys(target, source) {
     }
     for (const k of changedFirstSegments) {
       if (typeof k === "symbol") continue;
-      t[String(k)] = s[String(k)];
+      const key = String(k);
+      safeAssign(t, key, safeOwnRead(s, key));
     }
   }
   return true;
@@ -427,9 +451,9 @@ function structuralSnapshot(value) {
     return out2;
   }
   const src = value;
-  const out = /* @__PURE__ */ Object.create(null);
+  const out = {};
   for (const k of Object.keys(src)) {
-    out[k] = structuralSnapshot(src[k]);
+    safeAssign(out, k, structuralSnapshot(safeOwnRead(src, k)));
   }
   return out;
 }
@@ -1093,7 +1117,7 @@ function errorAwareContainerKeys(state, segments) {
 }
 function materializeErrors(state, containerSegments) {
   const liveContainer = getAtPath(state.form.value, containerSegments);
-  const tree = Array.isArray(liveContainer) ? [] : /* @__PURE__ */ Object.create(null);
+  const tree = Array.isArray(liveContainer) ? [] : {};
   const collect = (store, applyActivePathFilter) => {
     entries: for (const [pathKey, errors] of store) {
       if (errors.length === 0) continue;
@@ -1141,18 +1165,18 @@ function placeAt(tree, path, errors) {
     const nextSeg = path[i + 1];
     const key = typeof seg === "number" ? String(seg) : seg;
     const cursorRecord2 = cursor;
-    let child = cursorRecord2[key];
+    let child = safeOwnRead(cursorRecord2, key);
     if (child === null || child === void 0 || typeof child !== "object") {
-      child = typeof nextSeg === "number" ? [] : /* @__PURE__ */ Object.create(null);
-      cursorRecord2[key] = child;
+      child = typeof nextSeg === "number" ? [] : {};
+      safeAssign(cursorRecord2, key, child);
     }
     cursor = child;
   }
   const lastSeg = path[path.length - 1];
   const lastKey = typeof lastSeg === "number" ? String(lastSeg) : lastSeg;
   const cursorRecord = cursor;
-  const existing = cursorRecord[lastKey];
-  cursorRecord[lastKey] = Array.isArray(existing) ? [...existing, ...errors] : errors;
+  const existing = safeOwnRead(cursorRecord, lastKey);
+  safeAssign(cursorRecord, lastKey, Array.isArray(existing) ? [...existing, ...errors] : errors);
 }
 
 function buildFieldArrayApi(state) {
@@ -1548,10 +1572,10 @@ function stripUnacknowledgedSensitiveLeaves(form, optedInPaths, isSensitivePath)
     if (value === null || typeof value !== "object") return value;
     if (Array.isArray(value)) return value.map((item, i) => walk([...path, i], item));
     if (!isPlainRecord(value)) return value;
-    const out = /* @__PURE__ */ Object.create(null);
+    const out = {};
     for (const key of Object.keys(value)) {
       const walked = walk([...path, key], value[key]);
-      if (walked !== void 0) out[key] = walked;
+      if (walked !== void 0) safeAssign(out, key, walked);
     }
     return out;
   };
@@ -1583,10 +1607,19 @@ function mergeDeep(target, source, path, schema) {
       if (sourceDisc !== void 0) {
         const variantDefault = du.getVariantDefault(sourceDisc);
         if (isPlainRecord(variantDefault)) {
-          const out2 = Object.assign(/* @__PURE__ */ Object.create(null), variantDefault);
+          const out2 = { ...variantDefault };
           for (const key of Object.keys(sourceRecord)) {
-            if (!(key in variantDefault) && key !== du.discriminatorKey) continue;
-            out2[key] = mergeDeep(out2[key], sourceRecord[key], [...path, key], schema);
+            if (!safeOwnHas(variantDefault, key) && key !== du.discriminatorKey) continue;
+            safeAssign(
+              out2,
+              key,
+              mergeDeep(
+                safeOwnRead(out2, key),
+                safeOwnRead(sourceRecord, key),
+                [...path, key],
+                schema
+              )
+            );
           }
           return out2;
         }
@@ -1595,9 +1628,18 @@ function mergeDeep(target, source, path, schema) {
     }
   }
   const mergeTarget = target;
-  const out = isPlainRecord(mergeTarget) ? Object.assign(/* @__PURE__ */ Object.create(null), mergeTarget) : /* @__PURE__ */ Object.create(null);
+  const out = isPlainRecord(mergeTarget) ? { ...mergeTarget } : {};
   for (const key of Object.keys(source)) {
-    out[key] = mergeDeep(out[key], source[key], [...path, key], schema);
+    safeAssign(
+      out,
+      key,
+      mergeDeep(
+        safeOwnRead(out, key),
+        safeOwnRead(source, key),
+        [...path, key],
+        schema
+      )
+    );
   }
   return out;
 }
@@ -2381,17 +2423,17 @@ function walk(input, segments, schema, paths) {
     if (slim !== null && slim !== void 0 && typeof slim === "object" && !Array.isArray(slim) && !(slim instanceof Date) && !(slim instanceof RegExp) && !(slim instanceof Map) && !(slim instanceof Set)) {
       for (const k of Object.keys(slim)) allKeys.add(k);
     }
-    const out = /* @__PURE__ */ Object.create(null);
+    const out = {};
     let mutated = allKeys.size !== inputKeys.length;
     for (const key of allKeys) {
       const orig = input[key];
       if (orig === void 0 && inputKeysSet.has(key)) {
-        out[key] = void 0;
+        safeAssign(out, key, void 0);
         mutated = true;
         continue;
       }
       const walked = walk(orig, [...segments, key], schema, paths);
-      out[key] = walked;
+      safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
     return mutated ? out : input;
@@ -2410,9 +2452,13 @@ function walkUnspecified(slim, segments, paths) {
   }
   if (Array.isArray(slim)) return slim;
   if (slim !== null && typeof slim === "object") {
-    const out = /* @__PURE__ */ Object.create(null);
+    const out = {};
     for (const key of Object.keys(slim)) {
-      out[key] = walkUnspecified(slim[key], [...segments, key], paths);
+      safeAssign(
+        out,
+        key,
+        walkUnspecified(slim[key], [...segments, key], paths)
+      );
     }
     return out;
   }
@@ -2443,11 +2489,11 @@ function substitute(input, segments, schema, paths) {
   }
   if (typeof input === "object") {
     let mutated = false;
-    const out = /* @__PURE__ */ Object.create(null);
+    const out = {};
     for (const key of Object.keys(input)) {
       const orig = input[key];
       const walked = substitute(orig, [...segments, key], schema, paths);
-      out[key] = walked;
+      safeAssign(out, key, walked);
       if (walked !== orig) mutated = true;
     }
     return mutated ? out : input;
@@ -3057,9 +3103,9 @@ function buildFormApi(state, formInstanceId, options = {}) {
     if (value === null || typeof value !== "object" || Array.isArray(value)) {
       return EMPTY_FIELD_RECORD;
     }
-    const out = /* @__PURE__ */ Object.create(null);
+    const out = {};
     for (const key of Object.keys(value)) {
-      out[key] = callTerminal(`${path}.${key}`);
+      safeAssign(out, key, callTerminal(`${path}.${key}`));
     }
     return Object.freeze(out);
   }
@@ -3181,14 +3227,14 @@ function walkDuStubs(schema, value, path, warned) {
           );
         }
       }
-      const stub = /* @__PURE__ */ Object.create(null);
-      stub[du.discriminatorKey] = discValue;
+      const stub = {};
+      safeAssign(stub, du.discriminatorKey, discValue);
       return stub;
     }
   }
-  const out = /* @__PURE__ */ Object.create(null);
+  const out = {};
   for (const k of Object.keys(rec)) {
-    out[k] = walkDuStubs(schema, rec[k], [...path, k], warned);
+    safeAssign(out, k, walkDuStubs(schema, rec[k], [...path, k], warned));
   }
   return out;
 }
@@ -3271,8 +3317,8 @@ function cloneVariantSnapshot(value) {
     return out2;
   }
   const src = raw;
-  const out = /* @__PURE__ */ Object.create(null);
-  for (const k of Object.keys(src)) out[k] = cloneVariantSnapshot(src[k]);
+  const out = {};
+  for (const k of Object.keys(src)) safeAssign(out, k, cloneVariantSnapshot(src[k]));
   return out;
 }
 
@@ -5195,9 +5241,8 @@ function wirePersistence(state, config) {
     if (isDisposed()) return;
     const raw = await adapter.getItem(key);
     const existing = readPersistedPayload(raw);
-    const baseForm = existing?.data.form ?? /* @__PURE__ */ Object.create(null);
     const value = getAtPath(toRaw(state.form.value), path);
-    const nextForm = setAtPath(baseForm, path, value);
+    const nextForm = setAtPath(existing?.data.form ?? {}, path, value);
     const { key: pathKey } = canonicalizePath(path);
     const transientSet = new Set(
       (existing?.data.blankPaths ?? []).filter(
@@ -5389,15 +5434,15 @@ function stripSensitivePathsDeep(value, pathSoFar, isSensitivePath) {
   }
   const proto = Object.getPrototypeOf(value);
   if (proto !== Object.prototype && proto !== null) return value;
-  const out = /* @__PURE__ */ Object.create(null);
+  const out = {};
   const src = value;
   for (const key of Object.keys(src)) {
     const childPath = [...pathSoFar, key];
     if (isSensitivePath(childPath)) {
-      out[key] = void 0;
+      safeAssign(out, key, void 0);
       continue;
     }
-    out[key] = stripSensitivePathsDeep(src[key], childPath, isSensitivePath);
+    safeAssign(out, key, stripSensitivePathsDeep(src[key], childPath, isSensitivePath));
   }
   return out;
 }
@@ -7157,5 +7202,5 @@ function warnIfAmbientWizardProviderHadDuplicates() {
   }
 }
 
-export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, slimKindOf as j, useAbstractForm as k, lazy as l, useWizard as m, normalizeNumericOption as n, setAtPath as s, unset as u };
-//# sourceMappingURL=attaform.CKFbKFb6.mjs.map
+export { AttaformErrorCode as A, defaultDisplayState as a, defineCoercion as b, injectWizard as c, defaultCoercionRules as d, isPlainRecord as e, isUnset as f, getAtPath as g, humanize as h, injectForm as i, safeOwnRead as j, setAtPath as k, lazy as l, slimKindOf as m, normalizeNumericOption as n, useAbstractForm as o, useWizard as p, safeAssign as s, unset as u };
+//# sourceMappingURL=attaform.BqZuwLTK.mjs.map