@goodie-forms/core 1.0.0-alpha

package/dist/index.js

@@ -0,0 +1,1184 @@
+var S;
+((t) => {
+  function e(u, a) {
+    if (u == null) return;
+    const r = a.split(".");
+    let s = u;
+    for (const f of r) {
+      if (s == null) return;
+      s = s[f];
+    }
+    return s;
+  }
+  t.getValue = e;
+  function i(u, a, r) {
+    if (u === a) return !0;
+    if (u === null || a === null || typeof u != "object" || typeof a != "object") return !1;
+    if (Array.isArray(u)) {
+      if (!Array.isArray(a) || u.length !== a.length) return !1;
+      for (let h = 0; h < u.length; h++)
+        if (!i(u[h], a[h])) return !1;
+      return !0;
+    }
+    if (r != null) {
+      const h = r(u, a);
+      if (h !== void 0) return h;
+    }
+    if (u instanceof Date && a instanceof Date)
+      return u.getTime() === a.getTime();
+    if (u instanceof RegExp && a instanceof RegExp)
+      return u.source === a.source && u.flags === a.flags;
+    if (u instanceof Map && a instanceof Map) {
+      if (u.size !== a.size) return !1;
+      for (const [h, v] of u)
+        if (!a.has(h) || !i(v, a.get(h))) return !1;
+      return !0;
+    }
+    if (u instanceof Set && a instanceof Set) {
+      if (u.size !== a.size) return !1;
+      for (const h of u)
+        if (!a.has(h)) return !1;
+      return !0;
+    }
+    if (Object.getPrototypeOf(u) !== Object.getPrototypeOf(a))
+      return !1;
+    const s = Object.keys(u), f = Object.keys(a);
+    if (s.length !== f.length) return !1;
+    for (const h of s)
+      if (!Object.prototype.hasOwnProperty.call(a, h) || !i(u[h], a[h])) return !1;
+    return !0;
+  }
+  t.deepEqual = i;
+  function n(u, a, r, s) {
+    const f = [], h = [], v = [];
+    for (const g of a)
+      u.some((I) => r(I, g)) ? (s?.(g) ?? !0) && v.push(g) : (s?.(g) ?? !0) && f.push(g);
+    for (const g of u)
+      a.some((I) => r(g, I)) || (s?.(g) ?? !0) && h.push(g);
+    return { added: f, removed: h, unchanged: v };
+  }
+  t.diff = n;
+  function o(u, a, r) {
+    return c(u, a, () => r);
+  }
+  t.setValue = o;
+  function c(u, a, r) {
+    const s = a.split(".");
+    let f = u;
+    for (let g = 0; g < s.length - 1; g++) {
+      const I = s[g];
+      f[I] == null && (f[I] = {}), f = f[I];
+    }
+    const h = f[s[s.length - 1]], v = r(h);
+    v !== void 0 && (f[s[s.length - 1]] = v);
+  }
+  t.modifyValue = c;
+  function l(u, a) {
+    const r = a.split(".");
+    let s = u;
+    for (let f = 0; f < r.length - 1; f++) {
+      const h = r[f];
+      if (s[h] == null)
+        return;
+      s = s[h];
+    }
+    delete s[r[r.length - 1]];
+  }
+  t.deleteValue = l;
+})(S || (S = {}));
+var zt = /* @__PURE__ */ Symbol.for("immer-nothing"), $ = /* @__PURE__ */ Symbol.for("immer-draftable"), _ = /* @__PURE__ */ Symbol.for("immer-state"), jt = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(t) {
+    return `The plugin for '${t}' has not been loaded into Immer. To enable the plugin, import and call \`enable${t}()\` when initializing your application.`;
+  },
+  function(t) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${t}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(t) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + t;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(t) {
+    return `'current' expects a draft, got: ${t}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(t) {
+    return `'original' expects a draft, got: ${t}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function M(t, ...e) {
+  if (process.env.NODE_ENV !== "production") {
+    const i = jt[t], n = C(i) ? i.apply(null, e) : i;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${t}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var D = Object, k = D.getPrototypeOf, K = "constructor", et = "prototype", dt = "configurable", Y = "enumerable", W = "writable", R = "value", V = (t) => !!t && !!t[_];
+function E(t) {
+  return t ? Tt(t) || it(t) || !!t[$] || !!t[K]?.[$] || nt(t) || rt(t) : !1;
+}
+var Lt = D[et][K].toString(), Mt = /* @__PURE__ */ new WeakMap();
+function Tt(t) {
+  if (!t || !st(t))
+    return !1;
+  const e = k(t);
+  if (e === null || e === D[et])
+    return !0;
+  const i = D.hasOwnProperty.call(e, K) && e[K];
+  if (i === Object)
+    return !0;
+  if (!C(i))
+    return !1;
+  let n = Mt.get(i);
+  return n === void 0 && (n = Function.toString.call(i), Mt.set(i, n)), n === Lt;
+}
+function H(t, e, i = !0) {
+  q(t) === 0 ? (i ? Reflect.ownKeys(t) : D.keys(t)).forEach((o) => {
+    e(o, t[o], t);
+  }) : t.forEach((n, o) => e(o, n, t));
+}
+function q(t) {
+  const e = t[_];
+  return e ? e.type_ : it(t) ? 1 : nt(t) ? 2 : rt(t) ? 3 : 0;
+}
+var Dt = (t, e, i = q(t)) => i === 2 ? t.has(e) : D[et].hasOwnProperty.call(t, e), ht = (t, e, i = q(t)) => (
+  // @ts-ignore
+  i === 2 ? t.get(e) : t[e]
+), J = (t, e, i, n = q(t)) => {
+  n === 2 ? t.set(e, i) : n === 3 ? t.add(i) : t[e] = i;
+};
+function Bt(t, e) {
+  return t === e ? t !== 0 || 1 / t === 1 / e : t !== t && e !== e;
+}
+var it = Array.isArray, nt = (t) => t instanceof Map, rt = (t) => t instanceof Set, st = (t) => typeof t == "object", C = (t) => typeof t == "function", lt = (t) => typeof t == "boolean";
+function Ht(t) {
+  const e = +t;
+  return Number.isInteger(e) && String(e) === t;
+}
+var qt = (t) => st(t) ? t?.[_] : null, p = (t) => t.copy_ || t.base_, Gt = (t) => {
+  const e = qt(t);
+  return e ? e.copy_ ?? e.base_ : t;
+}, vt = (t) => t.modified_ ? t.copy_ : t.base_;
+function _t(t, e) {
+  if (nt(t))
+    return new Map(t);
+  if (rt(t))
+    return new Set(t);
+  if (it(t))
+    return Array[et].slice.call(t);
+  const i = Tt(t);
+  if (e === !0 || e === "class_only" && !i) {
+    const n = D.getOwnPropertyDescriptors(t);
+    delete n[_];
+    let o = Reflect.ownKeys(n);
+    for (let c = 0; c < o.length; c++) {
+      const l = o[c], u = n[l];
+      u[W] === !1 && (u[W] = !0, u[dt] = !0), (u.get || u.set) && (n[l] = {
+        [dt]: !0,
+        [W]: !0,
+        // could live with !!desc.set as well here...
+        [Y]: u[Y],
+        [R]: t[l]
+      });
+    }
+    return D.create(k(t), n);
+  } else {
+    const n = k(t);
+    if (n !== null && i)
+      return { ...t };
+    const o = D.create(n);
+    return D.assign(o, t);
+  }
+}
+function Pt(t, e = !1) {
+  return ot(t) || V(t) || !E(t) || (q(t) > 1 && D.defineProperties(t, {
+    set: G,
+    add: G,
+    clear: G,
+    delete: G
+  }), D.freeze(t), e && H(
+    t,
+    (i, n) => {
+      Pt(n, !0);
+    },
+    !1
+  )), t;
+}
+function Wt() {
+  M(2);
+}
+var G = {
+  [R]: Wt
+};
+function ot(t) {
+  return t === null || !st(t) ? !0 : D.isFrozen(t);
+}
+var U = "MapSet", pt = "Patches", yt = "ArrayMethods", Q = {};
+function A(t) {
+  const e = Q[t];
+  return e || M(0, t), e;
+}
+var wt = (t) => !!Q[t];
+function Vt(t, e) {
+  Q[t] || (Q[t] = e);
+}
+var j, X = () => j, $t = (t, e) => ({
+  drafts_: [],
+  parent_: t,
+  immer_: e,
+  // Whenever the modified draft contains a draft from another scope, we
+  // need to prevent auto-freezing so the unowned draft can be finalized.
+  canAutoFreeze_: !0,
+  unfinalizedDrafts_: 0,
+  handledSet_: /* @__PURE__ */ new Set(),
+  processedForPatches_: /* @__PURE__ */ new Set(),
+  mapSetPlugin_: wt(U) ? A(U) : void 0,
+  arrayMethodsPlugin_: wt(yt) ? A(yt) : void 0
+});
+function Et(t, e) {
+  e && (t.patchPlugin_ = A(pt), t.patches_ = [], t.inversePatches_ = [], t.patchListener_ = e);
+}
+function mt(t) {
+  gt(t), t.drafts_.forEach(Kt), t.drafts_ = null;
+}
+function gt(t) {
+  t === j && (j = t.parent_);
+}
+var Ot = (t) => j = $t(j, t);
+function Kt(t) {
+  const e = t[_];
+  e.type_ === 0 || e.type_ === 1 ? e.revoke_() : e.revoked_ = !0;
+}
+function It(t, e) {
+  e.unfinalizedDrafts_ = e.drafts_.length;
+  const i = e.drafts_[0];
+  if (t !== void 0 && t !== i) {
+    i[_].modified_ && (mt(e), M(4)), E(t) && (t = bt(e, t));
+    const { patchPlugin_: o } = e;
+    o && o.generateReplacementPatches_(
+      i[_].base_,
+      t,
+      e
+    );
+  } else
+    t = bt(e, i);
+  return Yt(e, t, !0), mt(e), e.patches_ && e.patchListener_(e.patches_, e.inversePatches_), t !== zt ? t : void 0;
+}
+function bt(t, e) {
+  if (ot(e))
+    return e;
+  const i = e[_];
+  if (!i)
+    return Z(e, t.handledSet_, t);
+  if (!at(i, t))
+    return e;
+  if (!i.modified_)
+    return i.base_;
+  if (!i.finalized_) {
+    const { callbacks_: n } = i;
+    if (n)
+      for (; n.length > 0; )
+        n.pop()(t);
+    kt(i, t);
+  }
+  return i.copy_;
+}
+function Yt(t, e, i = !1) {
+  !t.parent_ && t.immer_.autoFreeze_ && t.canAutoFreeze_ && Pt(e, i);
+}
+function Ct(t) {
+  t.finalized_ = !0, t.scope_.unfinalizedDrafts_--;
+}
+var at = (t, e) => t.scope_ === e, Jt = [];
+function At(t, e, i, n) {
+  const o = p(t), c = t.type_;
+  if (n !== void 0 && ht(o, n, c) === e) {
+    J(o, n, i, c);
+    return;
+  }
+  if (!t.draftLocations_) {
+    const u = t.draftLocations_ = /* @__PURE__ */ new Map();
+    H(o, (a, r) => {
+      if (V(r)) {
+        const s = u.get(r) || [];
+        s.push(a), u.set(r, s);
+      }
+    });
+  }
+  const l = t.draftLocations_.get(e) ?? Jt;
+  for (const u of l)
+    J(o, u, i, c);
+}
+function Qt(t, e, i) {
+  t.callbacks_.push(function(o) {
+    const c = e;
+    if (!c || !at(c, o))
+      return;
+    o.mapSetPlugin_?.fixSetContents(c);
+    const l = vt(c);
+    At(t, c.draft_ ?? c, l, i), kt(c, o);
+  });
+}
+function kt(t, e) {
+  if (t.modified_ && !t.finalized_ && (t.type_ === 3 || t.type_ === 1 && t.allIndicesReassigned_ || (t.assigned_?.size ?? 0) > 0)) {
+    const { patchPlugin_: n } = e;
+    if (n) {
+      const o = n.getPath(t);
+      o && n.generatePatches_(t, o, e);
+    }
+    Ct(t);
+  }
+}
+function St(t, e, i) {
+  const { scope_: n } = t;
+  if (V(i)) {
+    const o = i[_];
+    at(o, n) && o.callbacks_.push(function() {
+      N(t);
+      const l = vt(o);
+      At(t, i, l, e);
+    });
+  } else E(i) && t.callbacks_.push(function() {
+    const c = p(t);
+    t.type_ === 3 ? c.has(i) && Z(i, n.handledSet_, n) : ht(c, e, t.type_) === i && n.drafts_.length > 1 && (t.assigned_.get(e) ?? !1) === !0 && t.copy_ && Z(
+      ht(t.copy_, e, t.type_),
+      n.handledSet_,
+      n
+    );
+  });
+}
+function Z(t, e, i) {
+  return !i.immer_.autoFreeze_ && i.unfinalizedDrafts_ < 1 || V(t) || e.has(t) || !E(t) || ot(t) || (e.add(t), H(t, (n, o) => {
+    if (V(o)) {
+      const c = o[_];
+      if (at(c, i)) {
+        const l = vt(c);
+        J(t, n, l, t.type_), Ct(c);
+      }
+    } else E(o) && Z(o, e, i);
+  })), t;
+}
+function Xt(t, e) {
+  const i = it(t), n = {
+    type_: i ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: e ? e.scope_ : X(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    // actually instantiated in `prepareCopy()`
+    assigned_: void 0,
+    // The parent draft state.
+    parent_: e,
+    // The base state.
+    base_: t,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1,
+    // `callbacks` actually gets assigned in `createProxy`
+    callbacks_: void 0
+  };
+  let o = n, c = tt;
+  i && (o = [n], c = L);
+  const { revoke: l, proxy: u } = Proxy.revocable(o, c);
+  return n.draft_ = u, n.revoke_ = l, [u, n];
+}
+var tt = {
+  get(t, e) {
+    if (e === _)
+      return t;
+    let i = t.scope_.arrayMethodsPlugin_;
+    const n = t.type_ === 1 && typeof e == "string";
+    if (n && i?.isArrayOperationMethod(e))
+      return i.createMethodInterceptor(t, e);
+    const o = p(t);
+    if (!Dt(o, e, t.type_))
+      return Zt(t, o, e);
+    const c = o[e];
+    if (t.finalized_ || !E(c) || n && t.operationMethod && i?.isMutatingArrayMethod(
+      t.operationMethod
+    ) && Ht(e))
+      return c;
+    if (c === ft(t.base_, e)) {
+      N(t);
+      const l = t.type_ === 1 ? +e : e, u = B(t.scope_, c, t, l);
+      return t.copy_[l] = u;
+    }
+    return c;
+  },
+  has(t, e) {
+    return e in p(t);
+  },
+  ownKeys(t) {
+    return Reflect.ownKeys(p(t));
+  },
+  set(t, e, i) {
+    const n = Ft(p(t), e);
+    if (n?.set)
+      return n.set.call(t.draft_, i), !0;
+    if (!t.modified_) {
+      const o = ft(p(t), e), c = o?.[_];
+      if (c && c.base_ === i)
+        return t.copy_[e] = i, t.assigned_.set(e, !1), !0;
+      if (Bt(i, o) && (i !== void 0 || Dt(t.base_, e, t.type_)))
+        return !0;
+      N(t), O(t);
+    }
+    return t.copy_[e] === i && // special case: handle new props with value 'undefined'
+    (i !== void 0 || e in t.copy_) || // special case: NaN
+    Number.isNaN(i) && Number.isNaN(t.copy_[e]) || (t.copy_[e] = i, t.assigned_.set(e, !0), St(t, e, i)), !0;
+  },
+  deleteProperty(t, e) {
+    return N(t), ft(t.base_, e) !== void 0 || e in t.base_ ? (t.assigned_.set(e, !1), O(t)) : t.assigned_.delete(e), t.copy_ && delete t.copy_[e], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(t, e) {
+    const i = p(t), n = Reflect.getOwnPropertyDescriptor(i, e);
+    return n && {
+      [W]: !0,
+      [dt]: t.type_ !== 1 || e !== "length",
+      [Y]: n[Y],
+      [R]: i[e]
+    };
+  },
+  defineProperty() {
+    M(11);
+  },
+  getPrototypeOf(t) {
+    return k(t.base_);
+  },
+  setPrototypeOf() {
+    M(12);
+  }
+}, L = {};
+for (let t in tt) {
+  let e = tt[t];
+  L[t] = function() {
+    const i = arguments;
+    return i[0] = i[0][0], e.apply(this, i);
+  };
+}
+L.deleteProperty = function(t, e) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(e)) && M(13), L.set.call(this, t, e, void 0);
+};
+L.set = function(t, e, i) {
+  return process.env.NODE_ENV !== "production" && e !== "length" && isNaN(parseInt(e)) && M(14), tt.set.call(this, t[0], e, i, t[0]);
+};
+function ft(t, e) {
+  const i = t[_];
+  return (i ? p(i) : t)[e];
+}
+function Zt(t, e, i) {
+  const n = Ft(e, i);
+  return n ? R in n ? n[R] : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    n.get?.call(t.draft_)
+  ) : void 0;
+}
+function Ft(t, e) {
+  if (!(e in t))
+    return;
+  let i = k(t);
+  for (; i; ) {
+    const n = Object.getOwnPropertyDescriptor(i, e);
+    if (n)
+      return n;
+    i = k(i);
+  }
+}
+function O(t) {
+  t.modified_ || (t.modified_ = !0, t.parent_ && O(t.parent_));
+}
+function N(t) {
+  t.copy_ || (t.assigned_ = /* @__PURE__ */ new Map(), t.copy_ = _t(
+    t.base_,
+    t.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var te = class {
+  constructor(t) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !1, this.produce = (e, i, n) => {
+      if (C(e) && !C(i)) {
+        const c = i;
+        i = e;
+        const l = this;
+        return function(a = c, ...r) {
+          return l.produce(a, (s) => i.call(this, s, ...r));
+        };
+      }
+      C(i) || M(6), n !== void 0 && !C(n) && M(7);
+      let o;
+      if (E(e)) {
+        const c = Ot(this), l = B(c, e, void 0);
+        let u = !0;
+        try {
+          o = i(l), u = !1;
+        } finally {
+          u ? mt(c) : gt(c);
+        }
+        return Et(c, n), It(o, c);
+      } else if (!e || !st(e)) {
+        if (o = i(e), o === void 0 && (o = e), o === zt && (o = void 0), this.autoFreeze_ && Pt(o, !0), n) {
+          const c = [], l = [];
+          A(pt).generateReplacementPatches_(e, o, {
+            patches_: c,
+            inversePatches_: l
+          }), n(c, l);
+        }
+        return o;
+      } else
+        M(1, e);
+    }, this.produceWithPatches = (e, i) => {
+      if (C(e))
+        return (l, ...u) => this.produceWithPatches(l, (a) => e(a, ...u));
+      let n, o;
+      return [this.produce(e, i, (l, u) => {
+        n = l, o = u;
+      }), n, o];
+    }, lt(t?.autoFreeze) && this.setAutoFreeze(t.autoFreeze), lt(t?.useStrictShallowCopy) && this.setUseStrictShallowCopy(t.useStrictShallowCopy), lt(t?.useStrictIteration) && this.setUseStrictIteration(t.useStrictIteration);
+  }
+  createDraft(t) {
+    E(t) || M(8), V(t) && (t = ee(t));
+    const e = Ot(this), i = B(e, t, void 0);
+    return i[_].isManual_ = !0, gt(e), i;
+  }
+  finishDraft(t, e) {
+    const i = t && t[_];
+    (!i || !i.isManual_) && M(9);
+    const { scope_: n } = i;
+    return Et(n, e), It(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(t) {
+    this.autoFreeze_ = t;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(t) {
+    this.useStrictShallowCopy_ = t;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(t) {
+    this.useStrictIteration_ = t;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(t, e) {
+    let i;
+    for (i = e.length - 1; i >= 0; i--) {
+      const o = e[i];
+      if (o.path.length === 0 && o.op === "replace") {
+        t = o.value;
+        break;
+      }
+    }
+    i > -1 && (e = e.slice(i + 1));
+    const n = A(pt).applyPatches_;
+    return V(t) ? n(t, e) : this.produce(
+      t,
+      (o) => n(o, e)
+    );
+  }
+};
+function B(t, e, i, n) {
+  const [o, c] = nt(e) ? A(U).proxyMap_(e, i) : rt(e) ? A(U).proxySet_(e, i) : Xt(e, i);
+  return (i?.scope_ ?? X()).drafts_.push(o), c.callbacks_ = i?.callbacks_ ?? [], c.key_ = n, i && n !== void 0 ? Qt(i, c, n) : c.callbacks_.push(function(a) {
+    a.mapSetPlugin_?.fixSetContents(c);
+    const { patchPlugin_: r } = a;
+    c.modified_ && r && r.generatePatches_(c, [], a);
+  }), o;
+}
+function ee(t) {
+  return V(t) || M(10, t), Nt(t);
+}
+function Nt(t) {
+  if (!E(t) || ot(t))
+    return t;
+  const e = t[_];
+  let i, n = !0;
+  if (e) {
+    if (!e.modified_)
+      return e.base_;
+    e.finalized_ = !0, i = _t(t, e.scope_.immer_.useStrictShallowCopy_), n = e.scope_.immer_.shouldUseStrictIteration();
+  } else
+    i = _t(t, !0);
+  return H(
+    i,
+    (o, c) => {
+      J(i, o, Nt(c));
+    },
+    n
+  ), e && (e.finalized_ = !1), i;
+}
+function ie() {
+  class t extends Map {
+    constructor(r, s) {
+      super(), this[_] = {
+        type_: 2,
+        parent_: s,
+        scope_: s ? s.scope_ : X(),
+        modified_: !1,
+        finalized_: !1,
+        copy_: void 0,
+        assigned_: void 0,
+        base_: r,
+        draft_: this,
+        isManual_: !1,
+        revoked_: !1,
+        callbacks_: []
+      };
+    }
+    get size() {
+      return p(this[_]).size;
+    }
+    has(r) {
+      return p(this[_]).has(r);
+    }
+    set(r, s) {
+      const f = this[_];
+      return l(f), (!p(f).has(r) || p(f).get(r) !== s) && (i(f), O(f), f.assigned_.set(r, !0), f.copy_.set(r, s), f.assigned_.set(r, !0), St(f, r, s)), this;
+    }
+    delete(r) {
+      if (!this.has(r))
+        return !1;
+      const s = this[_];
+      return l(s), i(s), O(s), s.base_.has(r) ? s.assigned_.set(r, !1) : s.assigned_.delete(r), s.copy_.delete(r), !0;
+    }
+    clear() {
+      const r = this[_];
+      l(r), p(r).size && (i(r), O(r), r.assigned_ = /* @__PURE__ */ new Map(), H(r.base_, (s) => {
+        r.assigned_.set(s, !1);
+      }), r.copy_.clear());
+    }
+    forEach(r, s) {
+      const f = this[_];
+      p(f).forEach((h, v, g) => {
+        r.call(s, this.get(v), v, this);
+      });
+    }
+    get(r) {
+      const s = this[_];
+      l(s);
+      const f = p(s).get(r);
+      if (s.finalized_ || !E(f) || f !== s.base_.get(r))
+        return f;
+      const h = B(s.scope_, f, s, r);
+      return i(s), s.copy_.set(r, h), h;
+    }
+    keys() {
+      return p(this[_]).keys();
+    }
+    values() {
+      const r = this.keys();
+      return {
+        [Symbol.iterator]: () => this.values(),
+        next: () => {
+          const s = r.next();
+          return s.done ? s : {
+            done: !1,
+            value: this.get(s.value)
+          };
+        }
+      };
+    }
+    entries() {
+      const r = this.keys();
+      return {
+        [Symbol.iterator]: () => this.entries(),
+        next: () => {
+          const s = r.next();
+          if (s.done)
+            return s;
+          const f = this.get(s.value);
+          return {
+            done: !1,
+            value: [s.value, f]
+          };
+        }
+      };
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  }
+  function e(a, r) {
+    const s = new t(a, r);
+    return [s, s[_]];
+  }
+  function i(a) {
+    a.copy_ || (a.assigned_ = /* @__PURE__ */ new Map(), a.copy_ = new Map(a.base_));
+  }
+  class n extends Set {
+    constructor(r, s) {
+      super(), this[_] = {
+        type_: 3,
+        parent_: s,
+        scope_: s ? s.scope_ : X(),
+        modified_: !1,
+        finalized_: !1,
+        copy_: void 0,
+        base_: r,
+        draft_: this,
+        drafts_: /* @__PURE__ */ new Map(),
+        revoked_: !1,
+        isManual_: !1,
+        assigned_: void 0,
+        callbacks_: []
+      };
+    }
+    get size() {
+      return p(this[_]).size;
+    }
+    has(r) {
+      const s = this[_];
+      return l(s), s.copy_ ? !!(s.copy_.has(r) || s.drafts_.has(r) && s.copy_.has(s.drafts_.get(r))) : s.base_.has(r);
+    }
+    add(r) {
+      const s = this[_];
+      return l(s), this.has(r) || (c(s), O(s), s.copy_.add(r), St(s, r, r)), this;
+    }
+    delete(r) {
+      if (!this.has(r))
+        return !1;
+      const s = this[_];
+      return l(s), c(s), O(s), s.copy_.delete(r) || (s.drafts_.has(r) ? s.copy_.delete(s.drafts_.get(r)) : (
+        /* istanbul ignore next */
+        !1
+      ));
+    }
+    clear() {
+      const r = this[_];
+      l(r), p(r).size && (c(r), O(r), r.copy_.clear());
+    }
+    values() {
+      const r = this[_];
+      return l(r), c(r), r.copy_.values();
+    }
+    entries() {
+      const r = this[_];
+      return l(r), c(r), r.copy_.entries();
+    }
+    keys() {
+      return this.values();
+    }
+    [Symbol.iterator]() {
+      return this.values();
+    }
+    forEach(r, s) {
+      const f = this.values();
+      let h = f.next();
+      for (; !h.done; )
+        r.call(s, h.value, h.value, this), h = f.next();
+    }
+  }
+  function o(a, r) {
+    const s = new n(a, r);
+    return [s, s[_]];
+  }
+  function c(a) {
+    a.copy_ || (a.copy_ = /* @__PURE__ */ new Set(), a.base_.forEach((r) => {
+      if (E(r)) {
+        const s = B(a.scope_, r, a, r);
+        a.drafts_.set(r, s), a.copy_.add(s);
+      } else
+        a.copy_.add(r);
+    }));
+  }
+  function l(a) {
+    a.revoked_ && M(3, JSON.stringify(p(a)));
+  }
+  function u(a) {
+    if (a.type_ === 3 && a.copy_) {
+      const r = new Set(a.copy_);
+      a.copy_.clear(), r.forEach((s) => {
+        a.copy_.add(Gt(s));
+      });
+    }
+  }
+  Vt(U, { proxyMap_: e, proxySet_: o, fixSetContents: u });
+}
+function ne() {
+  const t = /* @__PURE__ */ new Set(["shift", "unshift"]), e = /* @__PURE__ */ new Set(["push", "pop"]), i = /* @__PURE__ */ new Set([
+    ...e,
+    ...t
+  ]), n = /* @__PURE__ */ new Set(["reverse", "sort"]), o = /* @__PURE__ */ new Set([
+    ...i,
+    ...n,
+    "splice"
+  ]), c = /* @__PURE__ */ new Set(["find", "findLast"]), l = /* @__PURE__ */ new Set([
+    "filter",
+    "slice",
+    "concat",
+    "flat",
+    ...c,
+    "findIndex",
+    "findLastIndex",
+    "some",
+    "every",
+    "indexOf",
+    "lastIndexOf",
+    "includes",
+    "join",
+    "toString",
+    "toLocaleString"
+  ]);
+  function u(d) {
+    return o.has(d);
+  }
+  function a(d) {
+    return l.has(d);
+  }
+  function r(d) {
+    return u(d) || a(d);
+  }
+  function s(d, y) {
+    d.operationMethod = y;
+  }
+  function f(d) {
+    d.operationMethod = void 0;
+  }
+  function h(d, y, w = !0) {
+    N(d);
+    const m = y();
+    return O(d), w && d.assigned_.set("length", !0), m;
+  }
+  function v(d) {
+    d.allIndicesReassigned_ = !0;
+  }
+  function g(d, y) {
+    return d < 0 ? Math.max(y + d, 0) : Math.min(d, y);
+  }
+  function I(d, y, w) {
+    return h(d, () => {
+      const m = d.copy_[y](...w);
+      return t.has(y) && v(d), i.has(y) ? m : d.draft_;
+    });
+  }
+  function xt(d, y, w) {
+    return h(
+      d,
+      () => (d.copy_[y](...w), v(d), d.draft_),
+      !1
+    );
+  }
+  function Rt(d, y) {
+    return function(...m) {
+      const P = y;
+      s(d, P);
+      try {
+        if (u(P)) {
+          if (i.has(P))
+            return I(d, P, m);
+          if (n.has(P))
+            return xt(d, P, m);
+          if (P === "splice") {
+            const b = h(
+              d,
+              () => d.copy_.splice(...m)
+            );
+            return v(d), b;
+          }
+        } else
+          return Ut(d, P, m);
+      } finally {
+        f(d);
+      }
+    };
+  }
+  function Ut(d, y, w) {
+    const m = p(d);
+    if (y === "filter") {
+      const P = w[0], b = [];
+      for (let z = 0; z < m.length; z++)
+        P(m[z], z, m) && b.push(d.draft_[z]);
+      return b;
+    }
+    if (c.has(y)) {
+      const P = w[0], b = y === "find", z = b ? 1 : -1, ct = b ? 0 : m.length - 1;
+      for (let T = ct; T >= 0 && T < m.length; T += z)
+        if (P(m[T], T, m))
+          return d.draft_[T];
+      return;
+    }
+    if (y === "slice") {
+      const P = w[0] ?? 0, b = w[1] ?? m.length, z = g(P, m.length), ct = g(b, m.length), T = [];
+      for (let ut = z; ut < ct; ut++)
+        T.push(d.draft_[ut]);
+      return T;
+    }
+    return m[y](...w);
+  }
+  Vt(yt, {
+    createMethodInterceptor: Rt,
+    isArrayOperationMethod: r,
+    isMutatingArrayMethod: u
+  });
+}
+var re = new te(), F = re.produce;
+let se = 0;
+function oe() {
+  return se++;
+}
+class x {
+  constructor(e, i) {
+    this.controller = e, this.path = i, this.id = oe(), this._isTouched = !1, this._isDirty = !1;
+  }
+  get value() {
+    return S.getValue(
+      this.controller._data,
+      this.path
+    );
+  }
+  get boundElement() {
+    return this.target;
+  }
+  get issues() {
+    return this.controller._issues.filter(
+      (e) => e.path?.join(".") === this.path
+    );
+  }
+  get isTouched() {
+    return this._isTouched;
+  }
+  get isDirty() {
+    return this._isDirty;
+  }
+  get isValid() {
+    return this.issues.length === 0;
+  }
+  _setTouched(e) {
+    const i = this._isTouched !== e;
+    this._isTouched = e, i && this.controller.events.emit("fieldTouchUpdated", this.path);
+  }
+  _setDirty(e) {
+    const i = this._isDirty !== e;
+    this._isDirty = e, i && this.controller.events.emit("fieldDirtyUpdated", this.path);
+  }
+  bindElement(e) {
+    e != null ? this.controller.events.emit("elementBound", this.path, e) : this.controller.events.emit("elementUnbound", this.path), this.target = e;
+  }
+  static ensureImmerability(e) {
+    if (typeof e != "object" || e === null) return;
+    const i = Object.getPrototypeOf(e);
+    if (i === Object.prototype || i === null) return;
+    const n = i.constructor;
+    typeof n == "function" && (e instanceof Date || e instanceof RegExp || e instanceof Map || e instanceof Set || e instanceof WeakMap || e instanceof WeakSet || ArrayBuffer.isView(e) || n[$] !== !0 && (n[$] = !0));
+  }
+  setValue(e, i) {
+    return this.modifyValue(() => e, i);
+  }
+  modifyValue(e, i) {
+    (i?.shouldTouch == null || i?.shouldTouch) && this.touch();
+    const n = S.getValue(
+      this.controller._initialData,
+      this.path
+    ), o = S.getValue(
+      this.controller._data,
+      this.path
+    );
+    x.ensureImmerability(n), x.ensureImmerability(o), this.controller._data = F(this.controller._data, (a) => {
+      S.modifyValue(
+        a,
+        this.path,
+        (r) => e(r, this)
+      );
+    });
+    const c = S.getValue(
+      this.controller._data,
+      this.path
+    );
+    x.ensureImmerability(c);
+    const l = (a, r) => {
+      if (typeof a != "object" || typeof r != "object") return;
+      const s = a.constructor, f = r.constructor;
+      if (s === f)
+        return this.controller.equalityComparators?.[s]?.(a, r);
+    };
+    if (!S.deepEqual(o, c, l) && this.controller.events.emit(
+      "valueChanged",
+      this.path,
+      c,
+      o
+    ), i?.shouldMarkDirty == null || i?.shouldMarkDirty) {
+      const a = !S.deepEqual(n, c, l);
+      this._setDirty(a);
+    }
+  }
+  reset() {
+    this._setTouched(!1), this._setDirty(!1);
+  }
+  touch() {
+    this._setTouched(!0);
+  }
+  markDirty() {
+    this.touch(), this._setDirty(!0);
+  }
+  triggerValidation() {
+    this.controller.validateField(this.path);
+  }
+  focus(e) {
+    (e?.shouldTouch == null || e.shouldTouch) && this.target?.addEventListener("focus", () => this.touch(), {
+      once: !0
+    }), this.target?.scrollIntoView(), this.target?.focus();
+  }
+}
+let ae = () => ({
+  emit(t, ...e) {
+    for (let i = this.events[t] || [], n = 0, o = i.length; n < o; n++)
+      i[n](...e);
+  },
+  events: {},
+  on(t, e) {
+    return (this.events[t] ||= []).push(e), () => {
+      this.events[t] = this.events[t]?.filter((i) => e !== i);
+    };
+  }
+});
+function ce(t, e) {
+  let i = [];
+  for (let n = t.length - 1; n >= 0; n--)
+    e(t[n]) && i.push(n);
+  i.forEach((n) => t.splice(n, 1));
+}
+ie();
+ne();
+class ue {
+  constructor(e) {
+    this._status = "idle", this._fields = /* @__PURE__ */ new Map(), this._issues = [], this.events = ae(), this.validationSchema = e.validationSchema, this.equalityComparators = e.equalityComparators, this._initialData = e.initialData ?? {}, this._data = F(this._initialData, () => {
+    });
+  }
+  get isDirty() {
+    for (const e of this._fields.values())
+      if (e.isDirty) return !0;
+    return !1;
+  }
+  get isValid() {
+    return this._issues.length === 0;
+  }
+  get isSubmitting() {
+    return this._status === "submitting";
+  }
+  setStatus(e) {
+    if (e === this._status) return;
+    const i = this._status;
+    this._status = e, this.events.emit("statusChanged", e, i);
+  }
+  _unsafeSetFieldValue(e, i, n) {
+    n?.updateInitialValue && (this._initialData = F(this._initialData, (o) => {
+      S.setValue(o, e, i);
+    })), this._data = F(this._data, (o) => {
+      S.setValue(o, e, i);
+    });
+  }
+  bindField(e, i) {
+    const n = new x(this, e);
+    return console.log("Binding", e, i?.defaultValue, n.id), this._fields.set(e, n), this.events.emit("fieldBound", e), i?.defaultValue != null && this._unsafeSetFieldValue(e, i.defaultValue, {
+      updateInitialValue: !0
+    }), i?.domElement != null && n.bindElement(i.domElement), n;
+  }
+  unbindField(e) {
+    this._fields.delete(e), this.events.emit("fieldUnbound", e);
+  }
+  // TODO: Add an option to keep dirty/touched fields as they are
+  reset(e) {
+    this.setStatus("idle"), this._data = this._initialData, this._issues = [];
+    for (const i of this._fields.values())
+      i.reset();
+    e != null && (this._initialData = e, this._data = F(this._initialData, () => {
+    }));
+  }
+  getField(e, i) {
+    let n = this._fields.get(e);
+    return n == null && i?.bindIfMissing && (n = this.bindField(e)), n;
+  }
+  clearFieldIssues(e) {
+    this._issues = this._issues.filter((i) => i.path == null ? !0 : i.path.join(".") !== e);
+  }
+  async applyValidation(e, i) {
+    const n = S.diff(
+      this._issues,
+      e.issues ?? [],
+      S.deepEqual,
+      (o) => o.path == null ? !1 : o.path.join(".") === i
+    );
+    ce(this._issues, (o) => n.removed.includes(o)), n.added.forEach((o) => this._issues.push(o)), (n.added.length !== 0 || n.removed.length !== 0) && this.events.emit("validationIssuesUpdated", i);
+  }
+  async validateField(e) {
+    if (this._status !== "idle" || this.validationSchema == null) return;
+    this.setStatus("validating"), this.getField(e, { bindIfMissing: !0 });
+    const i = await this.validationSchema["~standard"].validate(
+      this._data
+    );
+    this.events.emit("validationTriggered", e), this.applyValidation(i, e), this.setStatus("idle");
+  }
+  async validateForm() {
+    if (this._status !== "idle" || this.validationSchema == null) return;
+    this.setStatus("validating");
+    const e = await this.validationSchema["~standard"].validate(
+      this._data
+    );
+    for (const n of this._fields.keys())
+      this.events.emit("validationTriggered", n), this.applyValidation(e, n);
+    S.diff(this._issues, e.issues ?? [], S.deepEqual).added.forEach((n) => this._issues.push(n)), this.setStatus("idle");
+  }
+  createSubmitHandler(e, i) {
+    return async (n) => {
+      if (n?.preventDefault(), this._status !== "idle") return;
+      const o = new AbortController();
+      if (await this.validateForm(), this._issues.length === 0) {
+        this.setStatus("submitting"), await e?.(this._data, n, o.signal), this.setStatus("idle");
+        return;
+      }
+      for (const c of this._issues) {
+        if (c.path == null) continue;
+        const l = c.path.join("."), u = this.getField(l);
+        if (u != null && u.boundElement != null) {
+          u.focus();
+          break;
+        }
+      }
+      await i?.(this._issues, n, o.signal), this.setStatus("idle");
+    };
+  }
+}
+export {
+  S as Field,
+  ue as FormController,
+  x as FormField
+};
+//# sourceMappingURL=index.js.map