@reformer/core 3.0.0 → 4.0.0

package/dist/field-path-DuKdGcIE.js

@@ -0,0 +1,66 @@
+function c() {
+  return _("");
+}
+function _(t) {
+  return new Proxy({}, {
+    get(r, i) {
+      if (typeof i == "symbol")
+        return;
+      if (i === "__path" || i === "__fieldPath")
+        return t || i;
+      if (i === "__key") {
+        const n = t.split(".");
+        return n[n.length - 1] || i;
+      }
+      if (i === "then" || i === "catch" || i === "finally" || i === "constructor" || i === "toString" || i === "valueOf" || i === "toJSON")
+        return;
+      const f = t ? `${t}.${i}` : i, a = {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        __key: i,
+        __path: f,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        __formType: void 0,
+        __fieldType: void 0
+      };
+      return new Proxy(a, {
+        get(n, e) {
+          if (typeof e != "symbol") {
+            if (e === "__path" || e === "__fieldPath") return f;
+            if (e === "__key") return i;
+            if (e !== "__formType" && e !== "__fieldType" && !(e === "then" || e === "catch" || e === "finally" || e === "constructor" || e === "toString" || e === "valueOf" || e === "toJSON"))
+              return _(`${f}.${e}`);
+          }
+        }
+      });
+    }
+  });
+}
+function u(t) {
+  if (typeof t == "string")
+    return t;
+  if (t && typeof t == "object") {
+    const r = t.__path;
+    if (typeof r == "string")
+      return r;
+  }
+  throw new Error("Invalid field path node: " + JSON.stringify(t));
+}
+function y(t) {
+  const r = u(t);
+  return _(r);
+}
+function l(t) {
+  if (t && typeof t == "object" && "__key" in t)
+    return t.__key;
+  if (typeof t == "string") {
+    const r = t.split(".");
+    return r[r.length - 1];
+  }
+  throw new Error("Invalid field path node");
+}
+export {
+  l as a,
+  c,
+  u as e,
+  y as t
+};

package/dist/hooks/types.d.ts

@@ -1,4 +1,4 @@
-import type { ValidationError } from '../core/types';
+import { ValidationError } from '../core/types';
 /**
  * Состояние поля формы, возвращаемое хуком {@link useFormControl} для {@link FieldNode}.
  *

package/dist/hooks/useArrayLength.d.ts

@@ -0,0 +1,31 @@
+import { ArrayNode } from '../core/nodes/array-node';
+import { FormFields } from '../core/types';
+/**
+ * React-хук для подписки только на длину массива.
+ *
+ * Оптимизированная версия {@link useFormControl} для ArrayNode, которая
+ * подписывается только на сигнал `length`. Компонент не будет ре-рендериться
+ * при изменении значений вложенных полей.
+ *
+ * @typeParam T - Тип элемента массива
+ * @param control - ArrayNode для подписки
+ * @returns Текущая длина массива
+ *
+ * @example
+ * ```tsx
+ * function ArrayRenderer({ arrayNode }) {
+ *   const length = useArrayLength(arrayNode);
+ *
+ *   return (
+ *     <div>
+ *       {arrayNode.map((item, index) => (
+ *         <ItemRenderer key={item.id} item={item} />
+ *       ))}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @group React Hooks
+ */
+export declare function useArrayLength<T extends FormFields>(control: ArrayNode<T>): number;

package/dist/hooks/useFormControl.d.ts

@@ -1,7 +1,7 @@
-import type { FieldNode } from '../core/nodes/field-node';
-import type { ArrayNode } from '../core/nodes/array-node';
-import type { FormValue, FormFields } from '../core/types';
-import type { FieldControlState, ArrayControlState } from './types';
+import { FieldNode } from '../core/nodes/field-node';
+import { ArrayNode } from '../core/nodes/array-node';
+import { FormValue, FormFields } from '../core/types';
+import { FieldControlState, ArrayControlState } from './types';
 /**
  * React-хук для подписки на состояние {@link ArrayNode}.
  *

package/dist/hooks/useFormControlValue.d.ts

@@ -1,5 +1,5 @@
-import type { FieldNode } from '../core/nodes/field-node';
-import type { FormValue } from '../core/types';
+import { FieldNode } from '../core/nodes/field-node';
+import { FormValue } from '../core/types';
 /**
  * React-хук для подписки только на значение поля.
  *

package/dist/hooks/useHiddenCondition.d.ts

@@ -0,0 +1,25 @@
+import { FormProxy, FieldPath } from '../core/types';
+type HiddenFn<T> = (form: FormProxy<T>, path: FieldPath<T>) => boolean;
+/**
+ * Хук для реактивной оценки функции hidden.
+ *
+ * Подписывается на изменения формы через сигналы и возвращает текущее
+ * значение hidden-условия.
+ *
+ * @param hiddenFn - Функция, определяющая скрытие.
+ * @param form - {@link FormProxy} формы.
+ * @param path - Текущий {@link FieldPath}.
+ * @returns `true`, если элемент должен быть скрыт.
+ *
+ * @example
+ * ```tsx
+ * import { useHiddenCondition } from '@reformer/core';
+ *
+ * function MaybeHidden({ form, path, children }) {
+ *   const hidden = useHiddenCondition((f) => !f.subscribeNewsletter.value, form, path);
+ *   return hidden ? null : <>{children}</>;
+ * }
+ * ```
+ */
+export declare function useHiddenCondition<T>(hiddenFn: HiddenFn<T> | undefined, form: FormProxy<T>, path: FieldPath<T>): boolean;
+export {};

package/dist/hooks/useSignalSubscription.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from '@preact/signals-core';
+import { Signal } from '@preact/signals-core';
 /** @internal */
 export type SignalMap = Record<string, Signal<unknown>>;
 /** @internal */

package/dist/index-D25LsbRm.js

@@ -0,0 +1,73 @@
+import { c as f } from "./field-path-DuKdGcIE.js";
+import { watchField as m } from "./behaviors/watch-field.js";
+import { a as l, B as c } from "./registry-helpers-Bv_BJ1s-.js";
+import { copyFrom as h } from "./behaviors/copy-from.js";
+import { disableWhen as u, enableWhen as p } from "./behaviors/enable-when.js";
+import { computeFrom as y } from "./behaviors/compute-from.js";
+import { revalidateWhen as d } from "./behaviors/revalidate-when.js";
+import { syncFields as _ } from "./behaviors/sync-fields.js";
+import { resetWhen as P } from "./behaviors/reset-when.js";
+import { createTransformer as b, transformValue as v, transformers as g } from "./behaviors/transform-value.js";
+function s(r) {
+  if (!r)
+    return f();
+  const e = r.__path;
+  return A(e);
+}
+function A(r) {
+  return new Proxy({}, {
+    get(e, t) {
+      return typeof t == "symbol" ? void 0 : {
+        __path: r ? `${r}.${t}` : t,
+        __key: t
+      };
+    }
+  });
+}
+function B(r, e) {
+  const t = (Array.isArray(r) ? r : [r]).filter(Boolean), o = Array.isArray(e) ? e : [e];
+  for (const a of t) {
+    const i = s(a);
+    for (const n of o)
+      n(i);
+  }
+}
+function F(r, e, t) {
+  if (!r) return;
+  let o = !1;
+  m(
+    r,
+    (a, i) => {
+      if (!o && e(a)) {
+        const n = f();
+        t(n), o = !0;
+      }
+    },
+    { immediate: !0 }
+  );
+}
+const z = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BehaviorContextImpl: l,
+  BehaviorRegistry: c,
+  apply: B,
+  applyWhen: F,
+  computeFrom: y,
+  copyFrom: h,
+  createTransformer: b,
+  disableWhen: u,
+  enableWhen: p,
+  resetWhen: P,
+  revalidateWhen: d,
+  syncFields: _,
+  toBehaviorFieldPath: s,
+  transformValue: v,
+  transformers: g,
+  watchField: m
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  B as a,
+  F as b,
+  z as i,
+  s as t
+};

package/dist/index.d.ts

@@ -8,6 +8,8 @@ export { ArrayNode } from './core/nodes/array-node';
 export type { SetValueOptions } from './core/nodes/form-node';
 export { useFormControl } from './hooks/useFormControl';
 export { useFormControlValue } from './hooks/useFormControlValue';
+export { useArrayLength } from './hooks/useArrayLength';
+export { useHiddenCondition } from './hooks/useHiddenCondition';
 export type { FieldControlState, ArrayControlState } from './hooks/types';
 export type { BehaviorSchemaFn } from './core/behavior/types';
 export { validateForm } from './core/validation/validate-form';