@reformer/core 1.1.0-beta.7 → 1.1.0-beta.8

package/dist/behaviors-BRaiR-UY.js

@@ -0,0 +1,528 @@
+import { a as S, b as I, B as L } from "./registry-helpers-BfCZcMkO.js";
+var z = Symbol.for("preact-signals");
+function N() {
+  if (w > 1)
+    w--;
+  else {
+    for (var e, t = !1; P !== void 0; ) {
+      var i = P;
+      for (P = void 0, V++; i !== void 0; ) {
+        var n = i.o;
+        if (i.o = void 0, i.f &= -3, !(8 & i.f) && A(i)) try {
+          i.c();
+        } catch (o) {
+          t || (e = o, t = !0);
+        }
+        i = n;
+      }
+    }
+    if (V = 0, w--, t) throw e;
+  }
+}
+var r = void 0;
+function U(e) {
+  var t = r;
+  r = void 0;
+  try {
+    return e();
+  } finally {
+    r = t;
+  }
+}
+var P = void 0, w = 0, V = 0, B = 0;
+function C(e) {
+  if (r !== void 0) {
+    var t = e.n;
+    if (t === void 0 || t.t !== r)
+      return t = { i: 0, S: e, p: r.s, n: void 0, t: r, e: void 0, x: void 0, r: t }, r.s !== void 0 && (r.s.n = t), r.s = t, e.n = t, 32 & r.f && e.S(t), t;
+    if (t.i === -1)
+      return t.i = 0, t.n !== void 0 && (t.n.p = t.p, t.p !== void 0 && (t.p.n = t.n), t.p = r.s, t.n = void 0, r.s.n = t, r.s = t), t;
+  }
+}
+function d(e, t) {
+  this.v = e, this.i = 0, this.n = void 0, this.t = void 0, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+d.prototype.brand = z;
+d.prototype.h = function() {
+  return !0;
+};
+d.prototype.S = function(e) {
+  var t = this, i = this.t;
+  i !== e && e.e === void 0 && (e.x = i, this.t = e, i !== void 0 ? i.e = e : U(function() {
+    var n;
+    (n = t.W) == null || n.call(t);
+  }));
+};
+d.prototype.U = function(e) {
+  var t = this;
+  if (this.t !== void 0) {
+    var i = e.e, n = e.x;
+    i !== void 0 && (i.x = n, e.e = void 0), n !== void 0 && (n.e = i, e.x = void 0), e === this.t && (this.t = n, n === void 0 && U(function() {
+      var o;
+      (o = t.Z) == null || o.call(t);
+    }));
+  }
+};
+d.prototype.subscribe = function(e) {
+  var t = this;
+  return y(function() {
+    var i = t.value, n = r;
+    r = void 0;
+    try {
+      e(i);
+    } finally {
+      r = n;
+    }
+  }, { name: "sub" });
+};
+d.prototype.valueOf = function() {
+  return this.value;
+};
+d.prototype.toString = function() {
+  return this.value + "";
+};
+d.prototype.toJSON = function() {
+  return this.value;
+};
+d.prototype.peek = function() {
+  var e = r;
+  r = void 0;
+  try {
+    return this.value;
+  } finally {
+    r = e;
+  }
+};
+Object.defineProperty(d.prototype, "value", { get: function() {
+  var e = C(this);
+  return e !== void 0 && (e.i = this.i), this.v;
+}, set: function(e) {
+  if (e !== this.v) {
+    if (V > 100) throw new Error("Cycle detected");
+    this.v = e, this.i++, B++, w++;
+    try {
+      for (var t = this.t; t !== void 0; t = t.x) t.t.N();
+    } finally {
+      N();
+    }
+  }
+} });
+function ot(e, t) {
+  return new d(e, t);
+}
+function A(e) {
+  for (var t = e.s; t !== void 0; t = t.n) if (t.S.i !== t.i || !t.S.h() || t.S.i !== t.i) return !0;
+  return !1;
+}
+function W(e) {
+  for (var t = e.s; t !== void 0; t = t.n) {
+    var i = t.S.n;
+    if (i !== void 0 && (t.r = i), t.S.n = t, t.i = -1, t.n === void 0) {
+      e.s = t;
+      break;
+    }
+  }
+}
+function j(e) {
+  for (var t = e.s, i = void 0; t !== void 0; ) {
+    var n = t.p;
+    t.i === -1 ? (t.S.U(t), n !== void 0 && (n.n = t.n), t.n !== void 0 && (t.n.p = n)) : i = t, t.S.n = t.r, t.r !== void 0 && (t.r = void 0), t = n;
+  }
+  e.s = i;
+}
+function _(e, t) {
+  d.call(this, void 0), this.x = e, this.s = void 0, this.g = B - 1, this.f = 4, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+_.prototype = new d();
+_.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === B)) return !0;
+  if (this.g = B, this.f |= 1, this.i > 0 && !A(this))
+    return this.f &= -2, !0;
+  var e = r;
+  try {
+    W(this), r = this;
+    var t = this.x();
+    (16 & this.f || this.v !== t || this.i === 0) && (this.v = t, this.f &= -17, this.i++);
+  } catch (i) {
+    this.v = i, this.f |= 16, this.i++;
+  }
+  return r = e, j(this), this.f &= -2, !0;
+};
+_.prototype.S = function(e) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (var t = this.s; t !== void 0; t = t.n) t.S.S(t);
+  }
+  d.prototype.S.call(this, e);
+};
+_.prototype.U = function(e) {
+  if (this.t !== void 0 && (d.prototype.U.call(this, e), this.t === void 0)) {
+    this.f &= -33;
+    for (var t = this.s; t !== void 0; t = t.n) t.S.U(t);
+  }
+};
+_.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var e = this.t; e !== void 0; e = e.x) e.t.N();
+  }
+};
+Object.defineProperty(_.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var e = C(this);
+  if (this.h(), e !== void 0 && (e.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} });
+function rt(e, t) {
+  return new _(e, t);
+}
+function k(e) {
+  var t = e.u;
+  if (e.u = void 0, typeof t == "function") {
+    w++;
+    var i = r;
+    r = void 0;
+    try {
+      t();
+    } catch (n) {
+      throw e.f &= -2, e.f |= 8, E(e), n;
+    } finally {
+      r = i, N();
+    }
+  }
+}
+function E(e) {
+  for (var t = e.s; t !== void 0; t = t.n) t.S.U(t);
+  e.x = void 0, e.s = void 0, k(e);
+}
+function J(e) {
+  if (r !== this) throw new Error("Out-of-order effect");
+  j(this), r = e, this.f &= -2, 8 & this.f && E(this), N();
+}
+function x(e, t) {
+  this.x = e, this.u = void 0, this.s = void 0, this.o = void 0, this.f = 32, this.name = t?.name;
+}
+x.prototype.c = function() {
+  var e = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    var t = this.x();
+    typeof t == "function" && (this.u = t);
+  } finally {
+    e();
+  }
+};
+x.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, k(this), W(this), w++;
+  var e = r;
+  return r = this, J.bind(this, e);
+};
+x.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.o = P, P = this);
+};
+x.prototype.d = function() {
+  this.f |= 8, 1 & this.f || E(this);
+};
+x.prototype.dispose = function() {
+  this.d();
+};
+function y(e, t) {
+  var i = new x(e, t);
+  try {
+    i.c();
+  } catch (o) {
+    throw i.d(), o;
+  }
+  var n = i.d.bind(i);
+  return n[Symbol.dispose] = n, n;
+}
+function O() {
+  return T("");
+}
+function T(e) {
+  return new Proxy(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    {},
+    {
+      get(t, i) {
+        if (i === "__path" || i === "__fieldPath")
+          return e || i;
+        if (i === "__key") {
+          const f = e.split(".");
+          return f[f.length - 1] || i;
+        }
+        const n = e ? `${e}.${i}` : i, o = {
+          __path: n,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          __key: i,
+          __formType: void 0,
+          __fieldType: void 0
+        };
+        return new Proxy(o, {
+          get(f, a) {
+            if (a === "__path" || a === "__fieldPath")
+              return n;
+            if (a === "__key")
+              return i;
+            if (a === "__formType" || a === "__fieldType")
+              return;
+            const h = `${n}.${a}`;
+            return T(h);
+          }
+        });
+      }
+    }
+  );
+}
+function F(e, t, i) {
+  const { debounce: n, immediate: o = !1 } = i || {}, f = (a, h, l) => {
+    const u = a.getFieldByPath(e.__path);
+    if (!u) return null;
+    if (o) {
+      const s = u.value.value;
+      t(s, h);
+    }
+    return y(() => {
+      const s = u.value.value;
+      l(() => {
+        t(s, h);
+      });
+    });
+  };
+  S().register(f, { debounce: n });
+}
+function q(e, t, i) {
+  const { when: n, fields: o = "all", transform: f, debounce: a } = i || {};
+  F(
+    e,
+    (h, l) => {
+      if (n) {
+        const c = l.form.getValue();
+        if (!n(c)) return;
+      }
+      const u = f ? f(h) : h, s = l.form.getFieldByPath(t.__path);
+      if (s)
+        if (o === "all" || !o)
+          s.setValue(u, { emitEvent: !1 });
+        else {
+          const c = {};
+          o.forEach((v) => {
+            h && typeof h == "object" && (c[v] = h[v]);
+          }), "patchValue" in s && s.patchValue(c);
+        }
+    },
+    { debounce: a }
+  );
+}
+function $(e, t, i) {
+  const { debounce: n, resetOnDisable: o = !1 } = i || {}, f = (a, h, l) => {
+    const u = a.getFieldByPath(e.__path);
+    return u ? y(() => {
+      const s = a.value.value;
+      l(() => {
+        t(s) ? u.enable() : (u.disable(), o && u.reset());
+      });
+    }) : null;
+  };
+  S().register(f, { debounce: n });
+}
+function G(e, t, i) {
+  $(e, (n) => !t(n), i);
+}
+function H(e, t, i, n) {
+  const { debounce: o, condition: f } = n || {}, a = (h, l, u) => {
+    const s = h.getFieldByPath(t.__path);
+    if (!s) return null;
+    const c = e.map((v) => h.getFieldByPath(v.__path)).filter((v) => v !== void 0);
+    return c.length === 0 ? null : y(() => {
+      const v = c.map((g) => g.value.value);
+      u(() => {
+        if (f) {
+          const b = h.getValue();
+          if (!f(b)) return;
+        }
+        const g = {};
+        e.forEach((b, Z) => {
+          const D = b.__path.split(".").pop() || b.__path;
+          g[D] = v[Z];
+        });
+        const m = i(g);
+        s.setValue(m, { emitEvent: !1 });
+      });
+    });
+  };
+  S().register(a, { debounce: o });
+}
+function K(e, t, i) {
+  const { debounce: n } = i || {}, o = (f, a, h) => {
+    const l = f.getFieldByPath(e.__path);
+    if (!l) return null;
+    const u = t.map((s) => f.getFieldByPath(s.__path)).filter((s) => s !== void 0);
+    return u.length === 0 ? null : y(() => {
+      u.forEach((s) => s.value.value), h(() => {
+        l.validate();
+      });
+    });
+  };
+  S().register(o, { debounce: n });
+}
+function Q(e, t, i) {
+  const { debounce: n, transform: o } = i || {}, f = (a, h, l) => {
+    const u = a.getFieldByPath(e.__path), s = a.getFieldByPath(t.__path);
+    if (!u || !s) return null;
+    let c = !1;
+    const v = y(() => {
+      const m = u.value.value;
+      c || l(() => {
+        c = !0;
+        const b = o ? o(m) : m;
+        s.setValue(b, { emitEvent: !1 }), c = !1;
+      });
+    }), g = y(() => {
+      const m = s.value.value;
+      c || l(() => {
+        c = !0, u.setValue(m, { emitEvent: !1 }), c = !1;
+      });
+    });
+    return () => {
+      v(), g();
+    };
+  };
+  S().register(f, { debounce: n });
+}
+function X(e, t, i) {
+  const { debounce: n, resetValue: o = null, onlyIfDirty: f = !1 } = i || {}, a = (h, l, u) => {
+    const s = h.getFieldByPath(e.__path);
+    return s ? y(() => {
+      const c = h.value.value;
+      u(() => {
+        if (t(c)) {
+          if (f && !s.dirty.value)
+            return;
+          s.setValue(o), s.markAsPristine(), s.markAsUntouched();
+        }
+      });
+    }) : null;
+  };
+  S().register(a, { debounce: n });
+}
+function R(e, t, i) {
+  const { onUserChangeOnly: n = !1, emitEvent: o = !0, debounce: f } = i || {};
+  F(
+    e,
+    (a, h) => {
+      const l = h.form.getFieldByPath(e.__path);
+      if (!l || n && !l.touched.value)
+        return;
+      const u = t(a);
+      u !== a && l.setValue(u, { emitEvent: o });
+    },
+    { debounce: f }
+  );
+}
+function p(e, t) {
+  return (i, n) => {
+    R(i, e, { ...t, ...n });
+  };
+}
+const Y = {
+  /** Перевести в верхний регистр */
+  toUpperCase: p((e) => e?.toUpperCase()),
+  /** Перевести в нижний регистр */
+  toLowerCase: p((e) => e?.toLowerCase()),
+  /** Удалить пробелы с краев */
+  trim: p((e) => e?.trim()),
+  /** Удалить все пробелы */
+  removeSpaces: p((e) => e?.replace(/\s/g, "")),
+  /** Оставить только цифры */
+  digitsOnly: p((e) => e?.replace(/\D/g, "")),
+  /** Округлить число */
+  round: p(
+    (e) => typeof e == "number" ? Math.round(e) : e
+  ),
+  /** Округлить до 2 знаков после запятой */
+  roundTo2: p(
+    (e) => typeof e == "number" ? Math.round(e * 100) / 100 : e
+  )
+};
+function M(e) {
+  if (!e)
+    return O();
+  const t = e.__path;
+  return tt(t);
+}
+function tt(e) {
+  return new Proxy({}, {
+    get(t, i) {
+      return typeof i == "symbol" ? void 0 : {
+        __path: e ? `${e}.${i}` : i,
+        __key: i
+      };
+    }
+  });
+}
+function et(e, t) {
+  const i = (Array.isArray(e) ? e : [e]).filter(Boolean), n = Array.isArray(t) ? t : [t];
+  for (const o of i) {
+    const f = M(o);
+    for (const a of n)
+      a(f);
+  }
+}
+function it(e, t, i) {
+  if (!e) return;
+  let n = !1;
+  F(
+    e,
+    (o, f) => {
+      if (!n && t(o)) {
+        const a = O();
+        i(a), n = !0;
+      }
+    },
+    { immediate: !0 }
+  );
+}
+const st = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BehaviorContextImpl: I,
+  BehaviorRegistry: L,
+  apply: et,
+  applyWhen: it,
+  computeFrom: H,
+  copyFrom: q,
+  createFieldPath: O,
+  createTransformer: p,
+  disableWhen: G,
+  enableWhen: $,
+  resetWhen: X,
+  revalidateWhen: K,
+  syncFields: Q,
+  toBehaviorFieldPath: M,
+  transformValue: R,
+  transformers: Y,
+  watchField: F
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  y as E,
+  et as a,
+  it as b,
+  O as c,
+  ot as d,
+  q as e,
+  $ as f,
+  G as g,
+  H as h,
+  st as i,
+  F as j,
+  X as k,
+  R as l,
+  p as m,
+  Y as n,
+  K as r,
+  Q as s,
+  M as t,
+  rt as w
+};

package/dist/behaviors.d.ts

@@ -1,2 +1,6 @@
-export * from './core/behavior/index'
-export {}
+/**
+ * Re-export behaviors from the main index to ensure single module instance.
+ * This prevents static registry isolation issues when consuming the library.
+ */
+export { behaviors as default } from './index';
+export * from './core/behavior';