@gravity-ui/dynamic-forms 5.23.1 → 5.25.0

package/build/esm/lib/kit/i18n/en.json

@@ -35,6 +35,40 @@
     "Value can't be longer than {{count}} items",
     "Value can't be longer than {{count}} items"
   ],
+  "label-sr_error-additional-items": "Maximum allowed number of items is {{count}}",
+  "label-sr_error-additional-properties": "Maximum allowed number of properties is {{count}}",
+  "label-sr_error-any-of": "Incorrect value in field",
+  "label-sr_error-const": "Value must be {{expected}}",
+  "label-sr_error-contains": "At least one item must be added",
+  "label-sr_error-contains-min": "At least one item matching the condition must be added",
+  "label-sr_error-dependencies": "Field \"{{property}}\" is required",
+  "label-sr_error-enum": "Value {{value}} cannot be used",
+  "label-sr_error-exclusive-maximum": "Value must be less than {{count}}",
+  "label-sr_error-exclusive-minimum": "Value must be greater than {{count}}",
+  "label-sr_error-max-items": "Maximum allowed number of items is {{count}}",
+  "label-sr_error-max-length": "Maximum allowed number of characters is {{count}}",
+  "label-sr_error-max-properties": "Maximum allowed number of properties is {{count}}",
+  "label-sr_error-maximum": "Value must be less than or equal to {{count}}",
+  "label-sr_error-min-items": "Minimum allowed number of items is {{count}}",
+  "label-sr_error-min-length": "Minimum allowed number of characters is {{count}}",
+  "label-sr_error-min-properties": "Minimum allowed number of properties is {{count}}",
+  "label-sr_error-minimum": "Value must be greater than or equal to {{count}}",
+  "label-sr_error-multiple-of": "Value must be a multiple of {{count}}",
+  "label-sr_error-not": "Value cannot be used",
+  "label-sr_error-one-of": "Incorrect value in field",
+  "label-sr_error-pattern": "Value must match the pattern - {{pattern}}",
+  "label-sr_error-property-names": "Invalid property name \"{{property}}\"",
+  "label-sr_error-required": "Empty field",
+  "label-sr_error-type": "Value must be {{expected}}",
+  "label-sr_error-type-or": " or {{type}}",
+  "label-sr_error-unique-items": "Values must be unique",
+  "label-sr_type-array": "an array",
+  "label-sr_type-boolean": "a boolean",
+  "label-sr_type-integer": "an integer",
+  "label-sr_type-null": "null",
+  "label-sr_type-number": "a number",
+  "label-sr_type-object": "an object",
+  "label-sr_type-string": "a string",
   "label_error-min-number": "Value must be an integer no less than {{count}}",
   "label_error-max-number": "Value must not be greater than {{count}}",
   "label_error-min-number-with-scale": "Value must be no less than {{count}} {{scale}}",

package/build/esm/lib/kit/i18n/ru.json

@@ -35,6 +35,40 @@
     "Значение не может быть длиннее {{count}} элементов",
     "Значение не может быть длиннее {{count}} элементов"
   ],
+  "label-sr_error-additional-items": "Максимальное допустимое количество элементов: {{count}}",
+  "label-sr_error-additional-properties": "Максимальное допустимое количество свойств: {{count}}",
+  "label-sr_error-any-of": "Поле заполнено неправильно",
+  "label-sr_error-const": "Значение должно быть равно {{expected}}",
+  "label-sr_error-contains": "Необходимо добавить хотя бы один элемент",
+  "label-sr_error-contains-min": "Необходимо добавить хотя бы один элемент, удовлетворяющий условию",
+  "label-sr_error-dependencies": "Необходимо заполнить поле \"{{property}}\"",
+  "label-sr_error-enum": "Значение {{value}} не допустимо к использованию",
+  "label-sr_error-exclusive-maximum": "Значение должно быть меньше {{count}}",
+  "label-sr_error-exclusive-minimum": "Значение должно быть больше {{count}}",
+  "label-sr_error-max-items": "Максимальное допустимое количество элементов: {{count}}",
+  "label-sr_error-max-length": "Максимальное допустимое количество символов: {{count}}",
+  "label-sr_error-max-properties": "Максимальное допустимое количество свойств: {{count}}",
+  "label-sr_error-maximum": "Значение должно быть меньше или равно {{count}}",
+  "label-sr_error-min-items": "Минимальное допустимое количество элементов: {{count}}",
+  "label-sr_error-min-length": "Минимальное допустимое количество символов: {{count}}",
+  "label-sr_error-min-properties": "Минимальное допустимое количество свойств: {{count}}",
+  "label-sr_error-minimum": "Значение должно быть больше или равно {{count}}",
+  "label-sr_error-multiple-of": "Значение должно быть кратно {{count}}",
+  "label-sr_error-not": "Значение не допустимо к использованию",
+  "label-sr_error-one-of": "Поле заполнено неправильно",
+  "label-sr_error-pattern": "Значение должно удовлетворять шаблону - {{pattern}}",
+  "label-sr_error-property-names": "Недопустимое имя свойства \"{{property}}\"",
+  "label-sr_error-required": "Поле не заполнено",
+  "label-sr_error-type": "Значение должно быть {{expected}}",
+  "label-sr_error-type-or": " или {{type}}",
+  "label-sr_error-unique-items": "Значения должны быть уникальными",
+  "label-sr_type-array": "массивом",
+  "label-sr_type-boolean": "булевым значением",
+  "label-sr_type-integer": "целым числом",
+  "label-sr_type-null": "null",
+  "label-sr_type-number": "числом",
+  "label-sr_type-object": "объектом",
+  "label-sr_type-string": "строкой",
   "label_error-min-number": "Значение должно быть числом не меньше {{count}}",
   "label_error-max-number": "Значение должно быть числом не больше {{count}}",
   "label_error-min-number-with-scale": "Значение должно быть не меньше {{count}} {{scale}}",

package/build/esm/lib/unstable/core/SchemaRendererNode/SchemaRendererNode.js

@@ -5,12 +5,11 @@ import { SchemaRendererEventType, SchemaRendererMode } from '../constants';
 import { SCHEMA_RENDERER_SERVICE_FIELD } from '../useSchemaRenderer';
 import { useSchemaRendererState } from '../useSchemaRendererState';
 import { getServiceFieldName } from '../utils';
-import { getAccumulatedSchema, getRenderKit } from './utils';
+import { getAccumulatedSchema, getCompareValues, getRenderKit, scheduleFlush } from './utils';
 const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverride, schemaPath, }) => {
     var _a;
     const form = useForm();
-    const firstRenderRef = React.useRef(true);
-    const pendingTicksRef = React.useRef({ input: 0, meta: 0 });
+    const compareValuesRef = React.useRef(getCompareValues());
     const fieldRef = React.useRef(null);
     const unsubscribeRef = React.useRef(null);
     const [ticks, setTicks] = React.useState({ input: 0, meta: 0 });
@@ -35,6 +34,17 @@ const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverr
     const kit = React.useMemo(() => getRenderKit({ config: srState === null || srState === void 0 ? void 0 : srState.config, schema }), [schema, srState === null || srState === void 0 ? void 0 : srState.config]);
     React.useMemo(() => {
         var _a;
+        if (compareValuesRef.current({
+            form,
+            jsonDefaultValues,
+            headName,
+            name,
+            default: schema === null || schema === void 0 ? void 0 : schema.default,
+            type: schema === null || schema === void 0 ? void 0 : schema.type,
+            schemaPath,
+        })) {
+            return;
+        }
         (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);
         const initialState = { schemaPath };
         let defaultValue = schema === null || schema === void 0 ? void 0 : schema.default;
@@ -44,7 +54,7 @@ const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverr
             }
             catch (_b) { }
         }
-        unsubscribeRef.current = form.registerField(name, (f) => {
+        const unsubscribe = form.registerField(name, (f) => {
             const prevF = fieldRef.current;
             if (prevF) {
                 let inputTick = 0;
@@ -58,23 +68,26 @@ const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverr
                     metaTick = 1;
                 }
                 if (inputTick + metaTick) {
-                    if (firstRenderRef.current) {
-                        pendingTicksRef.current = { input: inputTick, meta: metaTick };
-                    }
-                    else {
-                        setTicks((t) => ({
-                            input: t.input + inputTick,
-                            meta: t.meta + metaTick,
-                        }));
-                    }
+                    setTicks((t) => ({
+                        input: t.input + inputTick,
+                        meta: t.meta + metaTick,
+                    }));
                 }
             }
             fieldRef.current = f;
         }, { submitFailed: true, touched: true, validating: true, value: true }, {
             data: { state: initialState },
             defaultValue,
+            silent: true,
             validateFields: [getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName)],
         });
+        if (defaultValue !== undefined) {
+            scheduleFlush(form);
+        }
+        unsubscribeRef.current = () => {
+            unsubscribe();
+            scheduleFlush(form);
+        };
     }, [form, jsonDefaultValues, headName, name, schema === null || schema === void 0 ? void 0 : schema.default, schema === null || schema === void 0 ? void 0 : schema.type, schemaPath]);
     const input = React.useMemo(() => {
         var _a;
@@ -99,13 +112,6 @@ const SchemaRendererNodeComponent = ({ headName, modeOverride, name, schemaOverr
         };
     }, [error, form, name, ticks.meta]);
     React.useEffect(() => {
-        firstRenderRef.current = false;
-        if (pendingTicksRef.current.input || pendingTicksRef.current.meta) {
-            setTicks((t) => ({
-                input: t.input + pendingTicksRef.current.input,
-                meta: t.meta + pendingTicksRef.current.meta,
-            }));
-        }
         return () => {
             var _a;
             (_a = unsubscribeRef.current) === null || _a === void 0 ? void 0 : _a.call(unsubscribeRef);

package/build/esm/lib/unstable/core/SchemaRendererNode/utils.d.ts

@@ -1,3 +1,4 @@
+import type { FormApi } from 'final-form';
 import { SchemaRendererMode } from '../constants';
 import type { JsonSchema, NodeEntity, NodeLayout, NodesConfig } from '../types';
 type GetRenderKitParams<Schema extends JsonSchema> = {
@@ -22,4 +23,6 @@ type GetRenderKitReturn<Schema extends JsonSchema> = {
 };
 export declare const getRenderKit: <Schema extends JsonSchema>({ config, schema, }: GetRenderKitParams<Schema>) => GetRenderKitReturn<Schema>;
 export declare const getAccumulatedSchema: (schemaPath: string, rootSchema?: JsonSchema, override?: JsonSchema, collectedPaths?: Set<string>) => JsonSchema;
+export declare const scheduleFlush: (form: FormApi) => void;
+export declare const getCompareValues: () => (currentValues: Record<string, unknown>) => boolean;
 export {};

package/build/esm/lib/unstable/core/SchemaRendererNode/utils.js

@@ -154,3 +154,25 @@ export const getAccumulatedSchema = (schemaPath, rootSchema, override, collected
     }
     return accumulatedSchema;
 };
+const flushes = new WeakMap();
+export const scheduleFlush = (form) => {
+    if (flushes.get(form)) {
+        return;
+    }
+    flushes.set(form, true);
+    queueMicrotask(() => {
+        flushes.delete(form);
+        form.batch(() => { });
+    });
+};
+export const getCompareValues = () => {
+    let cachedValues;
+    return (currentValues) => {
+        if (!cachedValues ||
+            [...Object.keys(cachedValues), ...Object.keys(currentValues)].some((key) => cachedValues[key] !== currentValues[key])) {
+            cachedValues = Object.assign({}, currentValues);
+            return false;
+        }
+        return true;
+    };
+};

package/build/esm/lib/unstable/core/types/components.d.ts

@@ -3,31 +3,21 @@ import type { FieldRenderProps } from 'react-final-form';
 import type { SchemaRendererMode } from '../constants';
 import type { SchemaToValueType } from './helpers';
 import type { JsonSchema } from './schema';
-export interface DefaultNodeLayoutProps {
-    copy?: boolean;
-    hidden?: boolean;
-    open?: boolean;
-    required?: boolean;
-}
 export interface NodeLayoutProps<Schema extends JsonSchema, Props extends Record<string, any> = {}, Value extends SchemaToValueType<Schema> = SchemaToValueType<Schema>> extends FieldRenderProps<Value | null | undefined> {
     children: React.ReactNode;
     headName: string;
     mode: SchemaRendererMode;
-    props: DefaultNodeLayoutProps & Partial<Props>;
+    props: Partial<Props>;
     schema: Schema;
     schemaPath: string;
 }
 export type NodeLayout<Schema extends JsonSchema, Props extends Record<string, any> = {}, Value extends SchemaToValueType<Schema> = SchemaToValueType<Schema>> = React.FC<NodeLayoutProps<Schema, Props, Value>>;
-export interface DefaultNodeEntityProps {
-    disabled?: boolean;
-    required?: boolean;
-}
 export interface NodeEntityProps<Schema extends JsonSchema, Props extends Record<string, any> = {}, LayoutProps extends Record<string, any> = {}, Value extends SchemaToValueType<Schema> = SchemaToValueType<Schema>> extends FieldRenderProps<Value | null | undefined> {
     Layout?: NodeLayout<Schema, LayoutProps>;
     headName: string;
-    layoutProps?: DefaultNodeLayoutProps & Partial<LayoutProps>;
+    layoutProps?: Partial<LayoutProps>;
     mode: SchemaRendererMode;
-    props: DefaultNodeEntityProps & Partial<Props>;
+    props: Partial<Props>;
     schema: Schema;
     schemaPath: string;
 }

package/build/esm/lib/unstable/core/types/schema.d.ts

@@ -1,25 +1,32 @@
 import type { JsonSchemaType, NodeType } from '../constants';
-import type { DefaultNodeEntityProps, DefaultNodeLayoutProps, NodeEntity, NodeLayout } from './components';
+import type { NodeEntity, NodeLayout } from './components';
 import type { ErrorMessages, Validator } from './validation';
 import type { ArrayValue, FieldValue, ObjectValue } from './values';
 interface NodeParameters<Type extends NodeType, Schema extends JsonSchema> {
     nodeParameters?: {
         entity?: string | NodeEntity<Schema>;
-        entityProps?: DefaultNodeEntityProps & Record<string, any>;
+        entityProps?: Record<string, any>;
         errorMessages?: Omit<ErrorMessages, 'dependencies' | 'required'> & {
             dependencies?: ErrorMessages['dependencies'] | Record<string, ErrorMessages['dependencies']>;
             required?: ErrorMessages['required'] | Record<string, ErrorMessages['required']>;
         };
+        flags?: {
+            copy?: boolean;
+            disabled?: boolean;
+            hidden?: boolean;
+            open?: boolean;
+            required?: boolean;
+        };
         formEntity?: string | NodeEntity<Schema>;
-        formEntityProps?: DefaultNodeEntityProps & Record<string, any>;
+        formEntityProps?: Record<string, any>;
         formLayout?: string | NodeLayout<Schema>;
-        formLayoutProps?: DefaultNodeLayoutProps & Record<string, any>;
+        formLayoutProps?: Record<string, any>;
         layout?: string | NodeLayout<Schema>;
-        layoutProps?: DefaultNodeLayoutProps & Record<string, any>;
+        layoutProps?: Record<string, any>;
         overviewEntity?: string | NodeEntity<Schema>;
-        overviewEntityProps?: DefaultNodeEntityProps & Record<string, any>;
+        overviewEntityProps?: Record<string, any>;
         overviewLayout?: string | NodeLayout<Schema>;
-        overviewLayoutProps?: DefaultNodeLayoutProps & Record<string, any>;
+        overviewLayoutProps?: Record<string, any>;
         type?: Type;
         validator?: string | Validator<Schema>;
     };

package/build/esm/lib/unstable/core/types/validation.d.ts

@@ -12,7 +12,7 @@ export interface ErrorMessages {
     additionalProperties?: ((e: JSLErrors.AdditionalProperties) => string) | string;
     anyOf?: ((e: JSLErrors.AnyOf) => string) | string;
     const?: ((e: JSLErrors.Const) => string) | string;
-    contains?: ((e: JSLErrors.ContainsAny) => string) | string;
+    contains?: ((e: JSLErrors.ContainsAny | JSLErrors.ContainsMin) => string) | string;
     dependencies?: ((e: JSLErrors.Dependencies) => string) | string;
     enum?: ((e: JSLErrors.Enum) => string) | string;
     exclusiveMaximum?: ((e: JSLErrors.ExclusiveMaximum) => string) | string;

package/build/esm/lib/unstable/core/useSchemaRenderer/types/state.d.ts

@@ -29,6 +29,9 @@ export interface SchemaRendererState<UserContext extends Record<string, unknown>
     unsubscribe: (id: string) => void;
     userContext: {
         MonacoEditor?: React.ComponentType<MonacoEditorProps>;
+        RenderHTMLOrMD?: React.ComponentType<{
+            content: string;
+        }>;
     } & UserContext;
     waiters: Record<string, ValidationWaiter | undefined>;
 }

package/build/esm/lib/unstable/core/useSchemaRenderer/useSchemaRenderer.js

@@ -68,7 +68,7 @@ export const useSchemaRenderer = ({ config, connectValidate = true, errorMessage
                 state.dispatchEvent(initialEvents);
                 initialEvents = [];
             }
-        }, { data: true }, { data: { state: initialState }, getValidator, validateFields: [headName] });
+        }, { data: true }, { data: { state: initialState }, getValidator, silent: true, validateFields: [headName] });
         prevParamsRef.current = {
             config,
             errorMessages,

package/build/esm/lib/unstable/core/utils/definers.d.ts

@@ -1,5 +1,5 @@
 import type { NodeType } from '../constants';
-import type { DefaultNodeEntityProps, DefaultNodeLayoutProps, ErrorMessages, NodeEntity, NodeLayout, NodesConfig, Validator } from '../types';
+import type { ErrorMessages, NodeEntity, NodeLayout, NodesConfig, Validator } from '../types';
 import type { EntityKind, ExtractNodeEntityProps, ExtractNodeLayoutProps, LayoutKind, NodeComponentProps, NodeTypeConfigKey, SchemaOfNodeType } from '../types/helpers';
 export declare const defineNodeEntityConfig: <Component extends NodeEntity<any>>(nodeEntityConfig: {
     Component: Component;
@@ -20,39 +20,53 @@ export declare const defineNodeLayoutConfig: <Component extends NodeLayout<any>>
 export declare const createNodeParametersDefiner: <Config extends NodesConfig>(_config: Config) => <Type extends NodeType, const Entity extends NodeTypeConfigKey<Config, Type, "formEntities"> | NodeTypeConfigKey<Config, Type, "overviewEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const FormEntity extends NodeTypeConfigKey<Config, Type, "formEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const OverviewEntity extends NodeTypeConfigKey<Config, Type, "overviewEntities"> | NodeEntity<SchemaOfNodeType<Type>> | undefined = undefined, const Layout extends NodeTypeConfigKey<Config, Type, "formLayouts"> | NodeTypeConfigKey<Config, Type, "overviewLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const FormLayout extends NodeTypeConfigKey<Config, Type, "formLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const OverviewLayout extends NodeTypeConfigKey<Config, Type, "overviewLayouts"> | NodeLayout<SchemaOfNodeType<Type>> | undefined = undefined, const ValidatorRef extends NodeTypeConfigKey<Config, Type, "validators"> | Validator<SchemaOfNodeType<Type>> | undefined = undefined>(nodeParameters: {
     type: Type;
     entity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | Entity;
-    entityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, EntityKind, Entity>;
+    entityProps?: NodeComponentProps<Config, Type, EntityKind, Entity>;
     formEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NodeEntity<SchemaOfNodeType<Type>> | FormEntity;
-    formEntityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, "formEntities", FormEntity>;
+    formEntityProps?: NodeComponentProps<Config, Type, "formEntities", FormEntity>;
     overviewEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | OverviewEntity;
-    overviewEntityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
+    overviewEntityProps?: NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
     layout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | Layout;
-    layoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, LayoutKind, Layout>;
+    layoutProps?: NodeComponentProps<Config, Type, LayoutKind, Layout>;
     formLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | FormLayout;
-    formLayoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
+    formLayoutProps?: NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
     overviewLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | OverviewLayout;
-    overviewLayoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
+    overviewLayoutProps?: NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
     errorMessages?: Omit<ErrorMessages, "dependencies" | "required"> & {
         dependencies?: ErrorMessages["dependencies"] | Record<string, ErrorMessages["dependencies"]>;
         required?: ErrorMessages["required"] | Record<string, ErrorMessages["required"]>;
     };
     validator?: NoInfer<NodeTypeConfigKey<Config, Type, "validators">> | Validator<SchemaOfNodeType<Type>> | ValidatorRef;
+    flags?: {
+        disabled?: boolean;
+        copy?: boolean;
+        hidden?: boolean;
+        open?: boolean;
+        required?: boolean;
+    };
 }) => {
     type: Type;
     entity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | Entity;
-    entityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, EntityKind, Entity>;
+    entityProps?: NodeComponentProps<Config, Type, EntityKind, Entity>;
     formEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "formEntities">> | NodeEntity<SchemaOfNodeType<Type>> | FormEntity;
-    formEntityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, "formEntities", FormEntity>;
+    formEntityProps?: NodeComponentProps<Config, Type, "formEntities", FormEntity>;
     overviewEntity?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewEntities">> | NodeEntity<SchemaOfNodeType<Type>> | OverviewEntity;
-    overviewEntityProps?: DefaultNodeEntityProps & NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
+    overviewEntityProps?: NodeComponentProps<Config, Type, "overviewEntities", OverviewEntity>;
     layout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | Layout;
-    layoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, LayoutKind, Layout>;
+    layoutProps?: NodeComponentProps<Config, Type, LayoutKind, Layout>;
     formLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "formLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | FormLayout;
-    formLayoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
+    formLayoutProps?: NodeComponentProps<Config, Type, "formLayouts", FormLayout>;
     overviewLayout?: NoInfer<NodeTypeConfigKey<Config, Type, "overviewLayouts">> | NodeLayout<SchemaOfNodeType<Type>> | OverviewLayout;
-    overviewLayoutProps?: DefaultNodeLayoutProps & NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
+    overviewLayoutProps?: NodeComponentProps<Config, Type, "overviewLayouts", OverviewLayout>;
     errorMessages?: Omit<ErrorMessages, "dependencies" | "required"> & {
         dependencies?: ErrorMessages["dependencies"] | Record<string, ErrorMessages["dependencies"]>;
         required?: ErrorMessages["required"] | Record<string, ErrorMessages["required"]>;
     };
     validator?: NoInfer<NodeTypeConfigKey<Config, Type, "validators">> | Validator<SchemaOfNodeType<Type>> | ValidatorRef;
+    flags?: {
+        disabled?: boolean;
+        copy?: boolean;
+        hidden?: boolean;
+        open?: boolean;
+        required?: boolean;
+    };
 };

package/build/esm/lib/unstable/kit/components/HTMLContent/HTMLContent.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { type TextProps } from '@gravity-ui/uikit';
 export interface HTMLContentProps extends TextProps {
-    html: string;
+    content: string;
+    headName?: string;
 }
 export declare const HTMLContent: React.FC<HTMLContentProps>;

package/build/esm/lib/unstable/kit/components/HTMLContent/HTMLContent.js

@@ -1,7 +1,17 @@
 import { __rest } from "tslib";
 import React from 'react';
 import { Text } from '@gravity-ui/uikit';
+import { SchemaRendererEventType, useSchemaRendererState } from '../../../core';
 export const HTMLContent = (_a) => {
-    var { html } = _a, restProps = __rest(_a, ["html"]);
-    return React.createElement(Text, Object.assign({}, restProps, { dangerouslySetInnerHTML: { __html: html } }));
+    var _b;
+    var { content, headName = '___stub-name' } = _a, restProps = __rest(_a, ["content", "headName"]);
+    const state = useSchemaRendererState({
+        headName,
+        subscriptions: [SchemaRendererEventType.UserContext],
+    });
+    const RenderHTMLOrMD = (_b = state === null || state === void 0 ? void 0 : state.userContext) === null || _b === void 0 ? void 0 : _b.RenderHTMLOrMD;
+    if (RenderHTMLOrMD) {
+        return React.createElement(RenderHTMLOrMD, { content: content });
+    }
+    return React.createElement(Text, Object.assign({}, restProps, { dangerouslySetInnerHTML: { __html: content } }));
 };

package/build/esm/lib/unstable/kit/components/LayoutContainer/LayoutContainer.css

@@ -8,4 +8,7 @@
 }
 .sr-layout-container_hide-empty:not(:has([data-fill=populated])) {
   display: none;
+}
+.sr-layout-container_hidden {
+  display: none;
 }

package/build/esm/lib/unstable/kit/components/LayoutContainer/LayoutContainer.d.ts

@@ -4,5 +4,6 @@ import './LayoutContainer.css';
 export interface LayoutContainerProps extends FlexProps {
     children: React.ReactNode;
     hideEmpty?: boolean;
+    hidden?: boolean;
 }
 export declare const LayoutContainer: React.FC<LayoutContainerProps>;

package/build/esm/lib/unstable/kit/components/LayoutContainer/LayoutContainer.js

@@ -5,6 +5,6 @@ import { block } from '../../utils';
 import './LayoutContainer.css';
 const b = block('layout-container');
 export const LayoutContainer = (_a) => {
-    var { className, children, hideEmpty = false } = _a, restProps = __rest(_a, ["className", "children", "hideEmpty"]);
-    return (React.createElement(Flex, Object.assign({ className: b({ 'hide-empty': hideEmpty }, className), direction: "column" }, restProps), children));
+    var { className, children, hideEmpty = false, hidden = false } = _a, restProps = __rest(_a, ["className", "children", "hideEmpty", "hidden"]);
+    return (React.createElement(Flex, Object.assign({ className: b({ 'hide-empty': hideEmpty, hidden }, className), direction: "column" }, restProps), children));
 };

package/build/esm/lib/unstable/kit/constants/index.d.ts

@@ -1,2 +1,3 @@
 export { DASH, DEFAULT_DATE_FORMAT } from './common';
 export { config, untypedConfig } from './config';
+export { errorMessages } from './messages';

package/build/esm/lib/unstable/kit/constants/index.js

@@ -1,2 +1,3 @@
 export { DASH, DEFAULT_DATE_FORMAT } from './common';
 export { config, untypedConfig } from './config';
+export { errorMessages } from './messages';

package/build/esm/lib/unstable/kit/constants/messages.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorMessages } from '../../core';
+export declare let errorMessages: Required<ErrorMessages>;

package/build/esm/lib/unstable/kit/constants/messages.js

@@ -0,0 +1,85 @@
+import get from 'lodash/get';
+import i18n from '../../../kit/i18n';
+import { subscribeConfigure } from '../../../kit/i18n/configure';
+const TYPE_I18N_KEYS = {
+    array: 'label-sr_type-array',
+    boolean: 'label-sr_type-boolean',
+    integer: 'label-sr_type-integer',
+    null: 'label-sr_type-null',
+    number: 'label-sr_type-number',
+    object: 'label-sr_type-object',
+    string: 'label-sr_type-string',
+};
+const getErrorMessages = () => ({
+    additionalItems: (e) => {
+        const schema = e.data.schema;
+        if (Array.isArray(schema.items)) {
+            return i18n('label-sr_error-additional-items', { count: schema.items.length });
+        }
+        return e.message;
+    },
+    additionalProperties: (e) => {
+        const schema = e.data.schema;
+        if (schema.properties) {
+            return i18n('label-sr_error-additional-properties', {
+                count: Object.keys(schema.properties).length,
+            });
+        }
+        return e.message;
+    },
+    anyOf: i18n('label-sr_error-any-of'),
+    const: (e) => i18n('label-sr_error-const', { expected: JSON.stringify(e.data.expected) }),
+    contains: (e) => e.code === 'contains-min-error'
+        ? i18n('label-sr_error-contains-min')
+        : i18n('label-sr_error-contains'),
+    dependencies: (e) => {
+        let property = e.data.missingProperty;
+        const title = get(e, `data.schema.properties.${property}.title`);
+        if (typeof title === 'string') {
+            property = title;
+        }
+        return i18n('label-sr_error-dependencies', { property });
+    },
+    enum: (e) => i18n('label-sr_error-enum', { value: JSON.stringify(e.data.value) }),
+    exclusiveMaximum: (e) => i18n('label-sr_error-exclusive-maximum', { count: e.data.maximum }),
+    exclusiveMinimum: (e) => i18n('label-sr_error-exclusive-minimum', { count: e.data.minimum }),
+    maxItems: (e) => i18n('label-sr_error-max-items', { count: e.data.maximum }),
+    maxLength: (e) => i18n('label-sr_error-max-length', { count: e.data.maxLength }),
+    maxProperties: (e) => i18n('label-sr_error-max-properties', { count: e.data.maxProperties }),
+    maximum: (e) => i18n('label-sr_error-maximum', { count: e.data.maximum }),
+    minItems: (e) => i18n('label-sr_error-min-items', { count: e.data.minItems }),
+    minLength: (e) => i18n('label-sr_error-min-length', { count: e.data.minLength }),
+    minProperties: (e) => i18n('label-sr_error-min-properties', { count: e.data.minProperties }),
+    minimum: (e) => i18n('label-sr_error-minimum', { count: e.data.minimum }),
+    multipleOf: (e) => i18n('label-sr_error-multiple-of', { count: e.data.multipleOf }),
+    not: i18n('label-sr_error-not'),
+    oneOf: i18n('label-sr_error-one-of'),
+    pattern: (e) => i18n('label-sr_error-pattern', { pattern: e.data.pattern }),
+    propertyNames: (e) => i18n('label-sr_error-property-names', { property: e.data.property }),
+    required: i18n('label-sr_error-required'),
+    type: (e) => {
+        const types = e.data.expected.split(',');
+        let expected = '';
+        types.forEach((t, i, arr) => {
+            let type = t.trim();
+            if (TYPE_I18N_KEYS[type]) {
+                type = i18n(TYPE_I18N_KEYS[type]);
+            }
+            if (i === 0) {
+                expected += type;
+            }
+            else if (i === arr.length - 1) {
+                expected += i18n('label-sr_error-type-or', { type });
+            }
+            else {
+                expected += `, ${type}`;
+            }
+        });
+        return i18n('label-sr_error-type', { expected });
+    },
+    uniqueItems: i18n('label-sr_error-unique-items'),
+});
+export let errorMessages = getErrorMessages();
+subscribeConfigure(() => {
+    errorMessages = getErrorMessages();
+});

package/build/esm/lib/unstable/kit/entities/Alert/Alert.css

@@ -0,0 +1,16 @@
+.sr-alert .g-alert__text-content > div {
+  gap: 0 !important;
+}
+.sr-alert_expanded .g-alert__text-content > div {
+  gap: calc(var(--g-spacing-base) * 2) !important;
+}
+.sr-alert__title {
+  cursor: pointer;
+}
+.sr-alert__message {
+  height: 0;
+  overflow: hidden;
+}
+.sr-alert__message_expanded {
+  height: unset;
+}

package/build/esm/lib/unstable/kit/entities/Alert/Alert.d.ts

@@ -1,6 +1,7 @@
 import * as icons from '@gravity-ui/icons';
 import { type IconProps, type AlertProps as UIKitAlertProps } from '@gravity-ui/uikit';
 import type { JsonSchemaString, NodeEntity } from '../../../core';
+import './Alert.css';
 export interface AlertProps extends UIKitAlertProps {
     iconName?: keyof typeof icons;
     iconProps?: Partial<IconProps>;