@companix/formkit 0.0.29 → 0.0.31

package/README.md

@@ -1,58 +1,364 @@
-## Create form primitives
+# @companix/formkit
+
+Формы на React одной декларативной схемой. Поля, раскладка, условия и проверка описываются деревом из обычных вызовов
+функций, а значения формы TypeScript выводит из самой схемы — без ручных интерфейсов, `useState` на каждое поле и
+`register` в разметке.
 
 ```tsx
-const SelectForm = (name: string) => {
-  // select form code
-}
-const InputForm = (name: string) => {
-  // input form code
-}
+const scheme = [
+  Label('Имя')(TextForm('name', { placeholder: 'Иван', $rules: { required: true } })),
+  CheckboxForm('hasCompany', { title: 'Представляю компанию' }),
+  OptionalCondition('hasCompany', { canActivate: (checked: boolean) => checked })(
+    Context('company')(Label('Компания')(TextForm('name', { placeholder: 'ООО «Ромашка»' })))
+  )
+]
+
+// onSubmit получит { name: string; hasCompany: boolean; company?: { name: string } }
+```
+
+`TextForm`, `CheckboxForm` и `Label` здесь — свои поле и раскладка проекта: как их завести, показано ниже.
+
+## Почему formkit
+
+- **Форма — данные, а не разметка.** Схема — массив, который собирают функциями: общий блок полей пишется один раз и
+  вставляется в любую форму, вариант формы — другой набор элементов, а не ветвление в JSX.
+- **Типы из схемы.** `onSubmit`, `onChange`, `defaultValues`, `setValue` и `useValue` знают имена и типы полей,
+  вложенные контексты и необязательность полей под условием.
+- **Поле пишется один раз.** `createForm` превращает любой компонент ввода в поле: умолчание, «что считать пустым» и
+  отрисовка ошибки живут в нём, а не в каждой форме.
+- **Условия и вложенность из коробки.** `OptionalCondition` показывает поля по значению другого поля, `Context`
+  складывает их в объект; скрытое поле не попадает ни в значения, ни в проверку, а под `NullableCondition` приходит
+  `null`.
+- **Состояние вне React.** Значения держит менеджер формы: правка поля перерисовывает это поле и тех, кто на него
+  подписан, а не всю форму и не экран вокруг неё.
+- **Изменённость.** Форма знает, что её правили, сообщает об этом и при отправке без изменений вызывает `onEqual`
+  вместо запроса.
+
+## Установка
+
+```sh
+npm i @companix/formkit
 ```
 
-## Create layouts
+Нужен React 18.
+
+## Форма за минуту
 
 ```tsx
-export const Label = createLayout((label: React.ReactNode) => {
-  return ({ children }) => {
-    return <FormGroup label={label}>{children}</FormGroup>
+import { useMemo } from 'react'
+import { createForm, createLayout, useForm, FormLayout } from '@companix/formkit'
+
+// поле: умолчание, проверка обязательности и компонент
+const TextForm = createForm<string, { placeholder: string }>({
+  defaultValue: '',
+  getRequireCheck: () => (value) => {
+    if (value.trim() === '') {
+      throw ''
+    }
+  },
+  getForm: ({ placeholder }) => {
+    return ({ field, error, disabled }) => {
+      return (
+        <div className="field">
+          <input
+            ref={field.ref}
+            value={field.value}
+            placeholder={placeholder}
+            disabled={disabled}
+            onChange={(e) => field.onChange(e.target.value)}
+          />
+          {error?.messages?.map((message) => (
+            <p key={message}>{message}</p>
+          ))}
+        </div>
+      )
+    }
   }
 })
 
-export const Double = createLayout(() => {
+// раскладка: подпись над полем
+const Label = createLayout((text: string) => {
   return ({ children }) => {
-    return <div className="form-double-primitive">{children}</div>
+    return (
+      <label className="label">
+        <span>{text}</span>
+        {children}
+      </label>
+    )
   }
 })
 
-export const Splitter = createLayout(() => {
-  return () => {
-    return <div className="form-splitter" />
+export const ProfileForm = () => {
+  const scheme = useMemo(() => {
+    return [
+      Label('Имя')(TextForm('name', { placeholder: 'Иван', $rules: { required: true } })),
+      Label('Город')(TextForm('city', { placeholder: 'Москва' }))
+    ]
+  }, [])
+
+  const form = useForm(scheme, {
+    defaultValues: { city: 'Москва' },
+    onSubmit: async (values) => {
+      await api.saveProfile(values) // values: { name: string; city: string }
+    }
+  })
+
+  return (
+    <>
+      <FormLayout manager={form.manager} />
+      <button onClick={form.handleSubmit}>Сохранить</button>
+    </>
+  )
+}
+```
+
+Менеджер формы создаётся один раз: схему и `defaultValues` `useForm` читает при первом рендере, поэтому схему держат в
+`useMemo`. `FormLayout` рисует схему и может стоять где угодно — в окне, на странице, в шаге мастера.
+
+## Поле — `createForm`
+
+Поле — это компонент ввода плюс три ответа: какое у него значение по умолчанию, что для него значит «пусто» и как его
+нарисовать по параметрам из схемы.
+
+```tsx
+const SelectForm = <T,>(defaultValue: T | null) => {
+  return createForm<T | null, { options: { value: T; title: string }[] }>({
+    defaultValue,
+    getRequireCheck: () => (value) => {
+      if (value === null) {
+        throw ''
+      }
+    },
+    getForm: ({ options }) => {
+      return ({ field, error }) => (
+        <Select options={options} value={field.value} onChange={field.onChange} error={error} />
+      )
+    }
+  })
+}
+
+SelectForm<'day' | 'night'>('day')('mode', { options: MODES })
+```
+
+Компонент получает `field` (`value`, `onChange`, `ref` для фокуса на ошибке), `error` и `disabled` формы. Умолчание,
+которое зависит от места, задают фабрикой, как у `SelectForm` выше: `NumberInputForm(1)('count', …)`.
+
+## Раскладка — `createLayout`
+
+Раскладка оборачивает поля разметкой. Параметр раскладки — один аргумент; раскладку без параметров вызывают сразу.
+
+```tsx
+const Card = createLayout(({ title, hint }: { title: string; hint?: string }) => {
+  return ({ children }) => (
+    <section className="card">
+      <h3>{title}</h3>
+      {hint && <p>{hint}</p>}
+      {children}
+    </section>
+  )
+})
+
+const Double = createLayout(() => {
+  return ({ children }) => <div className="double">{children}</div>
+})()
+
+Card({ title: 'Контакты', hint: 'Видят только менеджеры' })(
+  Double(TextForm('phone', { placeholder: '+7' }), TextForm('email', { placeholder: 'mail@site.ru' }))
+)
+```
+
+## Схема
+
+| Элемент                                          | Что делает                                                                | В значениях        |
+| ------------------------------------------------ | ------------------------------------------------------------------------- | ------------------ |
+| `XForm('name', params)`                          | поле                                                                      | `name: V`          |
+| `Layout(params)(…)`                              | разметка вокруг полей                                                     | поля как есть      |
+| `Context('name')(…)`                             | вложенный объект: имена полей внутри — `name.field`                       | `name: { … }`      |
+| `OptionalCondition('field', { canActivate })(…)` | поля показаны, пока `canActivate(значение поля)` верно; имя — полный путь | поля необязательны |
+| `NullableCondition('field', { canActivate })(…)` | как `OptionalCondition`, но скрытая ветка отдаёт `null` своим именам      | `name: V \| null`  |
+| `Visablility({ hidden })(…)`                     | поля не рисуются, но несут значение из `defaultValues`                    | поля необязательны |
+| `createExtraForm(…)`                             | поля, которые пользователь добавляет и убирает сам                        | поля необязательны |
+
+Значения `onSubmit` и `onChange` выводятся из схемы сами, тип `defaultValues` схемы — `GetDefaultValues<typeof scheme>`.
+
+## Проверка
+
+```tsx
+TextForm('inn', {
+  placeholder: '12 цифр',
+  $rules: {
+    required: true,
+    validate: (value) => {
+      if (!/^\d{12}$/.test(value)) {
+        throw 'ИНН — 12 цифр'
+      }
+    }
   }
 })
 ```
 
-## Create a scheme
+- `required` проверяет поле его же `getRequireCheck`; `validate` — после него. Без `required` `validate` работает,
+  только если поле не пустое.
+- Проверка бросает строку: `throw ''` подсвечивает поле, `throw 'текст'` — с сообщением, массив строк — несколько
+  сообщений. Ошибку рисует компонент поля из `error.messages`.
+- `handleSubmit` проверяет поля, которые форма показывает, и ставит фокус на первое ошибочное. Поле скрытого условия
+  отправку не держит. После первой попытки поля проверяются на каждой правке.
+- Ошибку от сервера ставит `setError` из второго аргумента `onSubmit`: `setError('inn', { message: 'ИНН занят' })`.
+
+## Значения, умолчания и условия
+
+У поля два источника начального значения: умолчание компонента (`defaultValue` из `createForm`) и `defaultValues`
+формы. Стартовое значение — `defaultValues`, а без них — умолчание компонента. От стартового значения считается
+изменённость, и с него поле начинает:
+
+- при первом показе;
+- когда условие снова показывает поле: скрытое поле теряет значение и ошибку, вернувшееся — начинает заново со
+  стартового, а не с того, что ввели до скрытия.
+
+Значения формы — `onChange`, `getValues()` и отправка — это то, что форма показывает. Поля скрытых условий в них не
+входят, а поле, которое изменение только что открыло, входит сразу, ещё до монтирования, со стартовым значением.
+
+Отсюда простое правило: `defaultValues` — только данные. Где данных нет, передавайте `undefined`, и поле возьмёт своё
+умолчание; повторять умолчание поля в `defaultValues` не нужно.
+
+```tsx
+defaultValues: {
+  hasEscorts: escorts !== null,
+  escorts: escorts ?? undefined // нет данных — поля начнут со своих умолчаний
+}
+```
+
+### Данные или `null` — `NullableCondition`
 
-```ts
+Часто включаемый блок в данных — объект или `null`: выключенное условие хранится как `null`, а не отдельным флажком.
+`OptionalCondition` даёт такому блоку `undefined` — скрытая ветка пропадает из значений. `NullableCondition` ведёт себя
+так же, но скрытая ветка отдаёт `null` своим именам — полям и контекстам уровня ветки; раскладки и вложенные условия
+внутри неё прозрачны. Имена — как `.optional()` и `.nullable()` в zod: `name?: V` против `name: V | null`.
+
+```tsx
 const scheme = [
-  Label('Имя')(
-    SelectForm('name', {
-      placeholder: 'Введите имя',
-      options: []
-    })
-  ),
-  Splitter(),
-  Double()(
-    Label('Фамилия')(
-      InputForm('surname', {
-        placeholder: 'Введите фамилию'
-      })
-    ),
-    Label('Отчество')(
-      InputForm('patronymic', {
-        placeholder: 'Введите отчество'
-      })
-    )
+  CheckboxForm('hasCompany', { title: 'Представляю компанию' }),
+  NullableCondition('hasCompany', { canActivate: (checked: boolean) => checked })(
+    Context('company')(Label('Компания')(TextForm('name', { placeholder: 'ООО «Ромашка»' })))
   )
 ]
+
+// onSubmit получит { hasCompany: boolean; company: { name: string } | null }
+```
+
+`null` у такого имени в `defaultValues` — отсутствие данных, как `undefined`: поля ветки начнут с умолчаний своих
+компонентов. Блок из данных передаётся как есть, флажок выводится из него:
+
+```tsx
+const form = useForm(scheme, {
+  defaultValues: {
+    hasCompany: profile.company !== null,
+    company: profile.company // { name: string } | null
+  },
+  onSubmit: async (values) => {
+    await api.saveProfile(values) // company — как в данных: объект или null
+  }
+})
+```
+
+Ветка из одного поля, у которого `null` — своё значение (стёртое число, дата без выбора), отдаёт `null` и скрытой, и
+пустой: различает их флажок.
+
+## Живая форма и изменённость
+
+```tsx
+const form = useForm(scheme, {
+  defaultValues,
+  // значения после каждой правки — расчёт и подсказки поверх полей, без кнопки отправки
+  onChange: (values) => setDraft(toDraft(values)),
+  // форма изменена или снова стартовая
+  onFormDirty: (isDirty) => setDirty(isDirty),
+  // отправили без изменений
+  onEqual: () => close()
+})
+```
+
+- `onDirty` сообщает о каждом поле, `onFormDirty` — о форме целиком: первое изменение и снятие последнего.
+- `setAsDefault()` делает текущие значения стартовыми — после успешного сохранения.
+- `reset(values)` ставит новые значения и делает их стартовыми; поле, которого нет в `values`, получает умолчание
+  компонента. `reset(values, { asDirty: true })` оставляет новые значения изменением.
+- `setAsDefault()` и `reset(values)` сообщают «чисто» через `onDirty` и `onFormDirty`.
+
+## Управление формой
+
+`useForm` возвращает:
+
+| Метод                         | Что делает                                                             |
+| ----------------------------- | ---------------------------------------------------------------------- |
+| `manager`                     | менеджер для `FormLayout`                                              |
+| `handleSubmit()`              | проверка показанных полей и `onSubmit` (или `onEqual`)                 |
+| `getValues()`                 | значения формы — то, что она показывает                                |
+| `getValue(name)`              | значение поля по полному пути (`company.name`)                         |
+| `setValue(name, value)`       | запись поля, как ввод пользователя                                     |
+| `reset(values, options?)`     | новые значения, по умолчанию — стартовые                               |
+| `setAsDefault()`              | текущие значения — стартовые                                           |
+| `setError(name, { message })` | ошибка поля                                                            |
+| `setFocus(name)`              | фокус на поле                                                          |
+| `subscribe(name, callback)`   | подписка на поле; возвращает отписку                                   |
+| `subscribeAny(callback)`      | подписка на любую правку; возвращает отписку                           |
+| `getNames()`                  | полные пути всех полей схемы                                           |
+| `useValue(name)`              | хук внутри `FormLayout`: значение поля с перерисовкой и типом из схемы |
+
+## Внутри схемы: `useValue` и `useSetValue`
+
+Компоненты раскладок и поля читают и пишут соседние поля по полному пути. Хуки берут форму из контекста, поэтому
+работают внутри `FormLayout`:
+
+```tsx
+// подсказка, которая зависит от выбранной причины
+const ReasonHint = createLayout(() => {
+  return () => {
+    const reason = useValue<Reason | null>('reason')
+
+    return (
+      <p className="hint">
+        {reason === 'scan' ? 'Переснимут только отмеченные' : 'Анкета вернётся на шаг'}
+      </p>
+    )
+  }
+})()
+
+// подстановка из списка в поле контакта
+const ManagerPick = ({ managers }: { managers: Manager[] }) => {
+  const setName = useSetValue<string>('contact.name')
+
+  return <Menu items={managers} onSelect={(manager) => setName(manager.name)} />
+}
+```
+
+Типизированный `useValue` для схемы — `createUseValue<typeof scheme>()`.
+
+## Поля, которые добавляет пользователь
+
+```tsx
+// Removable — своя раскладка с кнопкой удаления, AddMenu — меню ещё не добавленных полей
+const Optional = createExtraForm({
+  getItems: (registry) => [
+    registry('phone')((name, remove) => Removable(remove)(TextForm(name, { placeholder: 'Телефон' }))),
+    registry('email')((name, remove) => Removable(remove)(TextForm(name, { placeholder: 'Почта' })))
+  ],
+  getController: (append, visible) => <AddMenu hidden={visible} onSelect={append} />
+})
 ```
+
+Поле добавлено, пока у него есть значение: в `defaultValues` — показано сразу, убранное — изменение формы.
+
+## 0.0.31
+
+- `Condition` переименован в `OptionalCondition`: имя говорит, что скрытая ветка пропадает из значений.
+- `NullableCondition`: скрытая ветка отдаёт `null` своим полям и контекстам, а не пропадает из значений; `null` у них
+  в `defaultValues` — отсутствие данных.
+
+## 0.0.30
+
+- Поле, снова показанное условием, начинает со стартового значения (`defaultValues`), а не с умолчания компонента.
+- `onChange`, `getValues()` и отправка включают поля, которые изменение только что показало, — со стартовым значением,
+  до монтирования.
+- `handleSubmit` проверяет только показанные поля: скрытое поле отправку не держит. Ошибка скрытого поля сбрасывается.
+- Скрытое условием поле не считается изменённым — изменение несёт поле условия.
+- `setAsDefault()` и `reset()` сообщают «чисто» через `onDirty` и `onFormDirty`.

package/dist/ConditionBranch.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    name: string;
+    canActivate: (value: any) => boolean;
+    children: React.ReactNode;
+}
+export declare const ConditionBranch: ({ canActivate, name, children }: Props) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/bundle.es.js

@@ -1,199 +1,237 @@
-import { jsx as b, Fragment as q, jsxs as P } from "react/jsx-runtime";
-import { createContext as O, useState as L, useContext as R, useMemo as p, useEffect as $, useCallback as j, useRef as U } from "react";
-import M from "fast-deep-equal";
-const A = O({}), N = (n) => {
-  const [, r] = L([]), e = R(A);
-  if (!e)
+import { jsx as b, Fragment as L, jsxs as _ } from "react/jsx-runtime";
+import { createContext as z, useState as B, useContext as N, useMemo as $, useEffect as D, useCallback as m, useRef as G } from "react";
+import P from "fast-deep-equal";
+const w = z({}), M = (n) => {
+  const [, e] = B([]), r = N(w);
+  if (!r)
     throw new Error("useValue cannot be used outside Form context");
-  const s = p(() => {
-    const t = e.getForm(n);
+  const s = $(() => {
+    const t = r.getForm(n);
     if (!t)
       throw new Error(`form with name "${n}" doesnt exist in form`);
     return t;
-  }, [e, n]);
-  return $(() => {
-    const t = e.subscribeToForm(n, () => {
-      r([]);
+  }, [r, n]);
+  return D(() => {
+    const t = r.subscribeToForm(n, () => {
+      e([]);
     });
     return () => {
       t();
     };
   }, []), s.value;
-}, W = (n) => {
-  const r = R(A);
-  if (!r)
+}, k = (n) => {
+  const e = N(w);
+  if (!e)
     throw new Error("useSetValue cannot be used outside Form context");
-  return (e) => {
-    r.setValue(n, e);
+  return (r) => {
+    e.setValue(n, r);
   };
-}, X = () => (n) => N(n), _ = ({ canActivate: n, name: r, children: e }) => {
-  const s = N(r);
-  return n(s) ? /* @__PURE__ */ b(q, { children: e }) : null;
-}, z = ({ item: { Form: n }, name: r }) => {
-  const [, e] = L([]), s = R(A), { unregistry: t } = p(() => s.registry(r, () => {
-    e([]);
-  }), []), f = j(
-    (d) => {
-      if (d && d.focus) {
-        const h = s.getForm(r);
-        h.focus = () => {
-          d.focus();
+}, I = () => (n) => M(n), H = ({ canActivate: n, name: e, children: r }) => {
+  const s = M(e);
+  return n(s) ? /* @__PURE__ */ b(L, { children: r }) : null;
+}, J = ({ item: { Form: n }, name: e }) => {
+  const [, r] = B([]), s = N(w), { unregistry: t } = $(() => s.registry(e, () => {
+    r([]);
+  }), []), u = m(
+    (y) => {
+      if (y && y.focus) {
+        const v = s.getForm(e);
+        v.focus = () => {
+          y.focus();
         };
       }
     },
-    [r]
+    [e]
   );
-  $(() => () => {
+  D(() => () => {
     t();
   }, []);
-  const { value: y, error: m } = s.getForm(r);
+  const { value: d, error: h } = s.getForm(e);
   return /* @__PURE__ */ b(
     n,
     {
       field: {
-        value: y,
-        onChange: (d) => {
-          s.onChange(r, d);
+        value: d,
+        onChange: (y) => {
+          s.onChange(e, y);
         },
         onBlur: () => {
         },
-        ref: f
+        ref: u
       },
       isDirty: !1,
-      error: m,
+      error: h,
       disabled: s.disabled
     }
   );
-}, G = ({ item: n, path: r }) => {
-  const { getController: e, items: s } = n, t = R(A), f = p(() => {
-    const l = {};
-    return s.forEach(({ name: i, getForm: x }) => {
-      l[i] = x(i, () => D(i));
-    }), l;
-  }, []), y = j(() => {
-    const l = [];
+}, K = ({ item: n, path: e }) => {
+  const { getController: r, items: s } = n, t = N(w), u = $(() => {
+    const f = {};
+    return s.forEach(({ name: i, getForm: F }) => {
+      f[i] = F(i, () => j(i));
+    }), f;
+  }, []), d = m(() => {
+    const f = [];
     return s.forEach(({ name: i }) => {
-      t.getForm([...r, i].join(".")).value !== void 0 && l.push(i);
-    }), l;
-  }, []), m = p(() => y(), []), [d, h] = L(m);
-  $(() => {
-    const { unregistry: l } = t.registryExtraForm(
-      s.map(({ name: i }) => [...r, i].join(".")),
+      t.getForm([...e, i].join(".")).value !== void 0 && f.push(i);
+    }), f;
+  }, []), h = $(() => d(), []), [y, v] = B(h);
+  D(() => {
+    const { unregistry: f } = t.registryExtraForm(
+      s.map(({ name: i }) => [...e, i].join(".")),
       () => {
-        h(y());
+        v(d());
       }
     );
     return () => {
-      l();
+      f();
     };
   }, []);
-  const v = j(
-    (l) => {
-      f[l] && !d.includes(l) && h((i) => [...i, l]);
+  const x = m(
+    (f) => {
+      u[f] && !y.includes(f) && v((i) => [...i, f]);
     },
-    [d]
-  ), D = j((l) => {
-    h((i) => i.filter((x) => x !== l));
+    [y]
+  ), j = m((f) => {
+    v((i) => i.filter((F) => F !== f));
   }, []);
-  return /* @__PURE__ */ P(q, { children: [
-    d.map((l) => {
-      const i = f[l];
-      return /* @__PURE__ */ b(C, { path: r, scheme: [i] }, `param-form--${l}`);
+  return /* @__PURE__ */ _(L, { children: [
+    y.map((f) => {
+      const i = u[f];
+      return /* @__PURE__ */ b(A, { path: e, scheme: [i] }, `param-form--${f}`);
     }),
-    e(v, d)
+    r(x, y)
   ] });
-}, C = ({ scheme: n, path: r }) => /* @__PURE__ */ b(q, { children: n.map((e, s) => e.type === "layout" ? /* @__PURE__ */ b(e.Layout, { children: /* @__PURE__ */ b(C, { path: r, scheme: e.childs }) }, `layout-form--${s}-${r.length}`) : e.type === "context" ? /* @__PURE__ */ b(
-  C,
+}, A = ({ scheme: n, path: e }) => /* @__PURE__ */ b(L, { children: n.map((r, s) => r.type === "layout" ? /* @__PURE__ */ b(r.Layout, { children: /* @__PURE__ */ b(A, { path: e, scheme: r.childs }) }, `layout-form--${s}-${e.length}`) : r.type === "context" ? /* @__PURE__ */ b(
+  A,
   {
-    path: [...r, e.context],
-    scheme: e.childs
+    path: [...e, r.context],
+    scheme: r.childs
   },
-  `context-form--${s}-${e.context}-${r.length}`
-) : e.type === "condition" ? /* @__PURE__ */ b(
-  _,
+  `context-form--${s}-${r.context}-${e.length}`
+) : r.type === "condition" ? /* @__PURE__ */ b(
+  H,
   {
-    name: e.depended,
-    canActivate: e.canActivate,
-    children: /* @__PURE__ */ b(C, { path: r, scheme: e.childs })
+    name: r.depended,
+    canActivate: r.canActivate,
+    children: /* @__PURE__ */ b(A, { path: e, scheme: r.childs })
   },
-  `condition--${s}-${e.depended}-${r.length}`
-) : e.type === "extra" ? /* @__PURE__ */ b(G, { path: r, item: e }, `partial-item--${s}-${r.length}`) : e.type === "visability" ? e.hidden ? null : /* @__PURE__ */ b(C, { path: r, scheme: e.childs }, `visability--${s}-${r.length}`) : /* @__PURE__ */ b(
-  z,
+  `condition--${s}-${r.depended}-${e.length}`
+) : r.type === "extra" ? /* @__PURE__ */ b(K, { path: e, item: r }, `partial-item--${s}-${e.length}`) : r.type === "visability" ? r.hidden ? null : /* @__PURE__ */ b(A, { path: e, scheme: r.childs }, `visability--${s}-${e.length}`) : /* @__PURE__ */ b(
+  J,
   {
-    name: [...r, e.name].join("."),
-    item: e
+    name: [...e, r.name].join("."),
+    item: r
   },
-  `form-item--${s}-${e.name}-${r.length}`
-)) }), S = (n, r, e, s) => {
+  `form-item--${s}-${r.name}-${e.length}`
+)) }), Q = (n) => {
+  const e = {};
+  for (const r in n)
+    n[r] !== null && (e[r] = n[r]);
+  return e;
+}, p = (n, e, r, s) => {
   n.forEach((t) => {
-    if (t.type === "form" && s(t, [...r, t.name].join("."), e[t.name]), t.type === "context") {
-      S(t.childs, [...r, t.context], e[t.context] ?? {}, s);
+    if (t.type === "form" && s(t, [...e, t.name].join("."), r[t.name]), t.type === "context") {
+      p(t.childs, [...e, t.context], r[t.context] ?? {}, s);
       return;
     }
-    if (t.type === "layout" || t.type === "condition" || t.type === "visability") {
-      S(t.childs, r, e, s);
+    if (t.type === "layout" || t.type === "visability") {
+      p(t.childs, e, r, s);
       return;
     }
-    t.type === "extra" && t.items.forEach(({ getForm: f, name: y }) => {
-      S([f(y, () => {
-      })], r, e, s);
+    if (t.type === "condition") {
+      p(t.childs, e, t.nullable ? Q(r) : r, s);
+      return;
+    }
+    t.type === "extra" && t.items.forEach(({ getForm: u, name: d }) => {
+      p([u(d, () => {
+      })], e, r, s);
     });
   });
-}, E = ({ scheme: n, values: r, path: e, forms: s }) => {
+}, C = (n, e, r, s) => {
   n.forEach((t) => {
-    if (t.type === "form") {
-      const f = [...e, t.name].join(".");
-      s[f].value !== void 0 && (r[t.name] = s[f].value);
+    if (t.type === "form" && s([...e, t.name].join(".")), t.type === "context") {
+      C(t.childs, [...e, t.context], r, s);
+      return;
+    }
+    if (t.type === "layout") {
+      C(t.childs, e, r, s);
+      return;
+    }
+    if (t.type === "visability" && !t.hidden) {
+      C(t.childs, e, r, s);
+      return;
+    }
+    if (t.type === "condition" && t.canActivate(r[t.depended]?.value)) {
+      C(t.childs, e, r, s);
+      return;
+    }
+    t.type === "extra" && t.items.forEach(({ getForm: u, name: d }) => {
+      r[[...e, d].join(".")]?.value !== void 0 && C([u(d, () => {
+      })], e, r, s);
+    });
+  });
+}, U = (n, e) => {
+  n.forEach((r) => {
+    r.type === "form" && (e[r.name] = null), r.type === "context" && (e[r.context] = null), (r.type === "layout" || r.type === "condition" || r.type === "visability") && U(r.childs, e);
+  });
+}, S = ({ scheme: n, values: e, path: r, forms: s, shown: t }) => {
+  n.forEach((u) => {
+    if (u.type === "form") {
+      const { value: d, startValue: h } = s[[...r, u.name].join(".")];
+      d !== void 0 && (e[u.name] = d), d === void 0 && t && (e[u.name] = h);
     }
-    if (t.type === "context") {
-      r[t.context] = {}, E({
-        scheme: t.childs,
-        path: [...e, t.context],
-        values: r[t.context],
-        forms: s
+    if (u.type === "context") {
+      e[u.context] = {}, S({
+        scheme: u.childs,
+        path: [...r, u.context],
+        values: e[u.context],
+        forms: s,
+        shown: t
       });
       return;
     }
-    if (t.type === "layout") {
-      E({ scheme: t.childs, path: e, values: r, forms: s });
+    if (u.type === "layout") {
+      S({ scheme: u.childs, path: r, values: e, forms: s, shown: t });
       return;
     }
-    if (t.type === "visability") {
-      E({ scheme: t.childs, path: e, values: r, forms: s });
+    if (u.type === "visability") {
+      S({ scheme: u.childs, path: r, values: e, forms: s, shown: t && !u.hidden });
       return;
     }
-    if (t.type === "condition") {
-      const f = s[t.depended]?.value;
-      if (t.canActivate(f)) {
-        E({ scheme: t.childs, path: e, values: r, forms: s });
+    if (u.type === "condition") {
+      const d = s[u.depended]?.value;
+      if (u.canActivate(d)) {
+        S({ scheme: u.childs, path: r, values: e, forms: s, shown: t });
         return;
       }
+      u.nullable && U(u.childs, e);
     }
-    t.type === "extra" && t.items.forEach(({ getForm: f, name: y }) => {
-      E({ scheme: [f(y, () => {
-      })], path: e, values: r, forms: s });
+    u.type === "extra" && u.items.forEach(({ getForm: d, name: h }) => {
+      S({ scheme: [d(h, () => {
+      })], path: r, values: e, forms: s, shown: !1 });
     });
   });
-}, T = (n, r) => {
-  const e = {};
-  return E({ scheme: n, path: [], values: e, forms: r }), e;
-}, H = (n, r) => {
-  const { onSubmit: e, onChange: s, onEqual: t, disabled: f, onDirty: y, onFormDirty: m, onChangeEvent: d, defaultValues: h } = r, v = { onSubmit: e }, D = { onChange: s }, l = {
+}, q = (n, e) => {
+  const r = {};
+  return S({ scheme: n, path: [], values: r, forms: e, shown: !0 }), r;
+}, W = (n, e) => {
+  const { onSubmit: r, onChange: s, onEqual: t, disabled: u, onDirty: d, onFormDirty: h, onChangeEvent: y, defaultValues: v } = e, x = { onSubmit: r }, j = { onChange: s }, f = {
     isActive: !1,
     isSubmitted: !1,
     dirtyCount: 0
-  }, i = {}, x = /* @__PURE__ */ new Set(), V = {
+  }, i = {}, F = /* @__PURE__ */ new Set(), E = {
     subscribers: [],
     names: {}
   };
-  S(n, [], h ?? {}, (o, c, u) => {
-    i[c] = {
+  p(n, [], v ?? {}, (o, a, c) => {
+    i[a] = {
       error: null,
       isDirty: !1,
-      value: u,
-      // текущее (динамическое) состояние поля. Значение равно переданному дефолтному, либо: определяется как дефолтное значение компонента формы в момент его монтирования, а до этого - undefined.
-      startValue: u ?? o.defaultValue,
-      // начальное (стартовое) значение (равно переданному дефолтному, либо значению формы по умолчанию). Исходя из сравнения текущего значения со стартовым, можно понять, модифицированно ли поле
+      value: c,
+      // текущее (динамическое) состояние поля. Значение равно переданному дефолтному, либо: определяется как стартовое значение в момент монтирования поля, а до этого - undefined. Поле, которое скрыло условие, значения не имеет.
+      startValue: c ?? o.defaultValue,
+      // начальное (стартовое) значение (равно переданному дефолтному, либо значению формы по умолчанию). С него начинает поле при монтировании, в том числе снова показанное условием; исходя из сравнения текущего значения со стартовым, можно понять, модифицированно ли поле
       defaultValue: o.defaultValue,
       // дефолтное значение компонента формы
       rerender: () => {
@@ -202,98 +240,100 @@ const A = O({}), N = (n) => {
       validate: o.validate
     };
   });
-  const B = (o, c) => {
-    y?.({ name: o, isDirty: c }), c && l.dirtyCount === 0 && m?.(!0), !c && l.dirtyCount === 1 && m?.(!1), l.dirtyCount += c ? 1 : -1;
+  const T = (o, a) => {
+    d?.({ name: o, isDirty: a }), a && f.dirtyCount === 0 && h?.(!0), !a && f.dirtyCount === 1 && h?.(!1), f.dirtyCount += a ? 1 : -1;
+  }, O = () => {
+    for (const o in i)
+      i[o].isDirty && (T(o, !1), i[o].isDirty = !1);
   };
   return {
-    submitRef: v,
-    changeRef: D,
+    submitRef: x,
+    changeRef: j,
     scheme: n,
-    disabled: f,
+    disabled: u,
     activate() {
-      l.isActive = !0;
+      f.isActive = !0;
     },
     disactivate() {
-      l.isActive = !1;
+      f.isActive = !1;
     },
-    setError(o, c) {
-      const u = this.getForm(o);
-      u && (u.error = {
+    setError(o, a) {
+      const c = this.getForm(o);
+      c && (c.error = {
         error: !0,
-        messages: [c.message]
-      }, u.rerender());
+        messages: [a.message]
+      }, c.rerender());
     },
     setFocus(o) {
-      const c = this.getForm(o);
-      c && c.focus && c.focus();
+      const a = this.getForm(o);
+      a && a.focus && a.focus();
     },
-    setValue(o, c) {
-      const u = this.getForm(o);
-      u && u.value !== c && this.onChange(o, c);
+    setValue(o, a) {
+      const c = this.getForm(o);
+      c && c.value !== a && this.onChange(o, a);
     },
     getValues() {
-      return T(n, i);
+      return q(n, i);
     },
     async handleSubmit() {
-      if (f)
+      if (u)
         return;
-      l.isSubmitted = !0;
-      let o = !1, c = !1;
-      for (const u in i) {
-        const a = i[u];
-        if (a.value !== void 0) {
-          const g = a.validate(a.value);
-          g && (c = !0, a.error = g, a.rerender(), !o && a.focus && (a.focus(), o = !0));
+      f.isSubmitted = !0;
+      let o = !1, a = !1;
+      if (C(n, [], i, (c) => {
+        const l = i[c];
+        if (l.value !== void 0) {
+          const g = l.validate(l.value);
+          g && (a = !0, l.error = g, l.rerender(), !o && l.focus && (l.focus(), o = !0));
         }
-      }
-      if (!c) {
-        if (l.dirtyCount === 0 && t) {
+      }), !a) {
+        if (f.dirtyCount === 0 && t) {
           t();
           return;
         }
-        if (!v.onSubmit)
+        if (!x.onSubmit)
           return;
-        const u = T(n, i);
-        await v.onSubmit(u, {
-          setError: (a, g) => {
-            const F = this.getForm(a);
-            F.error = {
+        const c = q(n, i);
+        await x.onSubmit(c, {
+          setError: (l, g) => {
+            const V = this.getForm(l);
+            V.error = {
               error: !0,
               messages: [g.message]
-            }, F.rerender();
+            }, V.rerender();
           }
-        }).catch((a) => {
-          console.log("[formkit] submit exception:", a);
+        }).catch((l) => {
+          console.log("[formkit] submit exception:", l);
         });
       }
     },
-    reset(o, { asDirty: c }) {
-      S(n, [], o, (u, a, g) => {
-        if (g === void 0 && i[a].value === void 0)
+    reset(o, { asDirty: a }) {
+      p(n, [], o, (c, l, g) => {
+        if (g === void 0 && i[l].value === void 0)
           return;
-        if (V.names[a] && g === void 0) {
-          i[a].value = void 0;
+        if (E.names[l] && g === void 0) {
+          i[l].value = void 0;
           return;
         }
-        const F = g ?? u.defaultValue;
-        c || (i[a].startValue = F, i[a].isDirty = !1), i[a].value !== F && this.onChange(a, F);
-      }), c || (l.dirtyCount = 0, l.isSubmitted = !1), V.subscribers.forEach(({ visualizeEvalueatedForms: u }) => {
-        u();
+        const V = g ?? c.defaultValue;
+        a || (i[l].startValue = V), i[l].value !== V && this.onChange(l, V);
+      }), a || (O(), f.isSubmitted = !1), E.subscribers.forEach(({ visualizeEvalueatedForms: c }) => {
+        c();
       });
     },
     setAsDefault() {
-      S(n, [], {}, (o, c) => {
-        i[c].startValue = i[c].value, i[c].isDirty = !1;
-      }), l.dirtyCount = 0, l.isSubmitted = !1;
+      p(n, [], {}, (o, a) => {
+        i[a].startValue = i[a].value ?? i[a].defaultValue;
+      }), O(), f.isSubmitted = !1;
     },
-    registry(o, c) {
-      return i[o].rerender = c, i[o].value === void 0 && (i[o].value = i[o].defaultValue), {
+    registry(o, a) {
+      return i[o].rerender = a, i[o].value === void 0 && (i[o].value = E.names[o] ? i[o].defaultValue : i[o].startValue), {
         unregistry() {
           if (i[o].rerender = () => {
-          }, i[o].focus = void 0, l.isActive) {
-            i[o].value = void 0;
-            const u = !M(i[o].startValue, i[o].defaultValue);
-            i[o].isDirty !== u && B(o, u), i[o].isDirty = u;
+          }, i[o].focus = void 0, f.isActive) {
+            i[o].value = void 0, i[o].error = null;
+            const c = E.names[o] ? !P(i[o].startValue, i[o].defaultValue) : !1;
+            i[o].isDirty !== c && T(o, c), i[o].isDirty = c;
           }
         }
       };
@@ -301,52 +341,52 @@ const A = O({}), N = (n) => {
     getForm(o) {
       return i[o];
     },
-    subscribeToForm(o, c) {
-      const u = { callback: c }, a = this.getForm(o);
-      return a.subscribers.push(u), () => {
-        a.subscribers = a.subscribers.filter((g) => g !== u);
+    subscribeToForm(o, a) {
+      const c = { callback: a }, l = this.getForm(o);
+      return l.subscribers.push(c), () => {
+        l.subscribers = l.subscribers.filter((g) => g !== c);
       };
     },
     subscribeToAny(o) {
-      return x.add(o), () => {
-        x.delete(o);
+      return F.add(o), () => {
+        F.delete(o);
       };
     },
     getNames() {
       return Object.keys(i);
     },
-    registryExtraForm(o, c) {
-      const u = { visualizeEvalueatedForms: c };
-      return o.forEach((a) => {
-        V.names[a] = !0;
-      }), V.subscribers.push(u), {
+    registryExtraForm(o, a) {
+      const c = { visualizeEvalueatedForms: a };
+      return o.forEach((l) => {
+        E.names[l] = !0;
+      }), E.subscribers.push(c), {
         unregistry() {
-          V.subscribers = V.subscribers.filter((a) => a !== u);
+          E.subscribers = E.subscribers.filter((l) => l !== c);
         }
       };
     },
-    onChange(o, c) {
-      const u = this.getForm(o), a = !M(c, u.startValue);
-      u.isDirty !== a && B(o, a), u.isDirty = a, d?.({ name: o, value: c }), (u.error || l.isSubmitted) && (u.error = u.validate(c) || null);
-      const g = u.value;
-      u.value = c, u.rerender(), u.subscribers.forEach(({ callback: F }) => {
-        F(c, g);
-      }), x.forEach((F) => {
-        F();
-      }), D.onChange?.(T(n, i));
+    onChange(o, a) {
+      const c = this.getForm(o), l = !P(a, c.startValue);
+      c.isDirty !== l && T(o, l), c.isDirty = l, y?.({ name: o, value: a }), (c.error || f.isSubmitted) && (c.error = c.validate(a) || null);
+      const g = c.value;
+      c.value = a, c.rerender(), c.subscribers.forEach(({ callback: V }) => {
+        V(a, g);
+      }), F.forEach((V) => {
+        V();
+      }), j.onChange?.(q(n, i));
     }
   };
-}, Y = (n, r) => {
-  const e = U(null);
-  e.current === null && (e.current = H(n, r));
-  const s = e.current;
-  return $(() => {
-    e.current && (e.current.submitRef.onSubmit = r.onSubmit, e.current.changeRef.onChange = r.onChange);
-  }, [r.onSubmit, r.onChange]), {
+}, rr = (n, e) => {
+  const r = G(null);
+  r.current === null && (r.current = W(n, e));
+  const s = r.current;
+  return D(() => {
+    r.current && (r.current.submitRef.onSubmit = e.onSubmit, r.current.changeRef.onChange = e.onChange);
+  }, [e.onSubmit, e.onChange]), {
     manager: s,
-    useValue: (t) => N(t),
-    reset: (t, f = {}) => {
-      s.reset(t, f);
+    useValue: (t) => M(t),
+    reset: (t, u = {}) => {
+      s.reset(t, u);
     },
     setAsDefault: () => {
       s.setAsDefault();
@@ -354,11 +394,11 @@ const A = O({}), N = (n) => {
     setFocus: (t) => {
       s.setFocus(t);
     },
-    setError: (t, f) => {
-      s.setError(t, f);
+    setError: (t, u) => {
+      s.setError(t, u);
     },
-    setValue: (t, f) => {
-      s.setValue(t, f);
+    setValue: (t, u) => {
+      s.setValue(t, u);
     },
     getValue: (t) => s.getForm(t).value,
     getValues: () => s.getValues(),
@@ -366,91 +406,99 @@ const A = O({}), N = (n) => {
       await s.handleSubmit();
     },
     // prettier-ignore
-    subscribe: (t, f) => s.subscribeToForm(t, f),
+    subscribe: (t, u) => s.subscribeToForm(t, u),
     // подписка на любое изменение значений формы (для гейтов поверх всех полей)
     subscribeAny: (t) => s.subscribeToAny(t),
     // плоский список имён всех полей (dotted-пути; вложенные context раскрыты)
     getNames: () => s.getNames()
   };
-}, Z = ({ manager: n }) => (p(() => {
+}, er = ({ manager: n }) => ($(() => {
   n.activate();
-}, []), $(() => () => {
+}, []), D(() => () => {
   n.disactivate();
-}, []), /* @__PURE__ */ b(A.Provider, { value: n, children: /* @__PURE__ */ b(C, { scheme: n.scheme, path: [] }) })), w = (n) => {
+}, []), /* @__PURE__ */ b(w.Provider, { value: n, children: /* @__PURE__ */ b(A, { scheme: n.scheme, path: [] }) })), R = (n) => {
   try {
     n();
-  } catch (r) {
-    return r && typeof r == "string" ? {
+  } catch (e) {
+    return e && typeof e == "string" ? {
       error: !0,
-      messages: [r]
-    } : r instanceof Array && r.every((e) => e && typeof e == "string") ? {
+      messages: [e]
+    } : e instanceof Array && e.every((r) => r && typeof r == "string") ? {
       error: !0,
-      messages: r
+      messages: e
     } : {
       error: !0
     };
   }
-}, k = (n) => (r, e) => {
-  const s = n.getRequireCheck(e), { $rules: t = {}, ...f } = e, { validate: y, required: m } = t;
+}, tr = (n) => (e, r) => {
+  const s = n.getRequireCheck(r), { $rules: t = {}, ...u } = r, { validate: d, required: h } = t;
   return {
     type: "form",
-    name: r,
+    name: e,
     defaultValue: n.defaultValue,
-    Form: n.getForm(f),
-    validate: (d) => {
-      if (m) {
-        const h = w(() => s(d));
-        if (h)
-          return h;
-        if (y) {
-          const v = w(() => y(d));
-          if (v)
-            return v;
+    Form: n.getForm(u),
+    validate: (y) => {
+      if (h) {
+        const v = R(() => s(y));
+        if (v)
+          return v;
+        if (d) {
+          const x = R(() => d(y));
+          if (x)
+            return x;
         }
         return;
       }
-      if (y && !w(() => s(d))) {
-        const v = w(() => y(d));
-        if (v)
-          return v;
+      if (d && !R(() => s(y))) {
+        const x = R(() => d(y));
+        if (x)
+          return x;
       }
     }
   };
-}, I = (n) => (r) => (...e) => ({
+}, nr = (n) => (e) => (...r) => ({
   type: "layout",
-  Layout: n(r),
-  childs: e
-}), rr = ({
+  Layout: n(e),
+  childs: r
+}), sr = ({
   getItems: n,
-  getController: r
+  getController: e
 }) => ({
   type: "extra",
-  items: n((e) => (s) => ({ type: "registry", name: e, getForm: s })),
-  getController: r
-}), er = (n) => (...r) => ({
+  items: n((r) => (s) => ({ type: "registry", name: r, getForm: s })),
+  getController: e
+}), or = (n) => (...e) => ({
   type: "context",
   context: n,
+  childs: e
+}), ir = (n, e) => (...r) => ({
+  type: "condition",
+  depended: n,
+  canActivate: e.canActivate,
+  nullable: !1,
   childs: r
-}), tr = (n, r) => (...e) => ({
+}), ur = (n, e) => (...r) => ({
   type: "condition",
   depended: n,
-  canActivate: r.canActivate,
-  childs: e
-}), sr = ({ hidden: n }) => (...r) => ({
+  canActivate: e.canActivate,
+  nullable: !0,
+  childs: r
+}), cr = ({ hidden: n }) => (...e) => ({
   type: "visability",
   hidden: n ?? !1,
-  childs: r
+  childs: e
 });
 export {
-  tr as Condition,
-  er as Context,
-  Z as FormLayout,
-  sr as Visablility,
-  rr as createExtraForm,
-  k as createForm,
-  I as createLayout,
-  X as createUseValue,
-  Y as useForm,
-  W as useSetValue,
-  N as useValue
+  or as Context,
+  er as FormLayout,
+  ur as NullableCondition,
+  ir as OptionalCondition,
+  cr as Visablility,
+  sr as createExtraForm,
+  tr as createForm,
+  nr as createLayout,
+  I as createUseValue,
+  rr as useForm,
+  k as useSetValue,
+  M as useValue
 };

package/dist/core/builders/syntax.d.ts

@@ -1,8 +1,11 @@
 import { SchemeItems } from '../types';
-export declare const Context: <N extends string>(context: N) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Context<N, T>;
-export declare const Condition: (depended: string, props: {
+interface ConditionProps {
     canActivate: (value: any) => boolean;
-}) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Condition<T>;
+}
+export declare const Context: <N extends string>(context: N) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Context<N, T>;
+export declare const OptionalCondition: (depended: string, props: ConditionProps) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Condition<T, false>;
+export declare const NullableCondition: (depended: string, props: ConditionProps) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Condition<T, true>;
 export declare const Visablility: ({ hidden }: {
     hidden?: boolean;
 }) => <T extends SchemeItems.All[]>(...childs: T) => SchemeItems.Visablility<T>;
+export {};

package/dist/core/extract.d.ts

@@ -1,10 +1,13 @@
 import { SchemeItems } from './types';
 import { Compute, UnionToIntersection } from '../utils/typescript';
+type OrNull<T> = {
+    [K in keyof T]: T[K] | null;
+};
 type ExtractValue<T> = T extends SchemeItems.Form<infer N, infer V> ? {
     [K in N]: V;
 } : T extends SchemeItems.Layout<infer C> ? ExtractValue<C[number]> : T extends SchemeItems.Context<infer N, infer C> ? {
     [K in N]: Compute<UnionToIntersection<ExtractValue<C[number]>>>;
-} : T extends SchemeItems.Condition<infer C> ? Partial<ExtractValue<C[number]>> : T extends SchemeItems.Visablility<infer C> ? Partial<ExtractValue<C[number]>> : T extends SchemeItems.Extra<string, infer C> ? Partial<ExtractValue<ReturnType<C[number]['getForm']>>> : never;
+} : T extends SchemeItems.Condition<infer C, true> ? OrNull<ExtractValue<C[number]>> : T extends SchemeItems.Condition<infer C> ? Partial<ExtractValue<C[number]>> : T extends SchemeItems.Visablility<infer C> ? Partial<ExtractValue<C[number]>> : T extends SchemeItems.Extra<string, infer C> ? Partial<ExtractValue<ReturnType<C[number]['getForm']>>> : never;
 type ExtractValues<T> = Compute<UnionToIntersection<ExtractValue<T>>>;
 type ExtractFlatValue<T, A extends string | null> = T extends SchemeItems.Form<infer N, infer V> ? {
     [K in A extends null ? N : `${A}.${N}`]: V;

package/dist/core/types.d.ts

@@ -33,10 +33,11 @@ export declare namespace SchemeItems {
         name: N;
         getForm: <Q extends N>(name: Q, remove: () => void) => T;
     }
-    interface Condition<T extends All[] = All[]> {
+    interface Condition<T extends All[] = All[], Nullable extends boolean = boolean> {
         type: 'condition';
         depended: string;
         canActivate: (value: any) => boolean;
+        nullable: Nullable;
         childs: T;
     }
     interface Visablility<T extends All[] = All[]> {

package/dist/manager/read-scheme.d.ts

@@ -1,5 +1,8 @@
+import { Forms } from './manager';
 import { FieldValues } from '../types';
 import { SchemeItems } from '../core/types';
 type cb = (item: SchemeItems.Form, name: string, value?: any) => void;
+type shownCb = (name: string) => void;
 declare const readScheme: (scheme: SchemeItems.All[], path: string[], values: FieldValues, callback: cb) => void;
-export { readScheme };
+declare const readShown: (scheme: SchemeItems.All[], path: string[], forms: Forms, callback: shownCb) => void;
+export { readScheme, readShown };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@companix/formkit",
-  "version": "0.0.29",
+  "version": "0.0.31",
   "module": "./dist/bundle.es.js",
   "types": "./dist/index.d.ts",
   "type": "module",

package/dist/Condition.d.ts

@@ -1,7 +0,0 @@
-interface Props {
-    name: string;
-    canActivate: (value: any) => boolean;
-    children: React.ReactNode;
-}
-export declare const Condition: ({ canActivate, name, children }: Props) => import("react/jsx-runtime").JSX.Element | null;
-export {};