@reformer/core 1.1.0 → 2.0.0-beta.11

package/dist/hooks/useFormControlValue.d.ts

@@ -0,0 +1,167 @@
+import { FieldNode } from '../core/nodes/field-node';
+import { FormValue } from '../core/types';
+/**
+ * React-хук для подписки только на значение поля.
+ *
+ * Оптимизированная версия {@link useFormControl}, которая подписывается
+ * только на сигнал `value`. Компонент не будет ре-рендериться при изменении
+ * `errors`, `touched`, `valid` и других свойств состояния.
+ *
+ * ## Когда использовать
+ *
+ * - **Условный рендеринг** на основе значения другого поля
+ * - **Вычисляемые значения** зависящие от значения поля
+ * - **Read-only отображение** значения без интерактивности
+ * - **Оптимизация производительности** когда не нужны другие свойства состояния
+ *
+ * ## Когда НЕ использовать
+ *
+ * Если компоненту нужны `errors`, `touched`, `disabled` или другие свойства -
+ * используйте {@link useFormControl}. Множественные подписки на один контрол
+ * через разные хуки менее эффективны, чем одна подписка через `useFormControl`.
+ *
+ * @typeParam T - Тип значения поля
+ * @param control - FieldNode для подписки на значение
+ * @returns Текущее значение поля
+ *
+ * @example Условный рендеринг секции
+ * ```tsx
+ * import { useFormControlValue } from '@reformer/core';
+ *
+ * interface FormFields {
+ *   hasShipping: FieldNode<boolean>;
+ *   shippingAddress: GroupNode<AddressFields>;
+ * }
+ *
+ * function ShippingSection({ form }: { form: FormFields }) {
+ *   // Подписка только на значение checkbox
+ *   const hasShipping = useFormControlValue(form.hasShipping);
+ *
+ *   if (!hasShipping) {
+ *     return null;
+ *   }
+ *
+ *   return (
+ *     <div className="shipping-section">
+ *       <h3>Shipping Address</h3>
+ *       <AddressForm control={form.shippingAddress} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Динамические опции на основе другого поля
+ * ```tsx
+ * interface FormFields {
+ *   country: FieldNode<string>;
+ *   city: FieldNode<string>;
+ * }
+ *
+ * function CitySelect({ form }: { form: FormFields }) {
+ *   const country = useFormControlValue(form.country);
+ *   const { value, disabled } = useFormControl(form.city);
+ *
+ *   // Получаем города для выбранной страны
+ *   const cities = useMemo(() => getCitiesForCountry(country), [country]);
+ *
+ *   // Сбрасываем город при смене страны
+ *   useEffect(() => {
+ *     form.city.setValue('');
+ *   }, [country, form.city]);
+ *
+ *   return (
+ *     <select
+ *       value={value}
+ *       disabled={disabled || !country}
+ *       onChange={e => form.city.setValue(e.target.value)}
+ *     >
+ *       <option value="">Select city...</option>
+ *       {cities.map(city => (
+ *         <option key={city.id} value={city.id}>{city.name}</option>
+ *       ))}
+ *     </select>
+ *   );
+ * }
+ * ```
+ *
+ * @example Отображение суммы в реальном времени
+ * ```tsx
+ * interface OrderItem {
+ *   quantity: FieldNode<number>;
+ *   price: FieldNode<number>;
+ * }
+ *
+ * function OrderTotal({ items }: { items: ArrayNode<OrderItem> }) {
+ *   // Для каждого элемента получаем только значения
+ *   const quantities = items.map(item => useFormControlValue(item.controls.quantity));
+ *   const prices = items.map(item => useFormControlValue(item.controls.price));
+ *
+ *   const total = quantities.reduce((sum, qty, i) => sum + qty * prices[i], 0);
+ *
+ *   return (
+ *     <div className="order-total">
+ *       <strong>Total: ${total.toFixed(2)}</strong>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Preview значения
+ * ```tsx
+ * interface MarkdownEditorProps {
+ *   control: FieldNode<string>;
+ * }
+ *
+ * function MarkdownPreview({ control }: MarkdownEditorProps) {
+ *   // Подписка только на значение для preview
+ *   const markdown = useFormControlValue(control);
+ *
+ *   const html = useMemo(() => marked(markdown), [markdown]);
+ *
+ *   return (
+ *     <div
+ *       className="markdown-preview"
+ *       dangerouslySetInnerHTML={{ __html: html }}
+ *     />
+ *   );
+ * }
+ *
+ * // Основной редактор использует useFormControl для полного состояния
+ * function MarkdownEditor({ control }: MarkdownEditorProps) {
+ *   const { value, shouldShowError, errors } = useFormControl(control);
+ *
+ *   return (
+ *     <div className="editor-container">
+ *       <textarea
+ *         value={value}
+ *         onChange={e => control.setValue(e.target.value)}
+ *       />
+ *       {shouldShowError && <span className="error">{errors[0]?.message}</span>}
+ *
+ *       {/* Preview обновляется только при изменении value *}
+ *       <MarkdownPreview control={control} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example Счётчик символов
+ * ```tsx
+ * function CharacterCounter({ control, max }: { control: FieldNode<string>; max: number }) {
+ *   const value = useFormControlValue(control);
+ *   const remaining = max - value.length;
+ *
+ *   return (
+ *     <span className={remaining < 20 ? 'warning' : ''}>
+ *       {remaining} characters remaining
+ *     </span>
+ *   );
+ * }
+ * ```
+ *
+ * @see {@link useFormControl} - для полного состояния поля
+ * @see {@link FieldNode} - тип контрола поля
+ *
+ * @group React Hooks
+ */
+export declare function useFormControlValue<T extends FormValue>(control: FieldNode<T>): T;

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

@@ -0,0 +1,17 @@
+import { Signal } from '@preact/signals-core';
+/** @internal */
+export type SignalMap = Record<string, Signal<unknown>>;
+/** @internal */
+export type ExtractSignalValues<T extends SignalMap> = {
+    [K in keyof T]: T[K] extends Signal<infer V> ? V : never;
+};
+/** @internal */
+export interface SignalConfig<K extends string> {
+    key: K;
+    useShallowArrayEqual?: boolean;
+}
+/**
+ * Хук для подписки на набор сигналов с кешированием
+ * @internal
+ */
+export declare function useSignalSubscription<TSignals extends SignalMap, TSnapshot extends ExtractSignalValues<TSignals>>(signals: TSignals, configs: SignalConfig<Extract<keyof TSignals, string>>[], buildSnapshot: (values: ExtractSignalValues<TSignals>) => TSnapshot): TSnapshot;

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

@@ -6,5 +6,12 @@ export { FieldNode } from './core/nodes/field-node';
 export { GroupNode } from './core/nodes/group-node';
 export { ArrayNode } from './core/nodes/array-node';
 export type { SetValueOptions } from './core/nodes/form-node';
-export { useFormControl, useFormControlValue } from './hooks/useFormControl';
+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';
+export * as behaviors from './core/behavior';
+export * as validators from './core/validation';