attaform 0.27.6 → 0.28.0

package/dist/shared/attaform.h0i6LijT.mjs

@@ -0,0 +1,242 @@
+import { f as pathsEqual, i as isPathPrefix } from './attaform.wfY8XFvm.mjs';
+
+const DEFAULT_FIELD_VALIDATION_DEBOUNCE_MS = 0;
+const DEFAULT_HISTORY_MAX_SNAPSHOTS = 128;
+const RESERVED_KEY_PREFIX = "__atta:";
+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) {
+    return defaultValue;
+  }
+  return Math.max(min, Math.floor(value));
+}
+function pickDefined(bag) {
+  const out = {};
+  for (const key of Object.keys(bag)) {
+    if (bag[key] !== void 0) out[key] = bag[key];
+  }
+  return out;
+}
+
+function safeAssign(target, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(target, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+    return;
+  }
+  target[key] = value;
+}
+function isShadowedKey(key) {
+  return key in Object.prototype;
+}
+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 target[key];
+}
+function safeOwnHas(target, key) {
+  return Object.prototype.hasOwnProperty.call(target, key);
+}
+
+function isDescendable(value) {
+  if (value === null || typeof value !== "object") return false;
+  if (Array.isArray(value)) return true;
+  const proto = Object.getPrototypeOf(value);
+  return proto === null || proto === Object.prototype;
+}
+function appendSegment(prefix, segment) {
+  const next = new Array(prefix.length + 1);
+  for (let i = 0; i < prefix.length; i++) {
+    const s = prefix[i];
+    next[i] = s;
+  }
+  next[prefix.length] = segment;
+  return next;
+}
+function diffAndApply(oldValue, newValue, prefix, visit) {
+  if (Object.is(oldValue, newValue)) return;
+  const oldIsDescendable = isDescendable(oldValue);
+  const newIsDescendable = isDescendable(newValue);
+  if (oldValue === void 0 && newIsDescendable) {
+    walkNewDescendable(newValue, prefix, visit);
+    return;
+  }
+  if (oldIsDescendable && newValue === void 0) {
+    walkOldDescendable(oldValue, prefix, visit);
+    return;
+  }
+  if (oldIsDescendable && newIsDescendable) {
+    const oldIsArray = Array.isArray(oldValue);
+    const newIsArray = Array.isArray(newValue);
+    if (oldIsArray && newIsArray) {
+      diffArraysLockstep(oldValue, newValue, prefix, visit);
+      return;
+    }
+    if (!oldIsArray && !newIsArray) {
+      diffObjectsLockstep(
+        oldValue,
+        newValue,
+        prefix,
+        visit
+      );
+      return;
+    }
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldIsDescendable && !newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (!oldIsDescendable && newIsDescendable) {
+    visit({ kind: "changed", path: prefix, oldValue, newValue });
+    return;
+  }
+  if (oldValue === void 0) {
+    visit({ kind: "added", path: prefix, newValue });
+    return;
+  }
+  if (newValue === void 0) {
+    visit({ kind: "removed", path: prefix, oldValue });
+    return;
+  }
+  visit({ kind: "changed", path: prefix, oldValue, newValue });
+}
+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);
+    }
+  } else {
+    const rec = newValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(void 0, 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);
+    }
+  } else {
+    const rec = oldValue;
+    for (const k of Object.keys(rec)) {
+      diffAndApply(rec[k], void 0, appendSegment(prefix, k), 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);
+  }
+}
+function diffObjectsLockstep(oldRec, newRec, prefix, visit) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const k of Object.keys(oldRec)) {
+    seen.add(k);
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+  for (const k of Object.keys(newRec)) {
+    if (seen.has(k)) continue;
+    diffAndApply(oldRec[k], newRec[k], appendSegment(prefix, k), visit);
+  }
+}
+function applyChangedKeys(target, source, arrayOpPath, currentPath, patches) {
+  if (!isDescendable(target) || !isDescendable(source)) return false;
+  const targetIsArray = Array.isArray(target);
+  const sourceIsArray = Array.isArray(source);
+  if (targetIsArray !== sourceIsArray) return false;
+  const depth = currentPath.length;
+  const changedFirstSegments = /* @__PURE__ */ new Set();
+  for (const patch of patches) {
+    if (patch.path.length === depth) return false;
+    changedFirstSegments.add(patch.path[depth]);
+  }
+  if (targetIsArray) {
+    const t = target;
+    const s = source;
+    if (arrayOpPath === null || pathsEqual(currentPath, arrayOpPath)) {
+      if (t.length > s.length) t.length = s.length;
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        t[i] = s[i];
+      }
+    } else {
+      for (const idx of changedFirstSegments) {
+        const i = typeof idx === "number" ? idx : Number(idx);
+        if (i >= s.length) continue;
+        const childPath = appendSegment(currentPath, i);
+        const curEl = t[i];
+        const nextEl = s[i];
+        if (isPathPrefix(childPath, arrayOpPath) && isDescendable(curEl) && isDescendable(nextEl) && applyChangedKeys(
+          curEl,
+          nextEl,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+        t[i] = nextEl;
+      }
+    }
+  } else {
+    const t = target;
+    const s = source;
+    const sourceKeys = new Set(Object.keys(s));
+    for (const k of Object.keys(t)) {
+      if (!sourceKeys.has(k)) delete t[k];
+    }
+    for (const k of changedFirstSegments) {
+      const key = String(k);
+      const nextVal = safeOwnRead(s, key);
+      if (arrayOpPath !== null) {
+        const curVal = safeOwnRead(t, key);
+        const childPath = appendSegment(currentPath, key);
+        if (isDescendable(curVal) && isDescendable(nextVal) && applyChangedKeys(
+          curVal,
+          nextVal,
+          arrayOpPath,
+          childPath,
+          patches.filter((p) => isPathPrefix(childPath, p.path))
+        )) {
+          continue;
+        }
+      }
+      safeAssign(t, key, nextVal);
+    }
+  }
+  return true;
+}
+function structuralSnapshot(value) {
+  if (!isDescendable(value)) return value;
+  if (Array.isArray(value)) {
+    const out2 = new Array(value.length);
+    for (let i = 0; i < value.length; i++) {
+      out2[i] = structuralSnapshot(value[i]);
+    }
+    return out2;
+  }
+  const src = value;
+  const out = {};
+  for (const k of Object.keys(src)) {
+    safeAssign(out, k, structuralSnapshot(safeOwnRead(src, k)));
+  }
+  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 };