@reformer/core 1.0.0-beta.3

package/dist/create-field-path-CdPF3lIK.js

@@ -0,0 +1,704 @@
+var P = Symbol.for("preact-signals");
+function w() {
+  if (d > 1)
+    d--;
+  else {
+    for (var i, t = !1; l !== void 0; ) {
+      var e = l;
+      for (l = void 0, x++; e !== void 0; ) {
+        var n = e.o;
+        if (e.o = void 0, e.f &= -3, !(8 & e.f) && _(e)) try {
+          e.c();
+        } catch (o) {
+          t || (i = o, t = !0);
+        }
+        e = n;
+      }
+    }
+    if (x = 0, d--, t) throw i;
+  }
+}
+var r = void 0;
+function C(i) {
+  var t = r;
+  r = void 0;
+  try {
+    return i();
+  } finally {
+    r = t;
+  }
+}
+var l = void 0, d = 0, x = 0, y = 0;
+function k(i) {
+  if (r !== void 0) {
+    var t = i.n;
+    if (t === void 0 || t.t !== r)
+      return t = { i: 0, S: i, 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, i.n = t, 32 & r.f && i.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 c(i, t) {
+  this.v = i, this.i = 0, this.n = void 0, this.t = void 0, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+c.prototype.brand = P;
+c.prototype.h = function() {
+  return !0;
+};
+c.prototype.S = function(i) {
+  var t = this, e = this.t;
+  e !== i && i.e === void 0 && (i.x = e, this.t = i, e !== void 0 ? e.e = i : C(function() {
+    var n;
+    (n = t.W) == null || n.call(t);
+  }));
+};
+c.prototype.U = function(i) {
+  var t = this;
+  if (this.t !== void 0) {
+    var e = i.e, n = i.x;
+    e !== void 0 && (e.x = n, i.e = void 0), n !== void 0 && (n.e = e, i.x = void 0), i === this.t && (this.t = n, n === void 0 && C(function() {
+      var o;
+      (o = t.Z) == null || o.call(t);
+    }));
+  }
+};
+c.prototype.subscribe = function(i) {
+  var t = this;
+  return F(function() {
+    var e = t.value, n = r;
+    r = void 0;
+    try {
+      i(e);
+    } finally {
+      r = n;
+    }
+  }, { name: "sub" });
+};
+c.prototype.valueOf = function() {
+  return this.value;
+};
+c.prototype.toString = function() {
+  return this.value + "";
+};
+c.prototype.toJSON = function() {
+  return this.value;
+};
+c.prototype.peek = function() {
+  var i = r;
+  r = void 0;
+  try {
+    return this.value;
+  } finally {
+    r = i;
+  }
+};
+Object.defineProperty(c.prototype, "value", { get: function() {
+  var i = k(this);
+  return i !== void 0 && (i.i = this.i), this.v;
+}, set: function(i) {
+  if (i !== this.v) {
+    if (x > 100) throw new Error("Cycle detected");
+    this.v = i, this.i++, y++, d++;
+    try {
+      for (var t = this.t; t !== void 0; t = t.x) t.t.N();
+    } finally {
+      w();
+    }
+  }
+} });
+function O(i, t) {
+  return new c(i, t);
+}
+function _(i) {
+  for (var t = i.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 b(i) {
+  for (var t = i.s; t !== void 0; t = t.n) {
+    var e = t.S.n;
+    if (e !== void 0 && (t.r = e), t.S.n = t, t.i = -1, t.n === void 0) {
+      i.s = t;
+      break;
+    }
+  }
+}
+function V(i) {
+  for (var t = i.s, e = 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)) : e = t, t.S.n = t.r, t.r !== void 0 && (t.r = void 0), t = n;
+  }
+  i.s = e;
+}
+function h(i, t) {
+  c.call(this, void 0), this.x = i, this.s = void 0, this.g = y - 1, this.f = 4, this.W = t?.watched, this.Z = t?.unwatched, this.name = t?.name;
+}
+h.prototype = new c();
+h.prototype.h = function() {
+  if (this.f &= -3, 1 & this.f) return !1;
+  if ((36 & this.f) == 32 || (this.f &= -5, this.g === y)) return !0;
+  if (this.g = y, this.f |= 1, this.i > 0 && !_(this))
+    return this.f &= -2, !0;
+  var i = r;
+  try {
+    b(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 (e) {
+    this.v = e, this.f |= 16, this.i++;
+  }
+  return r = i, V(this), this.f &= -2, !0;
+};
+h.prototype.S = function(i) {
+  if (this.t === void 0) {
+    this.f |= 36;
+    for (var t = this.s; t !== void 0; t = t.n) t.S.S(t);
+  }
+  c.prototype.S.call(this, i);
+};
+h.prototype.U = function(i) {
+  if (this.t !== void 0 && (c.prototype.U.call(this, i), this.t === void 0)) {
+    this.f &= -33;
+    for (var t = this.s; t !== void 0; t = t.n) t.S.U(t);
+  }
+};
+h.prototype.N = function() {
+  if (!(2 & this.f)) {
+    this.f |= 6;
+    for (var i = this.t; i !== void 0; i = i.x) i.t.N();
+  }
+};
+Object.defineProperty(h.prototype, "value", { get: function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  var i = k(this);
+  if (this.h(), i !== void 0 && (i.i = this.i), 16 & this.f) throw this.v;
+  return this.v;
+} });
+function B(i, t) {
+  return new h(i, t);
+}
+function E(i) {
+  var t = i.u;
+  if (i.u = void 0, typeof t == "function") {
+    d++;
+    var e = r;
+    r = void 0;
+    try {
+      t();
+    } catch (n) {
+      throw i.f &= -2, i.f |= 8, S(i), n;
+    } finally {
+      r = e, w();
+    }
+  }
+}
+function S(i) {
+  for (var t = i.s; t !== void 0; t = t.n) t.S.U(t);
+  i.x = void 0, i.s = void 0, E(i);
+}
+function A(i) {
+  if (r !== this) throw new Error("Out-of-order effect");
+  V(this), r = i, this.f &= -2, 8 & this.f && S(this), w();
+}
+function u(i, t) {
+  this.x = i, this.u = void 0, this.s = void 0, this.o = void 0, this.f = 32, this.name = t?.name;
+}
+u.prototype.c = function() {
+  var i = this.S();
+  try {
+    if (8 & this.f || this.x === void 0) return;
+    var t = this.x();
+    typeof t == "function" && (this.u = t);
+  } finally {
+    i();
+  }
+};
+u.prototype.S = function() {
+  if (1 & this.f) throw new Error("Cycle detected");
+  this.f |= 1, this.f &= -9, E(this), b(this), d++;
+  var i = r;
+  return r = this, A.bind(this, i);
+};
+u.prototype.N = function() {
+  2 & this.f || (this.f |= 2, this.o = l, l = this);
+};
+u.prototype.d = function() {
+  this.f |= 8, 1 & this.f || S(this);
+};
+u.prototype.dispose = function() {
+  this.d();
+};
+function F(i, t) {
+  var e = new u(i, t);
+  try {
+    e.c();
+  } catch (o) {
+    throw e.d(), o;
+  }
+  var n = e.d.bind(e);
+  return n[Symbol.dispose] = n, n;
+}
+class R {
+  stack = [];
+  /**
+   * Добавить элемент в стек
+   * @param item - Элемент для добавления
+   */
+  push(t) {
+    this.stack.push(t);
+  }
+  /**
+   * Извлечь элемент из стека
+   * @returns Извлеченный элемент или undefined если стек пуст
+   */
+  pop() {
+    return this.stack.pop();
+  }
+  /**
+   * Получить текущий элемент (вершину стека) без извлечения
+   * @returns Текущий элемент или null если стек пуст
+   */
+  getCurrent() {
+    return this.stack.length > 0 ? this.stack[this.stack.length - 1] : null;
+  }
+  /**
+   * Извлечь элемент из стека с проверкой
+   * Выводит предупреждение в DEV режиме если извлеченный элемент не совпадает с ожидаемым
+   *
+   * @param expected - Ожидаемый элемент
+   * @param name - Имя реестра для отладки (например, 'ValidationRegistry')
+   */
+  verify(t, e) {
+    this.pop();
+  }
+  /**
+   * Получить длину стека
+   * @returns Количество элементов в стеке
+   */
+  get length() {
+    return this.stack.length;
+  }
+  /**
+   * Проверить, пуст ли стек
+   * @returns true если стек пуст
+   */
+  isEmpty() {
+    return this.stack.length === 0;
+  }
+  /**
+   * Очистить стек
+   */
+  clear() {
+    this.stack = [];
+  }
+}
+class I {
+  validators = [];
+  conditionStack = [];
+  /**
+   * Добавить валидатор в контекст
+   */
+  addValidator(t) {
+    if (this.conditionStack.length > 0) {
+      const e = this.conditionStack[this.conditionStack.length - 1];
+      t.condition = e;
+    }
+    this.validators.push(t);
+  }
+  /**
+   * Войти в условный блок
+   */
+  enterCondition(t, e) {
+    this.conditionStack.push({ fieldPath: t, conditionFn: e });
+  }
+  /**
+   * Выйти из условного блока
+   */
+  exitCondition() {
+    this.conditionStack.pop();
+  }
+  /**
+   * Получить все зарегистрированные валидаторы
+   */
+  getValidators() {
+    return this.validators;
+  }
+}
+class f {
+  /**
+   * Global stack активных реестров
+   * Используется для изоляции форм друг от друга
+   */
+  static registryStack = new R();
+  contextStack = [];
+  validators = [];
+  /**
+   * Получить текущий активный реестр из global stack
+   *
+   * @returns Текущий активный реестр или null
+   *
+   * @example
+   * ```typescript
+   * // В schema-validators.ts
+   * export function required(...) {
+   *   const registry = ValidationRegistry.getCurrent();
+   *   if (registry) {
+   *     registry.registerSync(...);
+   *   }
+   * }
+   * ```
+   */
+  static getCurrent() {
+    return f.registryStack.getCurrent();
+  }
+  /**
+   * Начать регистрацию валидаторов для формы
+   *
+   * Помещает this в global stack для изоляции форм
+   */
+  beginRegistration() {
+    const t = new I();
+    return this.contextStack.push(t), f.registryStack.push(this), t;
+  }
+  /**
+   * Завершить регистрацию и применить валидаторы к GroupNode
+   *
+   * Извлекает this из global stack
+   *
+   * Сохраняет валидаторы в локальном состоянии (this.validators) вместо глобального WeakMap.
+   */
+  endRegistration(t) {
+    const e = this.contextStack.pop();
+    if (!e)
+      throw new Error("No active registration context");
+    f.registryStack.verify(this, "ValidationRegistry"), this.validators = e.getValidators(), this.applyValidators(t, this.validators), this.applyArrayItemValidators(t, this.validators);
+  }
+  /**
+   * Отменить регистрацию без применения валидаторов
+   * Используется для временной валидации (например, в validateForm)
+   *
+   * Извлекает this из global stack
+   */
+  cancelRegistration() {
+    if (!this.contextStack.pop())
+      throw new Error("No active registration context to cancel");
+    f.registryStack.verify(this, "ValidationRegistry");
+  }
+  /**
+   * Получить текущий контекст регистрации
+   */
+  getCurrentContext() {
+    return this.contextStack[this.contextStack.length - 1];
+  }
+  /**
+   * Зарегистрировать синхронный валидатор
+   */
+  registerSync(t, e, n) {
+    const o = this.getCurrentContext();
+    if (!o)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    o.addValidator({
+      fieldPath: t,
+      type: "sync",
+      validator: e,
+      options: n
+    });
+  }
+  /**
+   * Зарегистрировать асинхронный валидатор
+   */
+  registerAsync(t, e, n) {
+    const o = this.getCurrentContext();
+    if (!o)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    o.addValidator({
+      fieldPath: t,
+      type: "async",
+      validator: e,
+      options: n
+    });
+  }
+  /**
+   * Зарегистрировать tree валидатор
+   */
+  registerTree(t, e) {
+    const n = this.getCurrentContext();
+    if (!n)
+      throw new Error("Validators can only be registered inside a validation schema function");
+    n.addValidator({
+      fieldPath: e?.targetField || "__tree__",
+      type: "tree",
+      validator: t,
+      options: e
+    });
+  }
+  /**
+   * Войти в условный блок
+   */
+  enterCondition(t, e) {
+    const n = this.getCurrentContext();
+    if (!n)
+      throw new Error("Conditions can only be used inside a validation schema function");
+    n.enterCondition(t, e);
+  }
+  /**
+   * Выйти из условного блока
+   */
+  exitCondition() {
+    const t = this.getCurrentContext();
+    if (!t)
+      throw new Error("No active condition");
+    t.exitCondition();
+  }
+  /**
+   * Зарегистрировать validation schema для элементов массива
+   *
+   * Используется функцией validateItems() для регистрации схемы валидации,
+   * которая будет применяться к каждому элементу ArrayNode.
+   *
+   * @param fieldPath - Путь к ArrayNode полю
+   * @param itemSchemaFn - Validation schema для элемента массива
+   */
+  registerArrayItemValidation(t, e) {
+    const n = this.getCurrentContext();
+    if (!n)
+      throw new Error(
+        "Array item validators can only be registered inside a validation schema function"
+      );
+    n.addValidator({
+      fieldPath: t,
+      type: "array-items",
+      validator: e,
+      options: {}
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    });
+  }
+  /**
+   * Получить зарегистрированные валидаторы для этого реестра
+   *
+   * Возвращает локальный массив валидаторов (без аргумента form).
+   */
+  getValidators() {
+    return this.validators;
+  }
+  /**
+   * Применить зарегистрированные валидаторы к GroupNode
+   * @private
+   */
+  applyValidators(t, e) {
+    const n = /* @__PURE__ */ new Map();
+    for (const o of e) {
+      if (o.type === "tree" || o.type === "array-items")
+        continue;
+      const a = n.get(o.fieldPath) || [];
+      a.push(o), n.set(o.fieldPath, a);
+    }
+  }
+  /**
+   * Применить array-items validators к ArrayNode элементам
+   * @private
+   */
+  applyArrayItemValidators(t, e) {
+    const n = e.filter((o) => o.type === "array-items");
+    if (n.length !== 0)
+      for (const o of n) {
+        const a = t[o.fieldPath.split(".")[0]];
+        if (a && "applyValidationSchema" in a) {
+          const s = o.validator;
+          a.applyValidationSchema(s);
+        }
+      }
+  }
+}
+class U {
+  /**
+   * Форма с типизированным Proxy-доступом к полям
+   */
+  form;
+  _form;
+  constructor(t) {
+    this._form = t;
+    const e = t._proxyInstance || t;
+    this.form = e;
+  }
+  /**
+   * Безопасно установить значение поля по строковому пути
+   *
+   * Автоматически использует emitEvent: false для предотвращения циклов
+   */
+  setFieldValue(t, e) {
+    const n = this._form.getFieldByPath(t);
+    n && n.setValue(e, { emitEvent: !1 });
+  }
+}
+class v {
+  /**
+   * Stack активных контекстов регистрации
+   * Используется для изоляции форм друг от друга
+   */
+  static contextStack = new R();
+  registrations = [];
+  isRegistering = !1;
+  /**
+   * Получить текущий активный реестр из context stack
+   *
+   * @returns Текущий активный реестр или null
+   *
+   * @example
+   * ```typescript
+   * // В schema-behaviors.ts
+   * export function copyFrom(...) {
+   *   const registry = BehaviorRegistry.getCurrent();
+   *   if (registry) {
+   *     registry.register({ ... });
+   *   }
+   * }
+   * ```
+   */
+  static getCurrent() {
+    return v.contextStack.getCurrent();
+  }
+  /**
+   * Начать регистрацию behaviors
+   * Вызывается перед применением схемы
+   *
+   * Помещает this в context stack для изоляции форм
+   */
+  beginRegistration() {
+    this.isRegistering = !0, this.registrations = [], v.contextStack.push(this);
+  }
+  /**
+   * Зарегистрировать behavior handler
+   * Вызывается функциями из schema-behaviors.ts
+   *
+   * @param handler - BehaviorHandlerFn функция
+   * @param options - Опции behavior (debounce)
+   *
+   * @example
+   * ```typescript
+   * const handler = createCopyBehavior(target, source, { when: ... });
+   * registry.register(handler, { debounce: 300 });
+   * ```
+   */
+  register(t, e) {
+    this.isRegistering && this.registrations.push({
+      // Type assertion безопасен: handler будет вызван с правильным типом формы в createEffect
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      handler: t,
+      debounce: e?.debounce
+    });
+  }
+  /**
+   * Завершить регистрацию и применить behaviors к форме
+   * Создает effect подписки для всех зарегистрированных behaviors
+   *
+   * Извлекает this из context stack
+   *
+   * @param form - GroupNode формы
+   * @returns Количество зарегистрированных behaviors и функция cleanup
+   */
+  endRegistration(t) {
+    this.isRegistering = !1, v.contextStack.verify(this, "BehaviorRegistry");
+    const e = new U(t), n = [];
+    for (const a of this.registrations) {
+      const s = this.createEffect(a, t, e);
+      s && n.push(s);
+    }
+    const o = () => {
+      n.forEach((a) => a());
+    };
+    return {
+      count: this.registrations.length,
+      cleanup: o
+    };
+  }
+  /**
+   * Создать effect подписку для behavior
+   * @private
+   */
+  createEffect(t, e, n) {
+    const { handler: o, debounce: a = 0 } = t;
+    let s = null;
+    const p = (m) => {
+      a > 0 ? (s && clearTimeout(s), s = setTimeout(m, a)) : m();
+    }, N = () => {
+      s && (clearTimeout(s), s = null);
+    }, g = o(e, n, p);
+    return g ? () => {
+      N(), g && g();
+    } : null;
+  }
+}
+function $() {
+  const i = f.getCurrent();
+  return i || {
+    registerSync: () => {
+    },
+    registerAsync: () => {
+    },
+    registerTree: () => {
+    },
+    enterCondition: () => {
+    },
+    exitCondition: () => {
+    },
+    registerArrayItemValidation: () => {
+    }
+  };
+}
+function D() {
+  const i = v.getCurrent();
+  return i || {
+    register: () => {
+    }
+  };
+}
+function W() {
+  return T("");
+}
+function T(i) {
+  return new Proxy(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    {},
+    {
+      get(t, e) {
+        if (e === "__path" || e === "__fieldPath")
+          return i || e;
+        if (e === "__key") {
+          const a = i.split(".");
+          return a[a.length - 1] || e;
+        }
+        const n = i ? `${i}.${e}` : e, o = {
+          __path: n,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          __key: e,
+          __formType: void 0,
+          __fieldType: void 0
+        };
+        return new Proxy(o, {
+          get(a, s) {
+            if (s === "__path" || s === "__fieldPath")
+              return n;
+            if (s === "__key")
+              return e;
+            if (s === "__formType" || s === "__fieldType")
+              return;
+            const p = `${n}.${s}`;
+            return T(p);
+          }
+        });
+      }
+    }
+  );
+}
+export {
+  v as B,
+  F as E,
+  R,
+  f as V,
+  D as a,
+  U as b,
+  W as c,
+  O as d,
+  $ as g,
+  B as w
+};