@gravity-ui/dynamic-forms 5.19.0 → 5.20.0

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

@@ -0,0 +1,39 @@
+import type { SchemaToValueType } from './helpers';
+import type { JsonSchema } from './schema';
+import type { ObjectValue } from './values';
+type ArrayError = SyncValidateError[];
+interface ObjectError extends Record<string, SyncValidateError> {
+}
+export type SyncValidateError = ArrayError | boolean | string | ObjectError | undefined;
+export type AsyncValidateError = Promise<SyncValidateError>;
+export type SyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => SyncValidateError;
+export type AsyncValidator<Schema extends JsonSchema> = (value: SchemaToValueType<Schema> | null | undefined, allValues: ObjectValue) => AsyncValidateError;
+export type Validator<Schema extends JsonSchema> = SyncValidator<Schema> | AsyncValidator<Schema>;
+export interface ErrorMessages {
+    additionalItems?: string;
+    additionalProperties?: string;
+    anyOf?: string;
+    const?: string;
+    contains?: string;
+    dependencies?: string;
+    enum?: string;
+    exclusiveMaximum?: string;
+    exclusiveMinimum?: string;
+    maxItems?: string;
+    maxLength?: string;
+    maxProperties?: string;
+    maximum?: string;
+    minItems?: string;
+    minLength?: string;
+    minProperties?: string;
+    minimum?: string;
+    multipleOf?: string;
+    not?: string;
+    oneOf?: string;
+    pattern?: string;
+    propertyNames?: string;
+    required?: string;
+    type?: string;
+    uniqueItems?: string;
+}
+export {};

package/build/cjs/lib/unstable/core/types/values.d.ts

@@ -0,0 +1,4 @@
+export type ArrayValue = FieldValue[];
+export interface ObjectValue extends Record<string, FieldValue> {
+}
+export type FieldValue = number | boolean | string | ArrayValue | ObjectValue | null | undefined;

package/build/cjs/lib/unstable/core/useSchemaRenderer/constants.d.ts

@@ -0,0 +1 @@
+export declare const ENTITY_SERVICE_FIELD = "ENTITY_SERVICE_FIELD";

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { useEntitiesState } from './useEntitiesState';
+export { useSchemaRendererMutators } from './useSchemaRendererMutators';

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/useEntitiesState.d.ts

@@ -0,0 +1,7 @@
+export declare const useEntitiesState: (name: string) => {
+    config: import("../..").SchemaRendererConfig | undefined;
+    error: import("../..").SyncValidateError;
+    headName: string | undefined;
+    mode: import("../..").SchemaRendererMode | undefined;
+    rootSchema: import("../..").JsonSchema | undefined;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/hooks/useSchemaRendererMutators.d.ts

@@ -0,0 +1,10 @@
+import type { RemoveExternalErrorsMutator, RemoveSchemaMutatorsMutator, SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator, SetExternalErrorsMutator, SetSchemaMutatorsMutator, TriggerFieldsMutator } from '../mutators';
+export declare const useSchemaRendererMutators: () => {
+    removeExternalErrors: RemoveExternalErrorsMutator | undefined;
+    removeSchemaMutators: RemoveSchemaMutatorsMutator | undefined;
+    setAsyncValidationCache: SetAsyncValidationCacheMutator | undefined;
+    setAsyncValidationWaiters: SetAsyncValidationWaitersMutator | undefined;
+    setExternalErrors: SetExternalErrorsMutator | undefined;
+    setSchemaMutators: SetSchemaMutatorsMutator | undefined;
+    triggerFields: TriggerFieldsMutator | undefined;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/index.d.ts

@@ -0,0 +1,3 @@
+export { useEntitiesState, useSchemaRendererMutators } from './hooks';
+export { schemaRendererMutators } from './mutators';
+export { type UseSchemaRendererParams, type UseSchemaRendererReturn, useSchemaRenderer, } from './useSchemaRenderer';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.d.ts

@@ -0,0 +1,3 @@
+import type { SetAsyncValidationCacheFunction, SetAsyncValidationWaitersFunction } from './types';
+export declare const setAsyncValidationWaiters: SetAsyncValidationWaitersFunction;
+export declare const setAsyncValidationCache: SetAsyncValidationCacheFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.d.ts

@@ -0,0 +1,2 @@
+export * from './async-validation';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/async-validation/types.d.ts

@@ -0,0 +1,34 @@
+import type { MutableState, Tools } from 'final-form';
+import type { FieldValue, JsonSchema, SyncValidateError, Validator } from '../../../types';
+export interface AsyncValidationWaiter {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}
+export interface AsyncValidationCache extends AsyncValidationWaiter {
+    result: SyncValidateError;
+}
+export interface AsyncValidationState {
+    cache?: {
+        [key: string]: AsyncValidationCache[] | undefined;
+    };
+    waiters?: {
+        [key: string]: AsyncValidationWaiter | undefined;
+    };
+}
+export interface SetAsyncValidationWaitersParams {
+    headName: string;
+    waiters: {
+        [key: string]: AsyncValidationWaiter;
+    };
+}
+export type SetAsyncValidationWaitersFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationWaitersParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationWaitersMutator = (params: SetAsyncValidationWaitersParams) => void;
+export interface SetAsyncValidationCacheParams {
+    cache: {
+        [key: string]: AsyncValidationCache;
+    };
+    headName: string;
+}
+export type SetAsyncValidationCacheFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationCacheParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetAsyncValidationCacheMutator = (params: SetAsyncValidationCacheParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveExternalErrorsFunction, SetExternalErrorsFunction } from './types';
+export declare const setExternalErrors: SetExternalErrorsFunction;
+export declare const removeExternalErrors: RemoveExternalErrorsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.d.ts

@@ -0,0 +1,2 @@
+export * from './external-errors';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/external-errors/types.d.ts

@@ -0,0 +1,25 @@
+import type { MutableState, Tools } from 'final-form';
+import type { SyncValidateError } from '../../../types';
+export interface ExternalErrorsState {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export interface SetExternalErrorsParams {
+    priorityErrors?: {
+        [key: string]: SyncValidateError;
+    };
+    regularErrors?: {
+        [key: string]: SyncValidateError;
+    };
+}
+export type SetExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetExternalErrorsMutator = (params: SetExternalErrorsParams) => void;
+export interface RemoveExternalErrorsParams {
+    removeFunctionOrNames: string[] | ((headName: string, state: ExternalErrorsState) => ExternalErrorsState);
+}
+export type RemoveExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveExternalErrorsMutator = (params: RemoveExternalErrorsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/index.d.ts

@@ -0,0 +1,13 @@
+export type * from './async-validation';
+export type * from './external-errors';
+export type * from './schema-mutators';
+export type * from './trigger-fields';
+export declare const schemaRendererMutators: {
+    removeExternalErrors: import("./external-errors").RemoveExternalErrorsFunction;
+    removeSchemaMutators: import("./schema-mutators").RemoveSchemaMutatorsFunction;
+    setAsyncValidationCache: import("./async-validation").SetAsyncValidationCacheFunction;
+    setAsyncValidationWaiters: import("./async-validation").SetAsyncValidationWaitersFunction;
+    setExternalErrors: import("./external-errors").SetExternalErrorsFunction;
+    setSchemaMutators: import("./schema-mutators").SetSchemaMutatorsFunction;
+    triggerFields: import("./trigger-fields").TriggerFieldsFunction;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema-mutators';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.d.ts

@@ -0,0 +1,3 @@
+import type { RemoveSchemaMutatorsFunction, SetSchemaMutatorsFunction } from './types';
+export declare const setSchemaMutators: SetSchemaMutatorsFunction;
+export declare const removeSchemaMutators: RemoveSchemaMutatorsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/types.d.ts

@@ -0,0 +1,26 @@
+import type { MutableState, Tools } from 'final-form';
+import type { JsonSchema } from '../../../types';
+export interface SchemaMutatorsState {
+    mutators?: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+    originalSchema?: JsonSchema;
+    schema?: JsonSchema;
+}
+export interface SetSchemaMutatorsParams {
+    mutators: {
+        name: string;
+        schema: JsonSchema;
+    }[];
+}
+export type SetSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type SetSchemaMutatorsMutator = (params: SetSchemaMutatorsParams) => void;
+export interface RemoveSchemaMutatorsParams {
+    mutatorsToRemove: {
+        name: string;
+        schema: JsonSchema | true;
+    }[];
+}
+export type RemoveSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type RemoveSchemaMutatorsMutator = (params: RemoveSchemaMutatorsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.d.ts

@@ -0,0 +1,2 @@
+export * from './trigger-fields';
+export * from './types';

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.d.ts

@@ -0,0 +1,2 @@
+import type { TriggerFieldsFunction } from './types';
+export declare const triggerFields: TriggerFieldsFunction;

package/build/cjs/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/types.d.ts

@@ -0,0 +1,6 @@
+import type { MutableState, Tools } from 'final-form';
+export interface TriggerFieldsParams {
+    fields: string[];
+}
+export type TriggerFieldsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [TriggerFieldsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
+export type TriggerFieldsMutator = (params: TriggerFieldsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/types.d.ts

@@ -0,0 +1,22 @@
+import type { ErrorObject } from 'ajv';
+import type { SchemaRendererMode } from '../constants';
+import type { FieldValue, JsonSchema, SchemaRendererConfig, SyncValidateError, Validator } from '../types';
+import type { AsyncValidationState, ExternalErrorsState, SchemaMutatorsState } from './mutators';
+export type EntityParametersError = ErrorObject<'entityParameters', {
+    schema: JsonSchema;
+    validator: Validator<JsonSchema>;
+    value: FieldValue;
+}>;
+export interface ValidateErrorItem {
+    error: SyncValidateError;
+    path: string[];
+}
+export interface EntitiesState {
+    config?: SchemaRendererConfig;
+    errorsRef?: React.RefObject<Record<string, SyncValidateError>>;
+    headName?: string;
+    mode?: SchemaRendererMode;
+    schema?: SchemaMutatorsState['schema'];
+}
+export interface SchemaRendererState extends AsyncValidationState, ExternalErrorsState, SchemaMutatorsState {
+}

package/build/cjs/lib/unstable/core/useSchemaRenderer/useSchemaRenderer.d.ts

@@ -0,0 +1,37 @@
+import type { FieldValidator } from 'final-form';
+import { type SchemaRendererMode } from '../constants';
+import type { ErrorMessages, FieldValue, JsonSchema, SchemaRendererConfig } from '../types';
+export interface UseSchemaRendererParams {
+    config: SchemaRendererConfig;
+    connectValidate?: boolean;
+    errorMessages?: ErrorMessages;
+    mode: SchemaRendererMode;
+    /**
+     * The `name` prop must be a non-empty string.
+     *
+     * In `final-form` and `react-final-form`, the `name` is used as a key to register
+     * the field within the form. If you pass an empty string (`name=""`), the field will
+     * not be registered, its value will not be tracked, and validation will not work.
+     *
+     * This can lead to:
+     * - the field being missing from the form `values`;
+     * - the `validate` function not being called;
+     * - no error or touched state updates;
+     * - inconsistent or broken form behavior.
+     *
+     * Always provide a unique, non-empty string for the field name.
+     */
+    name: string;
+    schema: JsonSchema;
+}
+export type UseSchemaRendererReturn = {
+    schema: JsonSchema | undefined;
+    validate: FieldValidator<FieldValue> | undefined;
+};
+export declare const useSchemaRenderer: ({ config, connectValidate, errorMessages, mode, name, schema: originalSchema, }: UseSchemaRendererParams) => {
+    schema: JsonSchema | undefined;
+    validate?: undefined;
+} | {
+    schema: JsonSchema | undefined;
+    validate: (value?: FieldValue) => any;
+};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/common.d.ts

@@ -0,0 +1 @@
+export declare const guessHeadName: (registeredFields: string[], name: string) => string | undefined;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/get-ajv-validate.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorObject, ValidateFunction } from 'ajv';
+import type { JsonSchema, SchemaRendererConfig } from '../../types';
+import type { EntityParametersError } from '../types';
+export interface GetAjvValidateParams {
+    config: SchemaRendererConfig;
+    schema: JsonSchema;
+}
+export interface GetAjvValidateReturn extends ValidateFunction {
+    errors?: (ErrorObject | EntityParametersError)[];
+}
+export declare const getAjvValidate: ({ config, schema }: GetAjvValidateParams) => GetAjvValidateReturn;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/get-validate.d.ts

@@ -0,0 +1,14 @@
+import { type FieldValidator } from 'final-form';
+import type { ErrorMessages, FieldValue, SchemaRendererConfig, SyncValidateError } from '../../types';
+import type { SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator } from '../mutators';
+export type GetValidateParams = {
+    config: SchemaRendererConfig;
+    errorMessages: ErrorMessages;
+    name: string;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    setAsyncValidationWaiters?: SetAsyncValidationWaitersMutator;
+    setErrors: (errors: Record<string, SyncValidateError>) => void;
+};
+type GetValidateReturn = FieldValidator<FieldValue>;
+export declare const getValidate: ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }: GetValidateParams) => GetValidateReturn;
+export {};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/index.d.ts

@@ -0,0 +1,2 @@
+export { guessHeadName } from './common';
+export { getValidate } from './get-validate';

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.d.ts

@@ -0,0 +1,10 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema } from '../../types';
+import type { ValidateErrorItem } from '../types';
+export interface ProcessAjvErrorParams<Schema extends JsonSchema> {
+    error: ErrorObject;
+    errorMessages: ErrorMessages;
+    schema: Schema;
+    onError: (error: ValidateErrorItem) => void;
+}
+export declare const processAjvError: <Schema extends JsonSchema>({ error, errorMessages, schema, onError, }: ProcessAjvErrorParams<Schema>) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.d.ts

@@ -0,0 +1,20 @@
+import type { ErrorObject } from 'ajv';
+import type { ErrorMessages, JsonSchema, ObjectValue } from '../../types';
+import type { AsyncValidationState, AsyncValidationWaiter, SetAsyncValidationCacheMutator } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessAjvValidateErrorsParams<Schema extends JsonSchema> {
+    ajvValidateErrors: (ErrorObject | EntityParametersError)[];
+    allValues: ObjectValue;
+    errorMessages: ErrorMessages;
+    name: string;
+    schema: Schema;
+    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
+    validationState: AsyncValidationState | undefined;
+}
+interface ProcessAjvValidateErrorsReturn {
+    ajvErrorItems: ValidateErrorItem[];
+    entityParametersErrorItems: ValidateErrorItem[];
+    waiters: Record<string, AsyncValidationWaiter>;
+}
+export declare const processAjvValidateErrors: <Schema extends JsonSchema>({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }: ProcessAjvValidateErrorsParams<Schema>) => ProcessAjvValidateErrorsReturn;
+export {};

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.d.ts

@@ -0,0 +1,15 @@
+import type { AsyncValidateError, ObjectValue } from '../../types';
+import type { AsyncValidationState } from '../mutators';
+import type { EntityParametersError, ValidateErrorItem } from '../types';
+export interface ProcessEntityParametersErrorParams {
+    allValues: ObjectValue;
+    error: EntityParametersError;
+    onAsyncError: (waiter: {
+        instancePath: string;
+        params: EntityParametersError['params'];
+        promise: AsyncValidateError;
+    }) => void;
+    onError: (error: ValidateErrorItem) => void;
+    validationState: AsyncValidationState | undefined;
+}
+export declare const processEntityParametersError: ({ allValues, error, onAsyncError, onError, validationState, }: ProcessEntityParametersErrorParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/process-errors-state.d.ts

@@ -0,0 +1,12 @@
+import type { ExternalErrorsState } from '../mutators';
+import type { ValidateErrorItem } from '../types';
+interface ProcessErrorsStateParams {
+    errorsState: ExternalErrorsState | undefined;
+    name: string;
+}
+interface ProcessErrorsStateReturn {
+    externalPriorityErrorItems: ValidateErrorItem[];
+    externalRegularErrorItems: ValidateErrorItem[];
+}
+export declare const processErrorsState: ({ errorsState, name, }: ProcessErrorsStateParams) => ProcessErrorsStateReturn;
+export {};

package/build/cjs/lib/unstable/core/utils/common.d.ts

@@ -0,0 +1,49 @@
+import type { JsonSchema } from '../types';
+/**
+ * Parses an AJV `schemaPath` (JSON Pointer) into an array of path segments
+ * suitable for lodash `get`.
+ *
+ * Strips the `#/` prefix, decodes URI-encoded characters, splits on `/`,
+ * and unescapes JSON Pointer tokens (`~1` → `/`, `~0` → `~`).
+ *
+ * Returns all segments unchanged; stripping a trailing validation keyword
+ * (e.g. `minLength`) before lookup is the caller's responsibility.
+ *
+ * @param schemaPath - JSON Pointer string, e.g. `"#/properties/name/minLength"`.
+ * @returns Path segments, e.g. `['properties', 'name', 'minLength']`.
+ */
+export declare const parseSchemaPath: (schemaPath: string) => string[];
+export declare const parseInstancePath: (instancePath: string) => string[];
+export declare const parseFinalFormName: (finalFormName: string) => string[];
+export declare const formatFinalFormPath: (finalFormPath: string[]) => string;
+export declare const getSchemaPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => string[] | undefined;
+/**
+ * Resolves a sub-schema from the root schema by an AJV `schemaPath`.
+ *
+ * Parses `schemaPath` via `parseSchemaPath` and looks up the node with lodash `get`.
+ * The path must point to a schema object, not to a validation keyword — callers
+ * should strip the trailing keyword first (see `processAjvError`).
+ *
+ * @param schemaPath - JSON Pointer string pointing to a schema node,
+ *   e.g. `"#/properties/name"`.
+ * @param schema - The root JSON schema object.
+ *
+ * @example
+ * const nameSchema = {
+ *   minLength: 5,
+ * };
+ * const objectSchema = {
+ *   properties: {
+ *     name: nameSchema,
+ *   },
+ * };
+ * getSchemaBySchemaPath("#/properties/name", objectSchema); // returns nameSchema
+ *
+ * @returns The sub-schema at the given path, or the root schema when the path is empty.
+ */
+export declare const getSchemaBySchemaPath: (schemaPath: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getSchemaByInstancePath: (instancePath: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getSchemaByFinalFormPath: (finalFormNameOrPath: string | string[], finalFormHeadName: string, schema: JsonSchema) => JsonSchema | undefined;
+export declare const getValuePaths: (value: unknown, path?: string[]) => string[][];
+export declare const smartSet: (object: object, path: string[], value: unknown) => object;
+export declare const smartMerge: (first: object, second: object, deep?: boolean) => {};

package/build/cjs/lib/unstable/core/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './common';

package/build/cjs/lib/unstable/kit/components/ArrayRemoveButton/ArrayRemoveButton.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface ArrayRemoveButtonProps {
+    name: string;
+    onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
+}
+export declare const ArrayRemoveButton: React.FC<ArrayRemoveButtonProps>;

package/build/cjs/lib/unstable/kit/components/ArrayRemoveButton/ArrayRemoveButton.js

@@ -7,21 +7,28 @@ const icons_1 = require("@gravity-ui/icons");
 const uikit_1 = require("@gravity-ui/uikit");
 const react_final_form_1 = require("react-final-form");
 const utils_1 = require("../../utils");
-const ArrayRemoveButton = ({ name }) => {
+const ArrayRemoveButton = ({ name, onClick }) => {
     const form = (0, react_final_form_1.useForm)();
+    const [ready, setReady] = react_1.default.useState(false);
     const arrayItem = (0, utils_1.isArrayItem)(name);
     const tupleItem = (0, utils_1.isTupleItem)(name, form);
-    const removeItem = react_1.default.useCallback(() => {
+    const removeItem = react_1.default.useCallback((event) => {
         var _a;
+        onClick === null || onClick === void 0 ? void 0 : onClick(event);
         const parentName = (0, utils_1.getArrayItemParentName)(name);
         const parentValue = (_a = form.getFieldState(parentName)) === null || _a === void 0 ? void 0 : _a.value;
         const index = Number((0, utils_1.getArrayItemIndex)(name));
         if (Array.isArray(parentValue)) {
+            form.focus(parentName);
             form.change(parentName, parentValue.filter((_, i) => i !== index));
+            form.blur(parentName);
         }
-    }, [form, name]);
-    if (arrayItem && !tupleItem) {
-        return (react_1.default.createElement(uikit_1.Button, { view: "flat-secondary", onClick: removeItem, qa: `${name}-remove-item` },
+    }, [form, name, onClick]);
+    react_1.default.useLayoutEffect(() => {
+        setReady(true);
+    }, []);
+    if (ready && arrayItem && !tupleItem) {
+        return (react_1.default.createElement(uikit_1.Button, { view: "flat-secondary", onClick: removeItem, qa: `${name}-remove-button` },
             react_1.default.createElement(uikit_1.Icon, { data: icons_1.TrashBin, size: 16 })));
     }
     return null;

package/build/cjs/lib/unstable/kit/components/ArrayRemoveButton/index.d.ts

@@ -0,0 +1 @@
+export { ArrayRemoveButton, type ArrayRemoveButtonProps } from './ArrayRemoveButton';

package/build/cjs/lib/unstable/kit/components/ControlContainer/ControlContainer.css

@@ -0,0 +1,20 @@
+.sr-control-container {
+  display: flex;
+  flex-direction: column;
+}
+.sr-control-container_stretch_max {
+  width: 100%;
+  flex: 1 0 0;
+}
+.sr-control-container_stretch_fit {
+  width: fit-content;
+  flex: 0 0 auto;
+}
+.sr-control-container_stretch_by-child {
+  width: fit-content;
+  flex: 0 0 auto;
+}
+.sr-control-container_stretch_by-child:has([data-stretch=max]) {
+  width: 100%;
+  flex: 1 0 0;
+}

package/build/cjs/lib/unstable/kit/components/ControlContainer/ControlContainer.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { type FlexProps } from '@gravity-ui/uikit';
+export interface ControlContainerProps extends FlexProps {
+    stretch: 'max' | 'fit' | 'by-child';
+    children: React.ReactNode;
+}
+export declare const ControlContainer: React.NamedExoticComponent<ControlContainerProps>;

package/build/cjs/lib/unstable/kit/components/ControlContainer/ControlContainer.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlContainer = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const uikit_1 = require("@gravity-ui/uikit");
+const utils_1 = require("../../utils");
+const b = (0, utils_1.block)('control-container');
+const Component = (_a) => {
+    var { stretch, children } = _a, restFlexProps = tslib_1.__rest(_a, ["stretch", "children"]);
+    return (react_1.default.createElement("div", { className: b({ stretch }), "data-stretch": stretch },
+        react_1.default.createElement(uikit_1.Flex, Object.assign({ direction: "column" }, restFlexProps, { grow: 1 }), children)));
+};
+exports.ControlContainer = react_1.default.memo(Component);

package/build/cjs/lib/unstable/kit/components/ControlContainer/index.d.ts

@@ -0,0 +1 @@
+export { ControlContainer, type ControlContainerProps } from './ControlContainer';

package/build/cjs/lib/unstable/kit/components/ControlContainer/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ControlContainer = void 0;
+var ControlContainer_1 = require("./ControlContainer");
+Object.defineProperty(exports, "ControlContainer", { enumerable: true, get: function () { return ControlContainer_1.ControlContainer; } });

package/build/cjs/lib/unstable/kit/components/ControlError/ControlError.css

@@ -1,33 +1,3 @@
-.sr-control-error__children {
-  width: 100%;
-}
-.sr-control-error__children_errors .g-control-label:not(.g-control-label_disabled) .g-checkbox__indicator:hover::before {
-  border: 1px solid var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-control-label:not(.g-control-label_disabled) .g-checkbox__indicator::before {
-  border: 1px solid var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-text-input:not(.g-text-input_disabled) .g-text-input__content {
-  border-color: var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-text-input:not(.g-text-input_disabled) .g-text-input__content:hover {
-  border-color: var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-text-area__content {
-  border-color: var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-text-area__content:hover {
-  border-color: var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-select-control:not(.g-select-control_disabled) .g-select-control__button:hover::before {
-  border: 1px solid var(--g-color-text-danger) !important;
-}
-.sr-control-error__children_errors .g-select-control:not(.g-select-control_disabled) .g-select-control__button::before {
-  border: 1px solid var(--g-color-text-danger) !important;
-}
-.sr-control-error__children_errors .g-segmented-radio-group:not([aria-disabled=true]) .g-segmented-radio-group__option_checked:hover::after {
-  border: 1px solid var(--g-color-text-danger);
-}
-.sr-control-error__children_errors .g-segmented-radio-group:not([aria-disabled=true]) .g-segmented-radio-group__option_checked::after {
-  border: 1px solid var(--g-color-text-danger);
+.sr-control-error {
+  margin-top: 2px;
 }

package/build/cjs/lib/unstable/kit/components/ControlError/ControlError.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export interface ControlErrorProps {
+    errorMessage?: string;
+    validationState?: 'invalid';
+}
+export declare const ControlError: React.FC<ControlErrorProps>;

package/build/cjs/lib/unstable/kit/components/ControlError/ControlError.js

@@ -6,10 +6,10 @@ const react_1 = tslib_1.__importDefault(require("react"));
 const uikit_1 = require("@gravity-ui/uikit");
 const utils_1 = require("../../utils");
 const b = (0, utils_1.block)('control-error');
-const ControlError = ({ className, errorMessage, validationState, children, }) => {
-    const error = validationState === 'invalid' && errorMessage ? (react_1.default.createElement(uikit_1.Text, { color: "danger" }, errorMessage)) : null;
-    return (react_1.default.createElement(uikit_1.Flex, { className: b(null, className), width: "100%", direction: "column", alignItems: "flex-start" },
-        react_1.default.createElement("div", { className: b('children', { errors: Boolean(error) }) }, children),
-        error));
+const ControlError = ({ errorMessage, validationState }) => {
+    if (validationState === 'invalid' && errorMessage) {
+        return (react_1.default.createElement(uikit_1.Text, { className: b(), color: "danger" }, errorMessage));
+    }
+    return null;
 };
 exports.ControlError = ControlError;

package/build/cjs/lib/unstable/kit/components/ControlError/index.d.ts

@@ -0,0 +1 @@
+export { ControlError, type ControlErrorProps } from './ControlError';

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

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

package/build/cjs/lib/unstable/kit/components/HTMLContent/index.d.ts

@@ -0,0 +1 @@
+export { HTMLContent, type HTMLContentProps } from './HTMLContent';