@reformer/renderer-json 1.0.0-beta.1

package/dist/components/json-form-renderer.d.ts

@@ -0,0 +1,80 @@
+import { ReactNode } from 'react';
+import { RenderBehaviorFn, RenderSchemaProxy } from '@reformer/renderer-react';
+import { JsonFormSchema } from '../types/json-schema';
+/**
+ * Props of {@link JsonFormRenderer}.
+ *
+ * @typeParam T - Тип формы (`getReformerForm<T>()`).
+ */
+export interface JsonFormRendererProps<T> {
+    /** JSON-схема формы. См. {@link JsonFormSchema}. */
+    schema: JsonFormSchema;
+    /** Опциональный behavior: hideWhen/patchProps/onComponentEvent поверх готовой схемы. */
+    renderBehavior?: RenderBehaviorFn<T>;
+    /** Колбэк, получающий построенный `RenderSchemaProxy` для внешних манипуляций. */
+    onSchemaReady?: (schema: RenderSchemaProxy<T>) => void;
+}
+/**
+ * Главный компонент пакета. Рендерит форму, описанную JSON-схемой.
+ *
+ * Должен использоваться внутри {@link JsonRendererProvider}, который снабжает рендерер
+ * реестром компонентов. Без реестра компонент бросит исключение при попытке резолва.
+ *
+ * @typeParam T - Тип формы.
+ *
+ * @example
+ * ```tsx
+ * import { useMemo } from 'react';
+ * import { createForm } from '@reformer/core';
+ * import { Input, FormField } from '@reformer/ui-kit';
+ * import {
+ *   JsonFormRenderer,
+ *   JsonRendererProvider,
+ *   defineRegistry,
+ *   FIELD_WRAPPER,
+ *   type JsonFormSchema,
+ * } from '@reformer/renderer-json';
+ *
+ * const schema: JsonFormSchema = {
+ *   version: '1.0',
+ *   root: {
+ *     component: 'Box',
+ *     children: [
+ *       { selector: 'email', model: 'email', component: 'Input' },
+ *     ],
+ *   },
+ * };
+ *
+ * type MyForm = { email: string };
+ *
+ * function MyFormPage() {
+ *   // form живёт в page-state и передаётся в registry через closure (см. ниже)
+ *   const form = useMemo(() => createForm<MyForm>({
+ *     form: { email: { value: '', component: Input, componentProps: { label: 'Email' } } },
+ *   }), []);
+ *
+ *   // registry с FormRoot-closure: компоненты, использующие форму, получают её
+ *   // через componentProps closure (JsonFormRenderer НЕ имеет form-prop'а — это by-design,
+ *   // т.к. JSON-схема статична, а форма runtime).
+ *   const registry = useMemo(() => defineRegistry((reg) => {
+ *     reg.field('Input', Input);
+ *     reg.container('Box', ({ children }) => <div>{children}</div>);
+ *     reg.container(FIELD_WRAPPER, FormField);
+ *   }), []);
+ *
+ *   return (
+ *     <JsonRendererProvider settings={{ registry, form }}>
+ *       <JsonFormRenderer schema={schema} />
+ *     </JsonRendererProvider>
+ *   );
+ * }
+ * ```
+ *
+ * **Note**: `JsonFormRenderer` принимает ТОЛЬКО `{ schema, renderBehavior?, onSchemaReady? }`.
+ * Форма передаётся в render-pipeline через {@link JsonRendererProvider} settings или через
+ * closure-pattern с {@link createRenderSchemaFromJson} + `FormRoot.__selfManagedChildren = true`
+ * (см. recipe `multi-step-from-json` в `docs/llms/`).
+ *
+ * @see [docs/llms/01-overview.md](../../docs/llms/01-overview.md)
+ */
+export declare function JsonFormRenderer<T>({ schema, renderBehavior, onSchemaReady, }: JsonFormRendererProps<T>): ReactNode;

package/dist/context/json-renderer-context.d.ts

@@ -0,0 +1,51 @@
+import { ReactNode } from 'react';
+import { RendererSettings } from '@reformer/renderer-react';
+import { ComponentRegistry } from '../registry/types';
+/**
+ * Расширенные настройки рендерера: всё из `RendererSettings` плюс реестр.
+ */
+export interface JsonRendererSettings extends RendererSettings {
+    /** Реестр компонентов и source-значений. См. {@link defineRegistry}. */
+    registry?: ComponentRegistry;
+}
+/**
+ * Props {@link JsonRendererProvider}.
+ */
+export interface JsonRendererProviderProps {
+    /** Настройки рендерера, как минимум содержащие `registry`. */
+    settings: JsonRendererSettings;
+    /** Дочернее поддерево, в котором доступен `JsonFormRenderer` и `useJsonRendererSettings`. */
+    children: ReactNode;
+}
+/**
+ * Провайдер настроек для {@link JsonFormRenderer}. Прокидывает реестр и
+ * fieldWrapper во вложенные компоненты через React Context.
+ *
+ * Поддерживает вложенность: внутренний провайдер сливается с внешним
+ * (внешний имеет приоритет в случае дублей имён в реестре).
+ *
+ * @example
+ * ```tsx
+ * <JsonRendererProvider settings={{ registry, fieldWrapper: FormField }}>
+ *   <JsonFormRenderer schema={schema} form={form} />
+ * </JsonRendererProvider>
+ * ```
+ */
+export declare function JsonRendererProvider({ settings, children }: JsonRendererProviderProps): ReactNode;
+/**
+ * Хук для чтения текущих настроек {@link JsonRendererProvider}.
+ *
+ * В режиме разработки бросает исключение, если вызван вне провайдера или
+ * если в провайдере не передан `registry`.
+ *
+ * @returns Текущие {@link JsonRendererSettings}.
+ *
+ * @example
+ * ```tsx
+ * function MyControl() {
+ *   const { registry } = useJsonRendererSettings();
+ *   return <span>{registry?.has('Input') ? 'ready' : 'not registered'}</span>;
+ * }
+ * ```
+ */
+export declare function useJsonRendererSettings(): JsonRendererSettings;

package/dist/converter/json-to-render-schema.d.ts

@@ -0,0 +1,31 @@
+import { RenderSchemaFn } from '@reformer/renderer-react';
+import { JsonFormSchema } from '../types/json-schema';
+import { ComponentRegistry } from '../registry/types';
+/**
+ * Создаёт RenderSchemaFn из JSON-схемы
+ *
+ * Конвертирует JSON-схему в функцию RenderSchemaFn, которую можно
+ * передать в FormRenderer из @reformer/renderer-react.
+ *
+ * @param schema - JSON-схема формы
+ * @param registry - Реестр компонентов для резолва имён
+ * @returns RenderSchemaFn для FormRenderer
+ *
+ * @example
+ * ```typescript
+ * const jsonSchema = {
+ *   root: {
+ *     component: 'Box',
+ *     children: [
+ *       { model: 'email' },
+ *       { model: 'password', component: 'InputPassword' }
+ *     ]
+ *   }
+ * };
+ *
+ * const renderSchema = createRenderSchemaFromJson(jsonSchema, registry);
+ *
+ * <FormRenderer render={renderSchema} settings={{ fieldWrapper: FormField }} />
+ * ```
+ */
+export declare function createRenderSchemaFromJson<T>(schema: JsonFormSchema, registry: ComponentRegistry): RenderSchemaFn<T>;

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @reformer/renderer-json
+ *
+ * JSON-based form renderer for @reformer ecosystem
+ *
+ * @packageDocumentation
+ */
+export { JsonFormRenderer } from './components/json-form-renderer';
+export type { JsonFormRendererProps } from './components/json-form-renderer';
+export type { JsonFormSchema, JsonNode } from './types/json-schema';
+export { isFieldNode, isContainerNode } from './types/json-schema';
+export { defineRegistry } from './registry/component-registry';
+export { FIELD_WRAPPER } from './registry/constants';
+export type { ComponentRegistry, ComponentMetadata, RegistryBuilder } from './registry/types';
+export { JsonRendererProvider, useJsonRendererSettings } from './context/json-renderer-context';
+export type { JsonRendererSettings, JsonRendererProviderProps, } from './context/json-renderer-context';
+export { createRenderSchemaFromJson } from './converter/json-to-render-schema';

package/dist/index.js

@@ -0,0 +1,212 @@
+import { jsx as y } from "react/jsx-runtime";
+import { useContext as g, createContext as w, useMemo as m, createElement as P } from "react";
+import { RenderNodeComponent as R, createRenderSchema as C, FormRenderer as F } from "@reformer/renderer-react";
+import { createFieldPath as $ } from "@reformer/core";
+class u {
+  own = /* @__PURE__ */ new Map();
+  parent = null;
+  get(e) {
+    return this.own.get(e) ?? this.parent?.get(e);
+  }
+  getSource(e) {
+    const r = this.get(e);
+    if (!(!r || r.type !== "source"))
+      return r.component;
+  }
+  has(e) {
+    return this.own.has(e) || (this.parent?.has(e) ?? !1);
+  }
+  names() {
+    const e = this.parent?.names() ?? [], r = Array.from(this.own.keys());
+    return [.../* @__PURE__ */ new Set([...e, ...r])];
+  }
+  _set(e, r) {
+    this.own.has(e) && console.warn(`[ComponentRegistry] Overwriting entry: ${e}`), this.own.set(e, r);
+  }
+  static withParent(e, r) {
+    const n = new u();
+    return n.parent = e, r.own.forEach((o, i) => {
+      n.own.set(i, o);
+    }), n;
+  }
+}
+function _(t) {
+  const e = new u();
+  return t({
+    field(n, o, i) {
+      e._set(n, { component: o, type: "field", description: i });
+    },
+    container(n, o, i) {
+      e._set(n, { component: o, type: "container", description: i });
+    },
+    source(n, o, i) {
+      e._set(n, { component: o, type: "source", description: i });
+    }
+  }), e;
+}
+const b = "$fieldWrapper", l = w({});
+function M({ settings: t, children: e }) {
+  const r = g(l), n = m(() => r.registry && t.registry ? u.withParent(r.registry, t.registry) : t.registry ?? r.registry, [r.registry, t.registry]), o = m(() => {
+    const i = n?.get(b)?.component;
+    return {
+      ...r,
+      ...t,
+      registry: n,
+      fieldWrapper: t.fieldWrapper ?? i ?? r.fieldWrapper
+    };
+  }, [r, t, n]);
+  return /* @__PURE__ */ y(l.Provider, { value: o, children: e });
+}
+function E() {
+  return g(l);
+}
+function h(t, e) {
+  const r = e.split(/\.|\[|\]/).filter(Boolean);
+  let n = t;
+  for (const o of r) {
+    if (n == null)
+      throw new Error(`Invalid field path: "${e}" - segment "${o}" not found`);
+    const i = parseInt(o, 10);
+    isNaN(i) ? n = n[o] : n = n[i];
+  }
+  if (n == null)
+    throw new Error(`Invalid field path: "${e}" - path resolved to null/undefined`);
+  return n;
+}
+function p(t) {
+  if (t === null || typeof t != "object") return !1;
+  const e = t;
+  return typeof e.model == "string" || typeof e.component == "string";
+}
+function S(t) {
+  return t !== null && typeof t == "object" && p(t.$template);
+}
+function x(t, e) {
+  const r = $(), n = s(t, r, e), o = ({ control: i }) => P(R, { node: n, form: i });
+  return o.displayName = "TemplateItemFC", o;
+}
+function a(t, e, r) {
+  if (typeof t == "string") {
+    const n = r.get(t);
+    if (n && n.type === "source") {
+      const o = n.component;
+      return typeof o == "function" ? (...i) => {
+        const c = o(...i);
+        return p(c) ? s(c, i[0], r) : c;
+      } : o;
+    }
+    return t;
+  }
+  if (S(t))
+    return x(t.$template, r);
+  if (p(t))
+    return s(t, e, r);
+  if (Array.isArray(t))
+    return t.map((n) => a(n, e, r));
+  if (typeof t == "function")
+    return (...n) => {
+      const o = t(...n);
+      return p(o) ? s(o, n[0], r) : o;
+    };
+  if (t !== null && typeof t == "object") {
+    const n = t, o = {};
+    let i = !1;
+    for (const c of Object.keys(n)) {
+      const f = a(n[c], e, r);
+      f !== n[c] && (i = !0), o[c] = f;
+    }
+    return i ? o : t;
+  }
+  return t;
+}
+function d(t, e, r) {
+  const n = {};
+  for (const o of Object.keys(t)) {
+    const i = t[o];
+    if ((o === "control" || o.endsWith("Control")) && typeof i == "string") {
+      n[o] = h(e, i);
+      continue;
+    }
+    if ((o === "component" || o.endsWith("Component")) && typeof i == "string") {
+      const c = r.get(i);
+      if (c) {
+        n[o] = c.component;
+        continue;
+      }
+    }
+    n[o] = a(i, e, r);
+  }
+  return n;
+}
+function I(t, e) {
+  return typeof t.model == "string" && t.model.length > 0 ? t.model : typeof t.selector == "string" && typeof t.component == "string" && !t.children && e.get(t.component)?.type === "field" ? t.selector : null;
+}
+function s(t, e, r) {
+  const n = I(t, r);
+  if (n !== null) {
+    const i = {
+      component: h(e, n)
+    };
+    return t.selector && (i.selector = t.selector), t.componentProps && (i.componentProps = d(
+      t.componentProps,
+      e,
+      r
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    )), i;
+  }
+  if (t.component) {
+    const o = r.get(t.component);
+    if (!o)
+      throw new Error(
+        `Component "${t.component}" not found in registry. Available components: ${r.names().join(", ")}`
+      );
+    if (o.type === "source")
+      throw new Error(
+        `Entry "${t.component}" is a 'source' and cannot be used as component`
+      );
+    const i = {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      component: o.component
+    };
+    return t.selector && (i.selector = t.selector), t.componentProps && (i.componentProps = d(
+      t.componentProps,
+      e,
+      r
+    )), t.children && t.children.length > 0 && (i.children = t.children.map((c) => s(c, e, r))), i;
+  }
+  throw new Error(
+    `Invalid JSON node: must have either "model" (for fields) or "component" (for containers). Got: ${JSON.stringify(t)}`
+  );
+}
+function J(t, e) {
+  return (r) => s(t.root, r, e);
+}
+function L({
+  schema: t,
+  renderBehavior: e,
+  onSchemaReady: r
+}) {
+  const { registry: n, ...o } = E(), i = m(() => {
+    const c = J(t, n), f = C(c);
+    return e && e(f), f;
+  }, [t, n, e]);
+  return m(() => {
+    r && r(i);
+  }, [i]), /* @__PURE__ */ y(F, { render: i, settings: o });
+}
+function W(t) {
+  return typeof t.model == "string" && t.model.length > 0;
+}
+function V(t) {
+  return typeof t.component == "string" && !W(t);
+}
+export {
+  b as FIELD_WRAPPER,
+  L as JsonFormRenderer,
+  M as JsonRendererProvider,
+  J as createRenderSchemaFromJson,
+  _ as defineRegistry,
+  V as isContainerNode,
+  W as isFieldNode,
+  E as useJsonRendererSettings
+};

package/dist/registry/component-registry.d.ts

@@ -0,0 +1,39 @@
+import { ComponentRegistry, ComponentMetadata, RegistryBuilder } from './types';
+export declare class ComponentRegistryImpl implements ComponentRegistry {
+    private own;
+    private parent;
+    get(name: string): ComponentMetadata | undefined;
+    getSource<T = unknown>(name: string): T | undefined;
+    has(name: string): boolean;
+    names(): string[];
+    _set(name: string, metadata: ComponentMetadata): void;
+    static withParent(parent: ComponentRegistry, child: ComponentRegistry): ComponentRegistry;
+}
+/**
+ * Создаёт реестр компонентов через builder-callback.
+ *
+ * Реестр обязателен для работы {@link JsonFormRenderer} — иначе компоненты,
+ * упомянутые в JSON-схеме, не отрезолвятся.
+ *
+ * @param fn - Builder-callback. Получает {@link RegistryBuilder} с методами `field`, `container`, `source`.
+ * @returns Готовый {@link ComponentRegistry}, который кладётся в `JsonRendererProvider`.
+ *
+ * @example
+ * ```typescript
+ * import { defineRegistry, FIELD_WRAPPER } from '@reformer/renderer-json';
+ * import { Input, Select, FormField } from '@reformer/ui-kit';
+ *
+ * const registry = defineRegistry((reg) => {
+ *   reg.field('Input', Input);
+ *   reg.field('Select', Select);
+ *   reg.container(FIELD_WRAPPER, FormField);
+ *   reg.source('LOAN_TYPES', [
+ *     { value: 'consumer', label: 'Потребительский' },
+ *     { value: 'mortgage', label: 'Ипотека' },
+ *   ]);
+ * });
+ * ```
+ *
+ * @see [docs/llms/03-registry.md](../../docs/llms/03-registry.md)
+ */
+export declare function defineRegistry(fn: (reg: RegistryBuilder) => void): ComponentRegistry;

package/dist/registry/constants.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Зарезервированный ключ реестра для контейнера-обёртки полей.
+ *
+ * Зарегистрируй компонент под этим именем (обычно `FormField` из `@reformer/ui-kit`),
+ * чтобы каждое поле получало label, error и hint автоматически.
+ *
+ * @example
+ * ```typescript
+ * import { defineRegistry, FIELD_WRAPPER } from '@reformer/renderer-json';
+ * import { FormField } from '@reformer/ui-kit';
+ *
+ * const registry = defineRegistry((reg) => {
+ *   reg.container(FIELD_WRAPPER, FormField);
+ * });
+ * ```
+ */
+export declare const FIELD_WRAPPER = "$fieldWrapper";

package/dist/registry/types.d.ts

@@ -0,0 +1,54 @@
+import { ComponentType } from 'react';
+/**
+ * Запись реестра. Хранит сам компонент (или source-значение) и его роль.
+ *
+ * @typeParam P - Пропсы компонента (для `field`/`container`).
+ *
+ * @example
+ * ```typescript
+ * const meta: ComponentMetadata = registry.get('Input')!;
+ * meta.type; // 'field'
+ * ```
+ */
+export interface ComponentMetadata<P = any> {
+    component: ComponentType<P> | unknown;
+    type: 'field' | 'container' | 'source';
+    description?: string;
+}
+/**
+ * Read-only API реестра, доступное в рантайме.
+ *
+ * Создаётся через {@link defineRegistry}. Передаётся в `JsonRendererProvider`
+ * через `settings.registry`.
+ *
+ * @example
+ * ```typescript
+ * if (registry.has('Input')) {
+ *   registry.get('Input'); // ComponentMetadata
+ * }
+ * registry.names(); // ['Input', 'Box', 'LOAN_TYPES', ...]
+ * ```
+ */
+export interface ComponentRegistry {
+    get(name: string): ComponentMetadata | undefined;
+    getSource<T = unknown>(name: string): T | undefined;
+    has(name: string): boolean;
+    names(): string[];
+}
+/**
+ * Builder, который попадает в callback {@link defineRegistry}.
+ *
+ * @example
+ * ```typescript
+ * defineRegistry((reg: RegistryBuilder) => {
+ *   reg.field('Input', Input);
+ *   reg.container('Box', Box);
+ *   reg.source('LOAN_TYPES', LOAN_TYPES);
+ * });
+ * ```
+ */
+export interface RegistryBuilder {
+    field<P>(name: string, component: ComponentType<P>, description?: string): void;
+    container<P>(name: string, component: ComponentType<P>, description?: string): void;
+    source<T>(name: string, value: T, description?: string): void;
+}

package/dist/types/json-schema.d.ts

@@ -0,0 +1,125 @@
+/**
+ * Типы для JSON-схемы формы
+ *
+ * @module reformer/renderer-json/types
+ */
+/**
+ * Унифицированный узел JSON-схемы
+ *
+ * Может представлять:
+ * - Поле формы (если указан `model`)
+ * - Контейнер/компонент (если указан только `component`)
+ * - Поле с кастомным компонентом (если указаны оба)
+ *
+ * @example
+ * ```json
+ * // Поле формы с дефолтным компонентом
+ * { "model": "email" }
+ *
+ * // Поле с кастомным компонентом
+ * { "model": "password", "component": "InputPassword" }
+ *
+ * // Контейнер
+ * { "component": "Box", "children": [...] }
+ * ```
+ */
+export interface JsonNode {
+    /**
+     * Идентификатор узла для renderBehavior (hideWhen, patchProps).
+     * Необязателен — нужен только если к узлу привязано поведение.
+     */
+    selector?: string;
+    /**
+     * Имя компонента из реестра: "Input", "Box", "Section", "Select"
+     *
+     * - Для полей: компонент для рендеринга значения (опционально, по умолчанию Input)
+     * - Для контейнеров: React-компонент контейнера (обязательно)
+     */
+    component?: string;
+    /**
+     * Путь к полю формы (модели): "email", "personalData.firstName", "addresses[0].city"
+     *
+     * Если указан — узел представляет поле формы.
+     */
+    model?: string;
+    /**
+     * Props для компонента (className, title и т.д.)
+     */
+    componentProps?: Record<string, unknown>;
+    /**
+     * Дочерние узлы (для контейнеров)
+     */
+    children?: JsonNode[];
+    /**
+     * Обёртка для узла (например, fieldWrapper)
+     *
+     * @example
+     * ```json
+     * {
+     *   "model": "email",
+     *   "wrapper": {
+     *     "component": "FormField",
+     *     "componentProps": { "className": "col-span-2" }
+     *   }
+     * }
+     * ```
+     */
+    wrapper?: JsonNode;
+}
+/**
+ * Корневая JSON-схема формы
+ *
+ * @example
+ * ```json
+ * {
+ *   "version": "1.0",
+ *   "root": {
+ *     "component": "Box",
+ *     "componentProps": { "className": "space-y-4" },
+ *     "children": [
+ *       { "model": "email" },
+ *       { "model": "password", "component": "InputPassword" }
+ *     ]
+ *   }
+ * }
+ * ```
+ */
+export interface JsonFormSchema {
+    /**
+     * Версия схемы (для миграций)
+     */
+    version?: string;
+    /**
+     * Корневой узел схемы
+     */
+    root: JsonNode;
+}
+/**
+ * Type guard: проверяет, является ли узел полем формы (имеет `model`).
+ *
+ * @param node - Узел JSON-схемы.
+ * @returns `true`, если у узла есть непустое `model`.
+ *
+ * @example
+ * ```typescript
+ * if (isFieldNode(node)) {
+ *   // node.model гарантированно строка
+ *   readField(node.model);
+ * }
+ * ```
+ */
+export declare function isFieldNode(node: JsonNode): boolean;
+/**
+ * Type guard: проверяет, является ли узел контейнером (только `component`, без `model`).
+ *
+ * @param node - Узел JSON-схемы.
+ * @returns `true`, если у узла есть `component`, но нет `model`.
+ *
+ * @example
+ * ```typescript
+ * if (isContainerNode(node)) {
+ *   node.children?.forEach(walk);
+ * }
+ * ```
+ */
+export declare function isContainerNode(node: JsonNode): boolean;

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@reformer/renderer-json",
+  "version": "1.0.0-beta.1",
+  "description": "JSON-based form renderer for @reformer ecosystem",
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "sideEffects": false,
+  "scripts": {
+    "generate:llms": "node ../../scripts/generate-llms-txt .",
+    "build": "npm run generate:llms && vite build",
+    "build:stackblitz": "vite build",
+    "dev": "vite",
+    "test": "node ../../scripts/run-vitest.mjs",
+    "test:watch": "vitest watch"
+  },
+  "keywords": [
+    "react",
+    "forms",
+    "reformer",
+    "renderer",
+    "json",
+    "typescript"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "author": "Alexandr Bukhtatyy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AlexandrBukhtatyy/ReFormer.git",
+    "directory": "packages/reformer-renderer-json"
+  },
+  "homepage": "https://alexandrbukhtatyy.github.io/ReFormer/",
+  "bugs": {
+    "url": "https://github.com/AlexandrBukhtatyy/ReFormer/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@reformer/core": ">=1.1.0",
+    "@reformer/renderer-react": ">=1.0.0",
+    "@reformer/ui-kit": ">=1.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@reformer/ui-kit": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@reformer/core": "*",
+    "@reformer/renderer-react": "*",
+    "@reformer/ui-kit": "*",
+    "@types/node": "^24.10.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
+    "@vitejs/plugin-react": "^5.1.0",
+    "@vitest/utils": "^4.0.8",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "typescript": "^5.9.3",
+    "vite": "^7.2.2",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.0.8"
+  }
+}