@reformer/renderer-json 5.0.2 → 6.1.0-beta.1

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

@@ -0,0 +1,81 @@
+declare const _default: {
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://reformer.dev/schemas/form-schema.schema.json",
+  "title": "ReFormer JSON form schema (M1, string-operator DSL)",
+  "description": "Base meta-schema: validates node structure + operator string syntax ($model/$component/$dataSource). Component-name enum is tightened per-app via buildFormSchemaMetaSchema; $dataSource names and $model paths are checked outside this schema.",
+  "type": "object",
+  "required": ["root"],
+  "additionalProperties": false,
+  "properties": {
+    "$schema": { "type": "string" },
+    "version": { "type": "string" },
+    "root": { "$ref": "#/definitions/node" }
+  },
+  "definitions": {
+    "modelOp": {
+      "type": "string",
+      "pattern": "^\\$model\\(.+\\)$",
+      "description": "Model binding: \"$model(path)\" — path resolved at runtime (not validated here)."
+    },
+    "componentOp": {
+      "type": "string",
+      "pattern": "^\\$component\\(.+\\)$",
+      "description": "Registry component: \"$component(Name)\". Name is tightened to a registry enum by buildFormSchemaMetaSchema."
+    },
+    "node": {
+      "oneOf": [
+        { "$ref": "#/definitions/fieldNode" },
+        { "$ref": "#/definitions/arrayNode" },
+        { "$ref": "#/definitions/containerNode" }
+      ]
+    },
+    "fieldNode": {
+      "type": "object",
+      "required": ["value"],
+      "additionalProperties": false,
+      "properties": {
+        "selector": { "type": "string" },
+        "value": { "$ref": "#/definitions/modelOp" },
+        "component": { "$ref": "#/definitions/componentOp" },
+        "componentProps": { "type": "object" },
+        "wrapper": { "$ref": "#/definitions/node" }
+      }
+    },
+    "arrayNode": {
+      "type": "object",
+      "required": ["array", "item"],
+      "additionalProperties": false,
+      "properties": {
+        "selector": { "type": "string" },
+        "array": { "$ref": "#/definitions/modelOp" },
+        "item": {
+          "type": "object",
+          "required": ["$template"],
+          "additionalProperties": false,
+          "properties": {
+            "$template": { "$ref": "#/definitions/node" }
+          }
+        },
+        "initialValue": { "type": "object" },
+        "componentProps": { "type": "object" }
+      }
+    },
+    "containerNode": {
+      "type": "object",
+      "required": ["component"],
+      "additionalProperties": false,
+      "properties": {
+        "selector": { "type": "string" },
+        "component": { "$ref": "#/definitions/componentOp" },
+        "componentProps": { "type": "object" },
+        "children": {
+          "type": "array",
+          "items": { "$ref": "#/definitions/node" }
+        }
+      }
+    }
+  }
+}
+;
+
+export default _default;

package/dist/schema/index.d.ts

@@ -0,0 +1,20 @@
+import { ComponentRegistry } from '../registry/types';
+/** Базовая мета-схема form-DSL (draft-07): структура + синтаксис операторов, имена не ограничены. */
+export declare const formSchemaMetaSchema: Record<string, unknown>;
+/** Имена компонентов реестра (`reg.field`/`reg.container`). */
+export declare function getComponentNames(registry: ComponentRegistry): string[];
+/** Имена registry-source (`reg.source`): options/itemLabel/константы/loading-компоненты. */
+export declare function getSourceNames(registry: ComponentRegistry): string[];
+/**
+ * Конкретная мета-схема: базовая + (если заданы `componentNames`) сужение паттерна `$component(...)`
+ * до enum имён (`^\$component\((Input|Select|…)\)$`). `$dataSource`-имена JSON Schema'й не покрыть
+ * (вложены в произвольный componentProps) — их проверяет рекурсивный обход в `validateFormSchema`.
+ *
+ * @example
+ * ```ts
+ * const schema = buildFormSchemaMetaSchema({ componentNames: getComponentNames(registry) });
+ * ```
+ */
+export declare function buildFormSchemaMetaSchema(opts?: {
+    componentNames?: string[];
+}): Record<string, unknown>;

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

@@ -1,125 +1,76 @@
-/**
- * Типы для 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).
-     * Необязателен — нужен только если к узлу привязано поведение.
-     */
+import { ModelOp, ComponentOp } from '../operators';
+/** Лист формы: значение из модели (`$model`) + опциональный компонент (`$component`, дефолт — Input). */
+export interface JsonFieldNode {
+    /** Id для render-behavior (hideWhen/patchProps). Опционален. */
     selector?: string;
-    /**
-     * Имя компонента из реестра: "Input", "Box", "Section", "Select"
-     *
-     * - Для полей: компонент для рендеринга значения (опционально, по умолчанию Input)
-     * - Для контейнеров: React-компонент контейнера (обязательно)
-     */
-    component?: string;
-    /**
-     * Путь к полю формы (модели): "email", "personalData.firstName", "addresses[0].city"
-     *
-     * Если указан — узел представляет поле формы.
-     */
-    model?: string;
-    /**
-     * Props для компонента (className, title и т.д.)
-     */
+    /** Привязка к сигналу модели: `'$model(personalData.lastName)'`. */
+    value: ModelOp;
+    /** Компонент поля из реестра: `'$component(Select)'`. Опционален. */
+    component?: ComponentOp;
+    /** Props компонента; значения могут содержать строки-операторы (`'$dataSource(NAME)'`) или вложенные узлы. */
     componentProps?: Record<string, unknown>;
+    /** Обёртка поля (например, FormField). */
+    wrapper?: JsonNode;
+}
+/** Массив форм: данные из модели (`$model`) + шаблон элемента (`$template`). */
+export interface JsonArrayNode {
+    /** Id для render-behavior. */
+    selector?: string;
+    /** Привязка к массиву модели: `'$model(coBorrowers)'`. */
+    array: ModelOp;
+    /** Шаблон под-схемы элемента. */
+    item: {
+        $template: JsonNode;
+    };
     /**
-     * Дочерние узлы (для контейнеров)
+     * «Пустой» элемент для кнопки «Добавить» (литерал-объект по форме элемента).
+     * Нужен, т.к. листья шаблона несут `value: '$model(...)'`, а не литерал-дефолт.
      */
+    initialValue?: Record<string, unknown>;
+    /** Оформление секции массива (title/addButtonLabel/itemLabel/emptyMessage/…). */
+    componentProps?: Record<string, unknown>;
+}
+/** Контейнер (Box/Section/Wizard/Step/…) с дочерними узлами. */
+export interface JsonContainerNode {
+    /** Id для render-behavior. */
+    selector?: string;
+    /** Компонент-контейнер из реестра: `'$component(Section)'`. */
+    component: ComponentOp;
+    /** Props компонента; значения могут содержать строки-операторы или вложенные узлы. */
+    componentProps?: Record<string, unknown>;
+    /** Дочерние узлы. */
     children?: JsonNode[];
-    /**
-     * Обёртка для узла (например, fieldWrapper)
-     *
-     * @example
-     * ```json
-     * {
-     *   "model": "email",
-     *   "wrapper": {
-     *     "component": "FormField",
-     *     "componentProps": { "className": "col-span-2" }
-     *   }
-     * }
-     * ```
-     */
-    wrapper?: JsonNode;
 }
+/** Узел JSON-схемы (M1). */
+export type JsonNode = JsonFieldNode | JsonArrayNode | JsonContainerNode;
 /**
- * Корневая JSON-схема формы
+ * Корневая JSON-схема формы.
  *
  * @example
- * ```json
- * {
- *   "version": "1.0",
- *   "root": {
- *     "component": "Box",
- *     "componentProps": { "className": "space-y-4" },
- *     "children": [
- *       { "model": "email" },
- *       { "model": "password", "component": "InputPassword" }
- *     ]
- *   }
- * }
+ * ```ts
+ * const schema: JsonFormSchema = {
+ *   version: '1.0',
+ *   root: {
+ *     component: '$component(Box)',
+ *     children: [{ value: '$model(email)', component: '$component(Input)' }],
+ *   },
+ * };
  * ```
  */
 export interface JsonFormSchema {
     /**
-     * Версия схемы (для миграций)
+     * Путь к мета-схеме для IDE (VSCode подсветит структуру/синтаксис/имена `$component`).
+     * Игнорируется конвертером. Сгенерировать конкретную мета-схему: `gen-form-json-schema.ts`.
      */
+    $schema?: string;
+    /** Версия схемы (для миграций). */
     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;
+/** Type-guard: узел — массив (`array: '$model(...)'` + `item.$template`). Проверять ПЕРВЫМ. */
+export declare function isArrayNode(node: JsonNode): node is JsonArrayNode;
+/** Type-guard: узел — лист (`value: '$model(...)'`). */
+export declare function isFieldNode(node: JsonNode): node is JsonFieldNode;
+/** Type-guard: узел — контейнер (`component: '$component(...)'`, без `value`/`array`). */
+export declare function isContainerNode(node: JsonNode): node is JsonContainerNode;

package/dist/validate.d.ts

@@ -0,0 +1,23 @@
+import { ComponentRegistry } from './registry/types';
+/** Результат валидации схемы. */
+export interface FormSchemaValidationResult {
+    valid: boolean;
+    /** Человекочитаемые ошибки (путь + сообщение). Пусто, если валидно. */
+    errors: string[];
+}
+/** Опции: реестр (имена извлекаются автоматически) либо явные списки имён. */
+export interface ValidateFormSchemaOptions {
+    registry?: ComponentRegistry;
+    componentNames?: string[];
+    sourceNames?: string[];
+}
+/**
+ * Валидирует form-DSL JSON-схему. Если передан `registry`, имена компонентов/source берутся из него.
+ *
+ * @example
+ * ```ts
+ * const { valid, errors } = validateFormSchema(jsonSchema, { registry });
+ * if (!valid) console.error(errors);
+ * ```
+ */
+export declare function validateFormSchema(schema: unknown, opts?: ValidateFormSchemaOptions): FormSchemaValidationResult;