@reformer/core 1.1.0 → 2.0.0-beta.3

package/dist/behaviors-DzYL8kY_.js

@@ -0,0 +1,499 @@
+import { b as w, c as E, d as I, B as L } from "./registry-helpers-BRxAr6nG.js";
+var $ = /* @__PURE__ */ Symbol.for("preact-signals");
+function B() {
+  if (y > 1)
+    y--;
+  else {
+    for (var e, t = !1; P !== void 0; ) {
+      var i = P;
+      for (P = void 0, N++; i !== void 0; ) {
+        var n = i.o;
+        if (i.o = void 0, i.f &= -3, !(8 & i.f) && W(i)) try {
+          i.c();
+        } catch (s) {
+          t || (e = s, t = !0);
+        }
+        i = n;
+      }
+    }
+    if (N = 0, y--, t) throw e;
+  }
+}
+function rt(e) {
+  if (y > 0) return e();
+  y++;
+  try {
+    return e();
+  } finally {
+    B();
+  }
+}
+var o = void 0;
+function C(e) {
+  var t = o;
+  o = void 0;
+  try {
+    return e();
+  } finally {
+    o = t;
+  }
+}
+var P = void 0, y = 0, N = 0, V = 0;
+function A(e) {
+  if (o !== void 0) {
+    var t = e.n;
+    if (t === void 0 || t.t !== o)
+      return t = { i: 0, S: e, p: o.s, n: void 0, t: o, e: void 0, x: void 0, r: t }, o.s !== void 0 && (o.s.n = t), o.s = t, e.n = t, 32 & o.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 = o.s, t.n = void 0, o.s.n = t, o.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 = $;
+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 : C(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 && C(function() {
+      var s;
+      (s = t.Z) == null || s.call(t);
+    }));
+  }
+};
+d.prototype.subscribe = function(e) {
+  var t = this;
+  return g(function() {
+    var i = t.value, n = o;
+    o = void 0;
+    try {
+      e(i);
+    } finally {
+      o = 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 = o;
+  o = void 0;
+  try {
+    return this.value;
+  } finally {
+    o = e;
+  }
+};
+Object.defineProperty(d.prototype, "value", { get: function() {
+  var e = A(this);
+  return e !== void 0 && (e.i = this.i), this.v;
+}, set: function(e) {
+  if (e !== this.v) {
+    if (N > 100) throw new Error("Cycle detected");
+    this.v = e, this.i++, V++, y++;
+    try {
+      for (var t = this.t; t !== void 0; t = t.x) t.t.N();
+    } finally {
+      B();
+    }
+  }
+} });
+function ot(e, t) {
+  return new d(e, t);
+}
+function W(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 j(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 k(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 = V - 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 === V)) return !0;
+  if (this.g = V, this.f |= 1, this.i > 0 && !W(this))
+    return this.f &= -2, !0;
+  var e = o;
+  try {
+    j(this), o = 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 o = e, k(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 = A(this);
+  if (this.h(), e !== void 0 && (e.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} });
+function st(e, t) {
+  return new _(e, t);
+}
+function M(e) {
+  var t = e.u;
+  if (e.u = void 0, typeof t == "function") {
+    y++;
+    var i = o;
+    o = void 0;
+    try {
+      t();
+    } catch (n) {
+      throw e.f &= -2, e.f |= 8, O(e), n;
+    } finally {
+      o = i, B();
+    }
+  }
+}
+function O(e) {
+  for (var t = e.s; t !== void 0; t = t.n) t.S.U(t);
+  e.x = void 0, e.s = void 0, M(e);
+}
+function z(e) {
+  if (o !== this) throw new Error("Out-of-order effect");
+  k(this), o = e, this.f &= -2, 8 & this.f && O(this), B();
+}
+function S(e, t) {
+  this.x = e, this.u = void 0, this.s = void 0, this.o = void 0, this.f = 32, this.name = t?.name;
+}
+S.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();
+  }
+};
+S.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, M(this), j(this), y++;
+  var e = o;
+  return o = this, z.bind(this, e);
+};
+S.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.o = P, P = this);
+};
+S.prototype.d = function() {
+  this.f |= 8, 1 & this.f || O(this);
+};
+S.prototype.dispose = function() {
+  this.d();
+};
+function g(e, t) {
+  var i = new S(e, t);
+  try {
+    i.c();
+  } catch (s) {
+    throw i.d(), s;
+  }
+  var n = i.d.bind(i);
+  return n[Symbol.dispose] = n, n;
+}
+function F(e, t, i) {
+  const { debounce: n, immediate: s = !1 } = i || {}, f = (u, l, h) => {
+    const a = u.getFieldByPath(e.__path);
+    return a ? (s && queueMicrotask(() => {
+      const r = a.value.value;
+      t(r, l);
+    }), g(() => {
+      const r = a.value.value;
+      h(() => {
+        t(r, l);
+      });
+    })) : null;
+  };
+  w().register(f, { debounce: n });
+}
+function J(e, t, i) {
+  const { when: n, fields: s = "all", transform: f, debounce: u } = i || {};
+  F(
+    e,
+    (l, h) => {
+      if (n) {
+        const c = h.form.getValue();
+        if (!n(c)) return;
+      }
+      const a = f ? f(l) : l, r = h.form.getFieldByPath(t.__path);
+      if (r)
+        if (s === "all" || !s)
+          r.setValue(a, { emitEvent: !1 });
+        else {
+          const c = {};
+          s.forEach((v) => {
+            l && typeof l == "object" && (c[v] = l[v]);
+          }), "patchValue" in r && r.patchValue(c);
+        }
+    },
+    { debounce: u }
+  );
+}
+function R(e, t, i) {
+  const { debounce: n, resetOnDisable: s = !1 } = i || {}, f = (u, l, h) => {
+    const a = u.getFieldByPath(e.__path);
+    return a ? g(() => {
+      const r = u.value.value;
+      h(() => {
+        t(r) ? a.enable() : (a.disable(), s && a.reset());
+      });
+    }) : null;
+  };
+  w().register(f, { debounce: n });
+}
+function G(e, t, i) {
+  R(e, (n) => !t(n), i);
+}
+function H(e, t, i, n) {
+  const { debounce: s, condition: f } = n || {}, u = (l, h, a) => {
+    const r = l.getFieldByPath(t.__path);
+    if (!r) return null;
+    const c = e.map((v) => l.getFieldByPath(v.__path)).filter((v) => v !== void 0);
+    return c.length === 0 ? null : g(() => {
+      const v = c.map((b) => b.value.value);
+      a(() => {
+        if (f) {
+          const x = l.getValue();
+          if (!f(x)) return;
+        }
+        const b = {};
+        e.forEach((x, q) => {
+          const D = x.__path.split(".").pop() || x.__path;
+          b[D] = v[q];
+        });
+        const m = i(b);
+        r.value.peek() !== m && queueMicrotask(() => {
+          r.setValue(m, { emitEvent: !1 });
+        });
+      });
+    });
+  };
+  w().register(u, { debounce: s });
+}
+function K(e, t, i) {
+  const { debounce: n } = i || {}, s = (f, u, l) => {
+    const h = f.getFieldByPath(e.__path);
+    if (!h) return null;
+    const a = t.map((r) => f.getFieldByPath(r.__path)).filter((r) => r !== void 0);
+    return a.length === 0 ? null : g(() => {
+      a.forEach((r) => r.value.value), l(() => {
+        h.validate();
+      });
+    });
+  };
+  w().register(s, { debounce: n });
+}
+function Q(e, t, i) {
+  const { debounce: n, transform: s } = i || {}, f = (u, l, h) => {
+    const a = u.getFieldByPath(e.__path), r = u.getFieldByPath(t.__path);
+    if (!a || !r) return null;
+    let c = !1;
+    const v = g(() => {
+      const m = a.value.value;
+      c || h(() => {
+        c = !0;
+        const U = s ? s(m) : m;
+        r.setValue(U, { emitEvent: !1 }), c = !1;
+      });
+    }), b = g(() => {
+      const m = r.value.value;
+      c || h(() => {
+        c = !0, a.setValue(m, { emitEvent: !1 }), c = !1;
+      });
+    });
+    return () => {
+      v(), b();
+    };
+  };
+  w().register(f, { debounce: n });
+}
+function X(e, t, i) {
+  const { debounce: n, resetValue: s = null, onlyIfDirty: f = !1 } = i || {}, u = (l, h, a) => {
+    const r = l.getFieldByPath(e.__path);
+    return r ? g(() => {
+      const c = l.value.value;
+      a(() => {
+        if (t(c)) {
+          if (f && !r.dirty.value)
+            return;
+          r.setValue(s), r.markAsPristine(), r.markAsUntouched();
+        }
+      });
+    }) : null;
+  };
+  w().register(u, { debounce: n });
+}
+function T(e, t, i) {
+  const { onUserChangeOnly: n = !1, emitEvent: s = !0, debounce: f } = i || {};
+  F(
+    e,
+    (u, l) => {
+      const h = l.form.getFieldByPath(e.__path);
+      if (!h || n && !h.touched.value)
+        return;
+      const a = t(u);
+      a !== u && h.setValue(a, { emitEvent: s });
+    },
+    { debounce: f }
+  );
+}
+function p(e, t) {
+  return (i, n) => {
+    T(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 Z(e) {
+  if (!e)
+    return E();
+  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 s of i) {
+    const f = Z(s);
+    for (const u of n)
+      u(f);
+  }
+}
+function it(e, t, i) {
+  if (!e) return;
+  let n = !1;
+  F(
+    e,
+    (s, f) => {
+      if (!n && t(s)) {
+        const u = E();
+        i(u), n = !0;
+      }
+    },
+    { immediate: !0 }
+  );
+}
+const at = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BehaviorContextImpl: I,
+  BehaviorRegistry: L,
+  apply: et,
+  applyWhen: it,
+  computeFrom: H,
+  copyFrom: J,
+  createFieldPath: E,
+  createTransformer: p,
+  disableWhen: G,
+  enableWhen: R,
+  resetWhen: X,
+  revalidateWhen: K,
+  syncFields: Q,
+  toBehaviorFieldPath: Z,
+  transformValue: T,
+  transformers: Y,
+  watchField: F
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  g as E,
+  et as a,
+  it as b,
+  J as c,
+  ot as d,
+  R as e,
+  G as f,
+  H as g,
+  F as h,
+  at as i,
+  K as j,
+  X as k,
+  T as l,
+  p as m,
+  Y as n,
+  rt as r,
+  Q as s,
+  Z as t,
+  st 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';