@gravity-ui/dynamic-forms 5.24.0 → 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/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/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/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/ArrayTable/ArrayTable.js

@@ -57,7 +57,7 @@ export const ArrayTable = ({ headName, input, mode, props, schema, schemaPath, }
     }, [props.order, schema.items]);
     const { head, rows } = React.useMemo(() => {
         let tupleItems = false;
-        let rowsCount = value === null || value === void 0 ? void 0 : value.length;
+        let rowsCount = (value === null || value === void 0 ? void 0 : value.length) || 0;
         let withRemoveButton = true;
         const getItemName = (index, property) => `${name}[${index}]${property === undefined ? '' : `.${property}`}`;
         const getItemSchemaPath = (index, property) => `${schemaPath}/items${tupleItems ? `/${index}` : ''}${property === undefined ? '' : `/properties/${property}`}`;
@@ -94,7 +94,7 @@ export const ArrayTable = ({ headName, input, mode, props, schema, schemaPath, }
     }
     return (React.createElement(EntityContainer, { stretch: "by-child", gap: 2, fill: "by-child" },
         React.createElement("div", null,
-            head,
+            rows.length ? head : null,
             rows),
         addButton));
 };

package/build/esm/lib/unstable/kit/form-entities/SegmentedRadioGroupInput/SegmentedRadioGroupInput.css

@@ -3,4 +3,8 @@
 }
 .sr-segmented-radio-group-input_error .g-segmented-radio-group .g-segmented-radio-group__option_checked::after {
   border: 1px solid var(--g-color-text-danger);
+}
+.sr-segmented-radio-group-input_overflowed {
+  height: 0;
+  opacity: 0;
 }

package/build/esm/lib/unstable/kit/form-entities/SegmentedRadioGroupInput/SegmentedRadioGroupInput.d.ts

@@ -1,7 +1,7 @@
 import { type SegmentedRadioGroupProps } from '@gravity-ui/uikit';
 import type { JsonSchemaString, NodeEntity } from '../../../core';
 import './SegmentedRadioGroupInput.css';
-export interface SegmentedRadioGroupInputProps extends Omit<SegmentedRadioGroupProps, 'value' | 'onFocus' | 'onBlur' | 'onChange' | 'onUpdate' | 'qa'> {
+export interface SegmentedRadioGroupInputProps extends Omit<SegmentedRadioGroupProps, 'children' | 'defaultValue' | 'value' | 'onFocus' | 'onBlur' | 'onChange' | 'onUpdate' | 'qa'> {
     enumDescriptions?: Record<string, string>;
     optionsDisabled?: Record<string, boolean>;
 }

package/build/esm/lib/unstable/kit/form-entities/SegmentedRadioGroupInput/SegmentedRadioGroupInput.js

@@ -3,13 +3,17 @@ import React from 'react';
 import { SegmentedRadioGroup } from '@gravity-ui/uikit';
 import { EntityContainer } from '../../components';
 import { block, getBooleanValidationState } from '../../utils';
+import { SelectInput } from '../SelectInput';
 import './SegmentedRadioGroupInput.css';
 const b = block('segmented-radio-group-input');
-export const SegmentedRadioGroupInput = ({ input, meta, props, schema }) => {
-    var _a;
+export const SegmentedRadioGroupInput = (_a) => {
+    var _b;
+    var { input, meta, props, schema } = _a, restProps = __rest(_a, ["input", "meta", "props", "schema"]);
     const { name, onBlur, onChange, onFocus, value } = input;
     const { enumDescriptions, optionsDisabled } = props, restEntityProps = __rest(props, ["enumDescriptions", "optionsDisabled"]);
-    const { disabled } = ((_a = schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.flags) || {};
+    const { disabled } = ((_b = schema.nodeParameters) === null || _b === void 0 ? void 0 : _b.flags) || {};
+    const ref = React.useRef(null);
+    const [overflowed, setOverflowed] = React.useState(false);
     const options = React.useMemo(() => {
         var _a;
         return (_a = schema.enum) === null || _a === void 0 ? void 0 : _a.map((value) => ({
@@ -23,6 +27,27 @@ export const SegmentedRadioGroupInput = ({ input, meta, props, schema }) => {
         onChange(value);
         onBlur();
     }, [onBlur, onChange, onFocus]);
-    return (React.createElement(EntityContainer, { stretch: "max", className: b({ error: getBooleanValidationState(meta) }) },
-        React.createElement(SegmentedRadioGroup, Object.assign({ width: "max", disabled: disabled || schema.readOnly, options: options }, restEntityProps, { value: value, onFocus: onFocus, onBlur: onBlur, onUpdate: onUpdate, qa: name }))));
+    React.useLayoutEffect(() => {
+        const root = ref.current;
+        if (!root) {
+            return;
+        }
+        const measure = () => {
+            const texts = root.querySelectorAll('.g-segmented-radio-group__option-text');
+            setOverflowed(Array.from(texts).some((node) => {
+                if (node.offsetWidth === 0 && node.scrollWidth === 0) {
+                    return false;
+                }
+                return node.scrollWidth > node.clientWidth;
+            }));
+        };
+        measure();
+        const observer = new ResizeObserver(measure);
+        observer.observe(root);
+        return () => observer.disconnect();
+    }, [options]);
+    return (React.createElement(EntityContainer, { stretch: "max" },
+        overflowed ? (React.createElement(SelectInput, Object.assign({ input: input, meta: meta, props: props, schema: schema }, restProps))) : null,
+        React.createElement(EntityContainer, { stretch: "max", className: b({ error: getBooleanValidationState(meta), overflowed }) },
+            React.createElement(SegmentedRadioGroup, Object.assign({ ref: ref, width: "max", disabled: disabled || schema.readOnly, options: options }, restEntityProps, { value: value, onFocus: onFocus, onBlur: onBlur, onUpdate: onUpdate, qa: name })))));
 };

package/build/esm/lib/unstable/kit/form-entities/SelectInput/SelectInput.d.ts

@@ -1,8 +1,7 @@
 import { type SelectProps } from '@gravity-ui/uikit';
 import type { JsonSchemaString, NodeEntity } from '../../../core';
-export interface SelectInputProps extends Omit<SelectProps, 'value' | 'onFocus' | 'onBlur' | 'onChange' | 'onUpdate' | 'multiple' | 'errorMessage' | 'validationState' | 'qa'> {
+export interface SelectInputProps extends Omit<SelectProps, 'defaultValue' | 'value' | 'onFocus' | 'onBlur' | 'onChange' | 'onUpdate' | 'multiple' | 'errorMessage' | 'validationState' | 'qa'> {
     enumDescriptions?: Record<string, string>;
     optionsMeta?: Record<string, string>;
-    options?: SelectProps['options'];
 }
 export declare const SelectInput: NodeEntity<JsonSchemaString, SelectInputProps>;

package/build/esm/lib/unstable/kit/form-layouts/FormRow/FormRow.css

@@ -22,4 +22,7 @@
 }
 .sr-form-row__help-mark {
   margin-top: 1.5px;
+}
+.sr-form-row__right {
+  max-width: calc(100% - 180px - var(--g-spacing-base) * 2);
 }

package/build/esm/lib/unstable/kit/layouts/Accordeon/Accordeon.js

@@ -12,34 +12,36 @@ export const Accordeon = ({ children, headName, input, meta, mode, schema, props
     const { titleProps, togglerProps, withIndent = false, withDefaultSummary = false } = props, restLayoutProps = __rest(props, ["titleProps", "togglerProps", "withIndent", "withDefaultSummary"]);
     const { copy, required, hidden, open } = ((_a = schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.flags) || {};
     const overviewFlag = mode === SchemaRendererMode.Overview;
-    const summary = React.useMemo(() => {
-        const stopPropagation = (event) => {
-            event.stopPropagation();
-        };
-        return (React.createElement(Flex, { alignItems: "center", gap: 2 },
-            withDefaultSummary ? (React.createElement(Text, Object.assign({}, titleProps, { className: b('title', { required: required && !overviewFlag }, titleProps === null || titleProps === void 0 ? void 0 : titleProps.className) }), schema.title)) : (React.createElement(Disclosure.Summary, null, (props) => (React.createElement(Button, Object.assign({}, togglerProps, { className: b('toggler', togglerProps === null || togglerProps === void 0 ? void 0 : togglerProps.className) }),
-                React.createElement(Flex, { alignItems: "center", gap: 2, height: "100%" },
-                    React.createElement(Icon, { data: props.expanded ? ChevronUp : ChevronDown }),
-                    React.createElement(Text, Object.assign({}, titleProps, { className: b('title', { required: required && !overviewFlag }, titleProps === null || titleProps === void 0 ? void 0 : titleProps.className) }), schema.title)))))),
-            schema.description ? (React.createElement(HelpMark, { onClick: stopPropagation },
-                React.createElement(HTMLContent, { content: schema.description, headName: headName }))) : null,
-            overviewFlag ? (React.createElement(CopyButton, { className: b('copy-button'), copy: copy, value: input.value })) : null,
-            overviewFlag ? null : (React.createElement(ArrayRemoveButton, { name: input.name, headName: headName, onClick: stopPropagation }))));
-    }, [
-        copy,
-        headName,
-        input.name,
-        input.value,
-        overviewFlag,
-        required,
-        schema.title,
-        schema.description,
-        titleProps,
-        togglerProps,
-        withDefaultSummary,
-    ]);
+    const summary = React.useMemo(() => (React.createElement(Text, Object.assign({}, titleProps, { className: b('title', { required: required && !overviewFlag }, titleProps === null || titleProps === void 0 ? void 0 : titleProps.className) }), schema.title)), [overviewFlag, required, schema.title, titleProps]);
+    const helpMark = React.useMemo(() => {
+        if (schema.description) {
+            return (React.createElement(HelpMark, null,
+                React.createElement(HTMLContent, { content: schema.description, headName: headName })));
+        }
+        return null;
+    }, [schema.description, headName]);
+    const copyButton = React.useMemo(() => {
+        if (overviewFlag) {
+            return React.createElement(CopyButton, { className: b('copy-button'), copy: copy, value: input.value });
+        }
+        return null;
+    }, [overviewFlag, copy, input.value]);
+    const removeButton = React.useMemo(() => {
+        if (overviewFlag) {
+            return null;
+        }
+        return React.createElement(ArrayRemoveButton, { name: input.name, headName: headName });
+    }, [overviewFlag, input.name, headName]);
     return (React.createElement(LayoutContainer, { className: b({ 'without-default-summary': !withDefaultSummary }), hideEmpty: overviewFlag, hidden: hidden },
-        React.createElement(Disclosure, Object.assign({ summary: summary, defaultExpanded: open }, restLayoutProps),
+        React.createElement(Disclosure, Object.assign({ defaultExpanded: open, summary: summary }, restLayoutProps),
+            React.createElement(Disclosure.Summary, null, ({ expanded, onClick }, defaultSummary) => (React.createElement(Flex, { minHeight: "28px", alignItems: "center", gap: 2 },
+                withDefaultSummary ? (defaultSummary) : (React.createElement(Button, Object.assign({}, togglerProps, { onClick: onClick, className: b('toggler', togglerProps === null || togglerProps === void 0 ? void 0 : togglerProps.className) }),
+                    React.createElement(Flex, { alignItems: "center", gap: 2, height: "100%" },
+                        React.createElement(Icon, { data: expanded ? ChevronUp : ChevronDown }),
+                        summary))),
+                helpMark,
+                copyButton,
+                removeButton))),
             React.createElement(Flex, { direction: "column", gap: 0.5, grow: 1 },
                 React.createElement("div", { className: b('content', { 'with-indent': withIndent }) }, children),
                 overviewFlag ? null : (React.createElement(EntityError, { errorMessage: meta.error, validationState: getValidationState(meta) }))))));

package/build/esm/lib/unstable/kit/utils/transformer.d.ts

@@ -1,11 +1,11 @@
 import { type Spec } from '../../../core';
-import { type JsonSchema } from '../../core';
+import { type ErrorMessages, type JsonSchema } from '../../core';
 type Rules = Record<string, (spec: Spec, mutableSchema: JsonSchema, rules: {
     specRules: Rules;
     viewSpecRules: Rules;
-}) => void>;
+}, errorMessages: ErrorMessages) => void>;
 export declare function specToJsonSchema(spec: Spec, mutableSchema?: JsonSchema, rules?: {
     specRules: Rules;
     viewSpecRules: Rules;
-}): JsonSchema;
+}, errorMessages?: ErrorMessages): JsonSchema;
 export {};

package/build/esm/lib/unstable/kit/utils/transformer.js

@@ -3,6 +3,7 @@ import isObject from 'lodash/isObject';
 import set from 'lodash/set';
 import { SpecTypes } from '../../../core';
 import { JsonSchemaType, NodeType } from '../../core';
+import { errorMessages as defaultErrorMessages } from '../constants';
 const viewSpecRules = {
     disabled: (spec, mutableSchema) => {
         if (spec.viewSpec.disabled) {
@@ -549,11 +550,16 @@ const specRules = {
             set(mutableSchema, 'nodeParameters.type', specTypeToNodeType[spec.type]);
         }
     },
-    required: (spec, mutableSchema) => {
+    required: (spec, mutableSchema, _rules, errorMessages) => {
         if (spec.required) {
             set(mutableSchema, 'allOf', [
                 ...(mutableSchema.allOf || []),
-                { not: { enum: [null, undefined, '', false] } },
+                {
+                    not: {
+                        enum: [null, undefined, '', false],
+                        nodeParameters: { errorMessages: { not: errorMessages.required } },
+                    },
+                },
             ]);
             set(mutableSchema, 'nodeParameters.flags.required', true);
         }
@@ -586,12 +592,12 @@ const specRules = {
             }
         }
     },
-    items: (spec, mutableSchema, rules) => {
+    items: (spec, mutableSchema, rules, errorMessages) => {
         if (spec.type === SpecTypes.Array && spec.items) {
             const childSchema = specToJsonSchema(spec.items, 'items' in mutableSchema &&
                 mutableSchema.items &&
                 !Array.isArray(mutableSchema.items)
-                ? Object.assign({}, mutableSchema.items) : {}, rules);
+                ? Object.assign({}, mutableSchema.items) : {}, rules, errorMessages);
             set(mutableSchema, 'items', childSchema);
         }
     },
@@ -649,10 +655,10 @@ const specRules = {
             set(mutableSchema, 'type', JsonSchemaType.Integer);
         }
     },
-    properties: (spec, mutableSchema, rules) => {
+    properties: (spec, mutableSchema, rules, errorMessages) => {
         if (spec.type === SpecTypes.Object && spec.properties) {
             Object.entries(spec.properties).forEach(([key, childSpec]) => {
-                const childSchema = specToJsonSchema(childSpec, Object.assign({}, (get(mutableSchema, ['properties', key]) || {})), rules);
+                const childSchema = specToJsonSchema(childSpec, Object.assign({}, (get(mutableSchema, ['properties', key]) || {})), rules, errorMessages);
                 set(mutableSchema, ['properties', key], childSchema);
             });
         }
@@ -667,13 +673,13 @@ const specRules = {
             set(mutableSchema, 'nodeParameters.errorMessages.pattern', spec.patternError);
         }
     },
-    viewSpec: (spec, mutableSchema, rules) => {
-        Object.values(rules.viewSpecRules).forEach((rule) => rule(spec, mutableSchema, rules));
+    viewSpec: (spec, mutableSchema, rules, errorMessages) => {
+        Object.values(rules.viewSpecRules).forEach((rule) => rule(spec, mutableSchema, rules, errorMessages));
     },
 };
-export function specToJsonSchema(spec, mutableSchema = {}, rules) {
+export function specToJsonSchema(spec, mutableSchema = {}, rules, errorMessages = defaultErrorMessages) {
     const mergedSpecRules = Object.assign(Object.assign({}, specRules), rules === null || rules === void 0 ? void 0 : rules.specRules);
     const mergedViewSpecRules = Object.assign(Object.assign({}, viewSpecRules), rules === null || rules === void 0 ? void 0 : rules.viewSpecRules);
-    Object.values(mergedSpecRules).forEach((rule) => rule(spec, mutableSchema, { specRules: mergedSpecRules, viewSpecRules: mergedViewSpecRules }));
+    Object.values(mergedSpecRules).forEach((rule) => rule(spec, mutableSchema, { specRules: mergedSpecRules, viewSpecRules: mergedViewSpecRules }, errorMessages));
     return mutableSchema;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/dynamic-forms",
-  "version": "5.24.0",
+  "version": "5.25.0",
   "description": "",
   "license": "MIT",
   "main": "build/cjs/index.js",