@reformer/renderer-json 4.0.1 → 6.0.0

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

@@ -13,6 +13,16 @@ export interface JsonFormRendererProps<T> {
     renderBehavior?: RenderBehaviorFn<T>;
     /** Колбэк, получающий построенный `RenderSchemaProxy` для внешних манипуляций. */
     onSchemaReady?: (schema: RenderSchemaProxy<T>) => void;
+    /**
+     * Валидировать JSON-схему против мета-схемы перед рендером. При ошибках рисует
+     * {@link SchemaErrorPanel} вместо формы. ajv грузится **динамически** (`import('../validate')`) —
+     * в prod-бандл не попадает, пока `validate` не включён.
+     *
+     * По умолчанию `false`. Чтобы валидировать только в dev, приложение передаёт значение из
+     * СВОЕГО окружения: `validate={import.meta.env.DEV}` — детекцию dev нельзя «запечь» в пакет,
+     * т.к. `import.meta.env.DEV` инлайнится в `false` при production-сборке самого пакета.
+     */
+    validate?: boolean;
 }
 /**
  * Главный компонент пакета. Рендерит форму, описанную JSON-схемой.
@@ -71,10 +81,9 @@ export interface JsonFormRendererProps<T> {
  * ```
  *
  * **Note**: `JsonFormRenderer` принимает ТОЛЬКО `{ schema, renderBehavior?, onSchemaReady? }`.
- * Форма передаётся в render-pipeline через {@link JsonRendererProvider} settings или через
- * closure-pattern с {@link createRenderSchemaFromJson} + `FormRoot.__selfManagedChildren = true`
- * (см. recipe `multi-step-from-json` в `docs/llms/`).
+ * Под M1 модель (`FormModel`) передаётся через {@link JsonRendererProvider} settings (`model`);
+ * листья JSON-схемы биндятся к её сигналам конвертером `convertJsonToM1Tree`.
  *
  * @see [docs/llms/01-overview.md](../../docs/llms/01-overview.md)
  */
-export declare function JsonFormRenderer<T>({ schema, renderBehavior, onSchemaReady, }: JsonFormRendererProps<T>): ReactNode;
+export declare function JsonFormRenderer<T>({ schema, renderBehavior, onSchemaReady, validate, }: JsonFormRendererProps<T>): ReactNode;

package/dist/components/schema-error-panel.d.ts

@@ -0,0 +1,8 @@
+import { ReactNode } from 'react';
+/** Props of {@link SchemaErrorPanel}. */
+export interface SchemaErrorPanelProps {
+    /** Человекочитаемые ошибки (`validateFormSchema().errors`). */
+    errors: string[];
+}
+/** Список ошибок схемы (path + message), с пометкой источника. Без внешних UI-зависимостей. */
+export declare function SchemaErrorPanel({ errors }: SchemaErrorPanelProps): ReactNode;

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

@@ -1,5 +1,6 @@
 import { ReactNode } from 'react';
 import { RendererSettings } from '@reformer/renderer-react';
+import { FormModel } from '@reformer/core';
 import { ComponentRegistry } from '../registry/types';
 /**
  * Расширенные настройки рендерера: всё из `RendererSettings` плюс реестр.
@@ -7,6 +8,11 @@ import { ComponentRegistry } from '../registry/types';
 export interface JsonRendererSettings extends RendererSettings {
     /** Реестр компонентов и source-значений. См. {@link defineRegistry}. */
     registry?: ComponentRegistry;
+    /**
+     * Модель данных (M1, единая схема). Если задана — JSON-листья биндятся к сигналам модели
+     * (`model.signalAt(selector)`), а форма строится из той же JSON-схемы (без отдельной схемы формы).
+     */
+    model?: FormModel<any>;
 }
 /**
  * Props {@link JsonRendererProvider}.

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

@@ -1,31 +1,15 @@
-import { RenderSchemaFn } from '@reformer/renderer-react';
+import { RenderSchemaFn, RenderNode } from '@reformer/renderer-react';
+import { FormModel } from '@reformer/core';
 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 }} />
- * ```
+ * Сырое дерево RenderNode из JSON (M1) — для `createForm({ model, schema })`.
+ * @group Converter
  */
-export declare function createRenderSchemaFromJson<T>(schema: JsonFormSchema, registry: ComponentRegistry): RenderSchemaFn<T>;
+export declare function convertJsonToM1Tree<T>(schema: JsonFormSchema, registry: ComponentRegistry, model: FormModel<T>): RenderNode<T>;
+/**
+ * `RenderSchemaFn` из JSON (M1) — для `FormRenderer`/`JsonFormRenderer`. Листья привязываются к
+ * сигналам модели (`'$model(path)'` → `model.signalAt`), компоненты/источники — из реестра.
+ * @group Converter
+ */
+export declare function createRenderSchemaFromJsonM1<T>(schema: JsonFormSchema, registry: ComponentRegistry, model: FormModel<T>): RenderSchemaFn<T>;

package/dist/index-CI7YxPq2.js

@@ -0,0 +1,45 @@
+const a = /^\$(model|component|dataSource)\((.+)\)$/;
+function n(e) {
+  if (typeof e != "string") return null;
+  const t = a.exec(e);
+  return t ? { op: t[1], arg: t[2] } : null;
+}
+const y = (e) => n(e)?.op === "model", g = (e) => n(e)?.op === "component", S = (e) => n(e)?.op === "dataSource", s = "http://json-schema.org/draft-07/schema#", p = "https://reformer.dev/schemas/form-schema.schema.json", c = "ReFormer JSON form schema (M1, string-operator DSL)", m = "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.", d = "object", f = ["root"], l = !1, u = { $schema: { type: "string" }, version: { type: "string" }, root: { $ref: "#/definitions/node" } }, $ = { 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: !1, 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: !1, properties: { selector: { type: "string" }, array: { $ref: "#/definitions/modelOp" }, item: { type: "object", required: ["$template"], additionalProperties: !1, properties: { $template: { $ref: "#/definitions/node" } } }, initialValue: { type: "object" }, componentProps: { type: "object" } } }, containerNode: { type: "object", required: ["component"], additionalProperties: !1, properties: { selector: { type: "string" }, component: { $ref: "#/definitions/componentOp" }, componentProps: { type: "object" }, children: { type: "array", items: { $ref: "#/definitions/node" } } } } }, r = {
+  $schema: s,
+  $id: p,
+  title: c,
+  description: m,
+  type: d,
+  required: f,
+  additionalProperties: l,
+  properties: u,
+  definitions: $
+}, O = r;
+function b(e) {
+  return e.names().filter((t) => {
+    const o = e.get(t)?.type;
+    return o === "field" || o === "container";
+  });
+}
+function N(e) {
+  return e.names().filter((t) => e.get(t)?.type === "source");
+}
+const h = (e) => e.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function j(e) {
+  const t = JSON.parse(JSON.stringify(r)), o = e?.componentNames;
+  if (o && o.length > 0) {
+    const i = o.map(h).join("|");
+    t.definitions.componentOp.pattern = `^\\$component\\((${i})\\)$`;
+  }
+  return t;
+}
+export {
+  g as a,
+  S as b,
+  j as c,
+  N as d,
+  O as f,
+  b as g,
+  y as i,
+  n as p
+};

package/dist/index.d.ts

@@ -7,11 +7,16 @@
  */
 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 { SchemaErrorPanel } from './components/schema-error-panel';
+export type { SchemaErrorPanelProps } from './components/schema-error-panel';
+export type { JsonFormSchema, JsonNode, JsonFieldNode, JsonArrayNode, JsonContainerNode, } from './types/json-schema';
+export { isFieldNode, isArrayNode, isContainerNode } from './types/json-schema';
+export { parseOperator, isModelOp, isComponentOp, isDataSourceOp } from './operators';
+export type { ModelOp, ComponentOp, DataSourceOp, JsonOperator, ParsedOperator } from './operators';
 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';
+export { createRenderSchemaFromJsonM1, convertJsonToM1Tree, } from './converter/json-to-render-schema';
+export { formSchemaMetaSchema, buildFormSchemaMetaSchema, getComponentNames, getSourceNames, } from './schema';

package/dist/index.js

@@ -1,38 +1,39 @@
-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 {
+import { jsx as u, jsxs as M } from "react/jsx-runtime";
+import { useContext as N, createContext as O, useMemo as g, useState as C, useEffect as F } from "react";
+import { createRenderSchema as j, FormRenderer as k } from "@reformer/renderer-react";
+import { i as f, a as R, p as m, b as A } from "./index-CI7YxPq2.js";
+import { c as rr, f as er, g as tr, d as nr } from "./index-CI7YxPq2.js";
+class h {
   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;
+    const t = this.get(e);
+    if (!(!t || t.type !== "source"))
+      return t.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])];
+    const e = this.parent?.names() ?? [], t = Array.from(this.own.keys());
+    return [.../* @__PURE__ */ new Set([...e, ...t])];
   }
-  _set(e, r) {
-    this.own.has(e) && console.warn(`[ComponentRegistry] Overwriting entry: ${e}`), this.own.set(e, r);
+  _set(e, t) {
+    this.own.has(e) && console.warn(`[ComponentRegistry] Overwriting entry: ${e}`), this.own.set(e, t);
   }
-  static withParent(e, r) {
-    const n = new u();
-    return n.parent = e, r.own.forEach((o, i) => {
+  static withParent(e, t) {
+    const n = new h();
+    return n.parent = e, t.own.forEach((o, i) => {
       n.own.set(i, o);
     }), n;
   }
 }
-function _(t) {
-  const e = new u();
-  return t({
+function K(r) {
+  const e = new h();
+  return r({
     field(n, o, i) {
       e._set(n, { component: o, type: "field", description: i });
     },
@@ -44,169 +45,199 @@ function _(t) {
     }
   }), 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;
+const v = "$fieldWrapper", S = O({});
+function Q({ settings: r, children: e }) {
+  const t = N(S), n = g(() => t.registry && r.registry ? h.withParent(t.registry, r.registry) : r.registry ?? t.registry, [t.registry, r.registry]), o = g(() => {
+    const i = n?.get(v)?.component;
     return {
-      ...r,
       ...t,
+      ...r,
       registry: n,
-      fieldWrapper: t.fieldWrapper ?? i ?? r.fieldWrapper
+      fieldWrapper: r.fieldWrapper ?? i ?? t.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];
+  }, [t, r, n]);
+  return /* @__PURE__ */ u(S.Provider, { value: o, children: e });
+}
+function W() {
+  return N(S);
+}
+function $(r) {
+  const e = r;
+  return f(e.array) && typeof e.item == "object" && e.item !== null && "$template" in e.item;
+}
+function E(r) {
+  return f(r.value);
+}
+function D(r) {
+  return R(r.component) && !E(r) && !$(r);
+}
+function P(r, e) {
+  if (!r) return;
+  const t = m(r)?.arg;
+  if (!t) throw new Error(`Invalid $component operator: "${r}"`);
+  const n = e.get(t);
+  if (!n)
+    throw new Error(
+      `Component "${t}" not found in registry. Available: ${e.names().join(", ")}`
+    );
+  if (n.type === "source")
+    throw new Error(`Entry "${t}" is a 'source' and cannot be used as $component(...)`);
+  return n.component;
+}
+function L(r, e) {
+  const t = e.get(r);
+  if (!t)
+    throw new Error(
+      `Data source "${r}" not found in registry. Available: ${e.names().join(", ")}`
+    );
+  return t.component;
+}
+function _(r, e) {
+  return e.split(".").reduce((t, n) => t == null ? t : t[n], r);
+}
+function I(r) {
+  if (r === null || typeof r != "object") return !1;
+  const e = r;
+  return f(e.value) || f(e.array) || R(e.component);
+}
+function V(r) {
+  return r == null ? r : JSON.parse(JSON.stringify(r));
+}
+function b(r, e, t) {
+  if (A(r)) return L(m(r).arg, t);
+  if (R(r)) return P(r, t);
+  if (f(r)) return e.signalAt(m(r).arg);
+  if (I(r)) return p(r, e, t);
+  if (Array.isArray(r)) return r.map((n) => b(n, e, t));
+  if (r !== null && typeof r == "object") {
+    const n = r, o = {};
+    for (const i of Object.keys(n)) o[i] = b(n[i], e, t);
+    return o;
   }
-  if (n == null)
-    throw new Error(`Invalid field path: "${e}" - path resolved to null/undefined`);
-  return n;
+  return r;
 }
-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) {
+function w(r, e, t) {
+  if (!r) return;
   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);
-  }
+  for (const o of Object.keys(r)) n[o] = b(r[o], e, t);
   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)
+function p(r, e, t) {
+  if ($(r)) {
+    const n = _(e, m(r.array).arg), o = r.item.$template, i = r.initialValue;
+    return {
+      ...r.selector ? { selector: r.selector } : {},
+      array: n,
+      initialValue: () => i ? V(i) : {},
+      item: (y) => p(o, y, t),
+      componentProps: w(r.componentProps, e, t)
     };
-    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
+  if (E(r)) {
+    const n = m(r.value).arg, o = e.signalAt(n);
+    return !o && typeof console < "u" && console.warn(`[JsonRenderer/M1] No model signal for "${n}".`), {
+      ...r.selector ? { selector: r.selector } : {},
+      value: o,
+      component: P(r.component, t),
+      componentProps: w(r.componentProps, e, t)
     };
-    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)}`
+  if (D(r))
+    return {
+      ...r.selector ? { selector: r.selector } : {},
+      component: P(r.component, t),
+      componentProps: w(r.componentProps, e, t),
+      children: r.children?.map((n) => p(n, e, t))
+    };
+  throw new Error(`Invalid JSON node (M1): ${JSON.stringify(r)}`);
+}
+function U(r, e, t) {
+  return p(r.root, t, e);
+}
+function T(r, e, t) {
+  return () => p(r.root, t, e);
+}
+function q({ errors: r }) {
+  return /* @__PURE__ */ M(
+    "div",
+    {
+      role: "alert",
+      "data-testid": "schema-error-panel",
+      style: {
+        border: "1px solid #f5a9a9",
+        background: "#fff5f5",
+        color: "#9b1c1c",
+        borderRadius: 8,
+        padding: "16px 20px",
+        font: "14px/1.5 ui-monospace, SFMono-Regular, Menlo, monospace"
+      },
+      children: [
+        /* @__PURE__ */ M("strong", { style: { display: "block", marginBottom: 8, fontSize: 15 }, children: [
+          "Невалидная JSON-схема формы (",
+          r.length,
+          ")"
+        ] }),
+        /* @__PURE__ */ u("ul", { style: { margin: 0, paddingLeft: 20 }, children: r.map((e, t) => /* @__PURE__ */ u("li", { style: { marginBottom: 4 }, children: e }, t)) })
+      ]
+    }
   );
 }
-function J(t, e) {
-  return (r) => s(t.root, r, e);
-}
-function L({
-  schema: t,
+function X({
+  schema: r,
   renderBehavior: e,
-  onSchemaReady: r
+  onSchemaReady: t,
+  validate: n = !1
 }) {
-  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);
+  const { registry: o, model: i, ...y } = W(), [a, d] = C(
+    n ? void 0 : null
+  );
+  F(() => {
+    if (!n) {
+      d(null);
+      return;
+    }
+    let l = !1;
+    return d(void 0), import("./validate.js").then(({ validateFormSchema: s }) => {
+      if (l) return;
+      const { valid: J, errors: x } = s(r, { registry: o });
+      d(J ? null : x);
+    }).catch((s) => {
+      l || d([`Schema validator failed to load: ${String(s)}`]);
+    }), () => {
+      l = !0;
+    };
+  }, [n, r, o]);
+  const c = g(() => {
+    if (!i)
+      throw new Error(
+        "JsonFormRenderer: settings.model is required (M1). Pass the FormModel via JsonRendererProvider."
+      );
+    if (a !== null) return null;
+    const l = T(r, o, i), s = j(l);
+    return e && e(s), s;
+  }, [r, o, e, i, a]);
+  return g(() => {
+    c && t && t(c);
+  }, [c]), a && a.length > 0 ? /* @__PURE__ */ u(q, { errors: a }) : c ? /* @__PURE__ */ u(k, { render: c, settings: y }) : null;
 }
 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
+  v as FIELD_WRAPPER,
+  X as JsonFormRenderer,
+  Q as JsonRendererProvider,
+  q as SchemaErrorPanel,
+  rr as buildFormSchemaMetaSchema,
+  U as convertJsonToM1Tree,
+  T as createRenderSchemaFromJsonM1,
+  K as defineRegistry,
+  er as formSchemaMetaSchema,
+  tr as getComponentNames,
+  nr as getSourceNames,
+  $ as isArrayNode,
+  R as isComponentOp,
+  D as isContainerNode,
+  A as isDataSourceOp,
+  E as isFieldNode,
+  f as isModelOp,
+  m as parseOperator,
+  W as useJsonRendererSettings
 };

package/dist/operators.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Операторы JSON-схемы (M1) — СТРОКОВЫЕ ссылки на модель/реестр.
+ *
+ * JSON нельзя «вызвать функцию», поэтому привязки кодируются СТРОКАМИ функц-стиля с дискриминатором:
+ *
+ * - `"$model(path)"`        — путь к полю/массиву модели: лист → `model.signalAt(path)`, массив → `model.<path>`.
+ * - `"$component(Name)"`    — имя компонента в реестре (`reg.field`/`reg.container`).
+ * - `"$dataSource(NAME)"`   — имя registry-source (`reg.source`): options/itemLabel/константы/loading-компоненты.
+ *
+ * Схема остаётся чистым JSON (копируется в `.json`, приходит строкой с сервера). Типобезопасность
+ * на этапе компиляции даётся template-literal типами ({@link ModelOp} и т.д.) — литерал
+ * `'$model(loanType)'` проверяется без вызова функций. Голые строки (не-`$`, напр. `label`) не резолвятся.
+ *
+ * @module reformer/renderer-json/operators
+ */
+/** Строка-оператор привязки к полю/массиву модели: `` `$model(${path})` ``. */
+export type ModelOp = `$model(${string})`;
+/** Строка-оператор ссылки на компонент реестра: `` `$component(${name})` ``. */
+export type ComponentOp = `$component(${string})`;
+/** Строка-оператор ссылки на registry-source: `` `$dataSource(${name})` ``. */
+export type DataSourceOp = `$dataSource(${string})`;
+/** Любой строковый оператор JSON-схемы. */
+export type JsonOperator = ModelOp | ComponentOp | DataSourceOp;
+/** Разобранный оператор: тип + аргумент (путь/имя). */
+export interface ParsedOperator {
+    op: 'model' | 'component' | 'dataSource';
+    arg: string;
+}
+/**
+ * Разбор строки-оператора `"$op(arg)"`. Возвращает `null` для не-операторов (обычных строк),
+ * чтобы вызывающий оставил значение как есть.
+ *
+ * @example
+ * ```ts
+ * parseOperator('$model(loanType)');   // { op: 'model', arg: 'loanType' }
+ * parseOperator('$dataSource(LOAN_TYPES)'); // { op: 'dataSource', arg: 'LOAN_TYPES' }
+ * parseOperator('Введите сумму');       // null  (обычная строка)
+ * ```
+ */
+export declare function parseOperator(value: unknown): ParsedOperator | null;
+/** Type-guard: строка — `"$model(...)"`. */
+export declare const isModelOp: (v: unknown) => v is ModelOp;
+/** Type-guard: строка — `"$component(...)"`. */
+export declare const isComponentOp: (v: unknown) => v is ComponentOp;
+/** Type-guard: строка — `"$dataSource(...)"`. */
+export declare const isDataSourceOp: (v: unknown) => v is DataSourceOp;