@gravity-ui/dynamic-forms 5.19.1 → 5.21.0

package/build/esm/lib/unstable/kit/entities/FewOfNested/FewOfNested.js

@@ -0,0 +1,69 @@
+import React from 'react';
+import isString from 'lodash/isString';
+import { SchemaRendererEventType, SchemaRendererMode, SchemaRendererNode, getRenderKit, useSchemaRendererState, } from '../../../core';
+import { EntityContainer, LayoutContainer } from '../../components';
+import { block } from '../../utils';
+import './FewOfNested.css';
+const b = block('few-of-nested');
+export const FewOfNested = ({ Layout, headName, input, layoutProps, meta, mode, props, schema, schemaPath, }) => {
+    const { name, value } = input;
+    const { togglerArrayRemoveButton = false, toggler: togglerSchema = {}, withIndent = false, } = props;
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    const srState = useSchemaRendererState({
+        headName,
+        subscriptions: [SchemaRendererEventType.Config],
+    });
+    const [togglerValues, setTogglerValues] = React.useState(() => {
+        if (value && Object.keys(value).length) {
+            return Object.keys(value);
+        }
+        if (!overviewFlag && schema.properties && Object.keys(schema.properties).length) {
+            return [Object.keys(schema.properties)[0]];
+        }
+        return [];
+    });
+    const toggler = React.useMemo(() => {
+        let result = null;
+        const renderKit = getRenderKit({ config: srState === null || srState === void 0 ? void 0 : srState.config, schema: togglerSchema });
+        const { Entity, Layout, entityProps, independent, layoutProps } = renderKit[mode];
+        const togglerInput = Object.assign(Object.assign({}, input), { name: togglerArrayRemoveButton ? name : `${name}._____toggler`, value: togglerValues, onChange: (value) => {
+                if (Array.isArray(value)) {
+                    setTogglerValues(value.filter(isString));
+                }
+            } });
+        const togglerMeta = Object.assign(Object.assign({}, meta), { error: undefined });
+        if (Entity) {
+            result = (React.createElement(Entity, { Layout: independent ? Layout : undefined, headName: headName, input: togglerInput, layoutProps: independent ? layoutProps : undefined, meta: togglerMeta, mode: mode, props: entityProps, schema: togglerSchema, schemaPath: "___stub" }));
+            if (Layout && !independent) {
+                result = (React.createElement(Layout, { headName: headName, input: togglerInput, meta: togglerMeta, mode: mode, props: layoutProps, schema: togglerSchema, schemaPath: "___stub" }, result));
+            }
+        }
+        return result;
+    }, [
+        headName,
+        input,
+        meta,
+        mode,
+        name,
+        srState === null || srState === void 0 ? void 0 : srState.config,
+        togglerArrayRemoveButton,
+        togglerSchema,
+        togglerValues,
+    ]);
+    const wrapperInput = React.useMemo(() => {
+        if (!togglerArrayRemoveButton) {
+            return input;
+        }
+        return Object.assign(Object.assign({}, input), { name: `${name}._____wrapper` });
+    }, [name, input, togglerArrayRemoveButton]);
+    let content = (React.createElement(EntityContainer, { direction: "column-reverse", stretch: "by-child", fill: "populated" },
+        togglerValues.length ? (React.createElement(LayoutContainer, { className: b('content', { 'with-indent': withIndent }), hideEmpty: overviewFlag }, togglerValues.map((togglerValue) => (React.createElement(SchemaRendererNode, { headName: headName, key: togglerValue, name: `${name ? name + '.' : ''}${togglerValue}`, schemaPath: `${schemaPath}/properties/${togglerValue}` }))))) : null,
+        toggler));
+    if (overviewFlag && togglerValues.length === 0) {
+        content = React.createElement(React.Fragment, null, toggler);
+    }
+    if (Layout) {
+        content = (React.createElement(Layout, { headName: headName, input: wrapperInput, meta: meta, mode: mode, schema: schema, schemaPath: schemaPath, props: layoutProps || {} }, content));
+    }
+    return content;
+};

package/build/esm/lib/unstable/kit/entities/FewOfNested/index.d.ts

@@ -0,0 +1 @@
+export { FewOfNested, type FewOfNestedProps } from './FewOfNested';

package/build/esm/lib/unstable/kit/entities/FewOfNested/index.js

@@ -0,0 +1 @@
+export { FewOfNested } from './FewOfNested';

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

@@ -0,0 +1,8 @@
+import * as icons from '@gravity-ui/icons';
+import { type IconProps, type LabelProps as UIKitLabelProps } from '@gravity-ui/uikit';
+import { type JsonSchemaString, type NodeEntity } from '../../../core';
+export interface LabelProps extends UIKitLabelProps {
+    iconName?: keyof typeof icons;
+    iconProps?: Partial<IconProps>;
+}
+export declare const Label: NodeEntity<JsonSchemaString, LabelProps>;

package/build/esm/lib/unstable/kit/entities/Label/Label.js

@@ -0,0 +1,26 @@
+import { __rest } from "tslib";
+import React from 'react';
+import * as icons from '@gravity-ui/icons';
+import { Icon, Label as UIKitLabel, } from '@gravity-ui/uikit';
+import { SchemaRendererMode } from '../../../core';
+import { EntityContainer } from '../../components';
+export const Label = ({ input, mode, props, schema }) => {
+    const { value } = input;
+    const { iconName, iconProps, title } = props, restEntityProps = __rest(props, ["iconName", "iconProps", "title"]);
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    const icon = React.useMemo(() => iconName && icons[iconName] ? (React.createElement(Icon, Object.assign({ data: icons[iconName] }, iconProps))) : undefined, [iconName, iconProps]);
+    const content = React.useMemo(() => {
+        if (title) {
+            if (typeof title === 'string') {
+                return React.createElement("span", { dangerouslySetInnerHTML: { __html: title } });
+            }
+            return title;
+        }
+        if (schema.description) {
+            return React.createElement("span", { dangerouslySetInnerHTML: { __html: schema.description } });
+        }
+        return undefined;
+    }, [title, schema.description]);
+    return (React.createElement(EntityContainer, { stretch: "fit", fill: "populated" },
+        React.createElement(UIKitLabel, Object.assign({ size: overviewFlag ? 'xs' : 'm', value: value, icon: icon }, restEntityProps), content)));
+};

package/build/esm/lib/unstable/kit/entities/Label/index.d.ts

@@ -0,0 +1 @@
+export { Label, type LabelProps } from './Label';

package/build/esm/lib/unstable/kit/entities/Label/index.js

@@ -0,0 +1 @@
+export { Label } from './Label';

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

@@ -0,0 +1,6 @@
+.sr-monaco_error .sr-monaco__container {
+  border-color: var(--g-color-text-danger);
+}
+.sr-monaco__dialog-body {
+  padding: calc(var(--g-spacing-base) * 4);
+}

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

@@ -0,0 +1,8 @@
+import type { MonacoEditorProps } from 'react-monaco-editor/lib/types';
+import { type JsonSchemaString, type NodeEntity } from '../../../core';
+import './Monaco.css';
+export interface MonacoProps extends Omit<MonacoEditorProps, 'defaultValue' | 'value' | 'onChange'> {
+    ignoreMonacoErrors?: boolean;
+    withDialog?: boolean;
+}
+export declare const Monaco: NodeEntity<JsonSchemaString, MonacoProps>;

package/build/esm/lib/unstable/kit/entities/Monaco/Monaco.js

@@ -0,0 +1,77 @@
+import { __rest } from "tslib";
+import React from 'react';
+import { Dialog } from '@gravity-ui/uikit';
+import { SchemaRendererEventType, SchemaRendererMode, useSchemaRendererState, useSchemaRendererTools, } from '../../../core';
+import { EmptyEntityValue, EntityContainer, MonacoContainer } from '../../components';
+import { block, getBooleanValidationState } from '../../utils';
+import './Monaco.css';
+const b = block('monaco');
+export const Monaco = ({ headName, input, meta, mode, props, schema, }) => {
+    const { name, onBlur, onChange, onFocus, value } = input;
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    const { language = 'plaintext', options: optionsProps, withDialog = true, ignoreMonacoErrors = false, width = '100%', height = 350 } = props, restEntityProps = __rest(props, ["language", "options", "withDialog", "ignoreMonacoErrors", "width", "height"]);
+    const srState = useSchemaRendererState({
+        headName,
+        subscriptions: [SchemaRendererEventType.UserContext],
+    });
+    const { addExternalErrors, removeExternalErrors } = useSchemaRendererTools();
+    const { MonacoEditor } = (srState === null || srState === void 0 ? void 0 : srState.userContext) || {};
+    const modelUrisRef = React.useRef([]);
+    const innerErrorRef = React.useRef(null);
+    const [dialogOpen, setDialogOpen] = React.useState(false);
+    const toggleDialogOpen = React.useCallback(() => setDialogOpen((f) => !f), []);
+    const options = React.useMemo(() => (Object.assign({ fontSize: 12, readOnly: overviewFlag || schema.readOnly, formatOnPaste: true, formatOnType: true, contextmenu: false, minimap: { enabled: false }, autoClosingBrackets: 'languageDefined', automaticLayout: true }, optionsProps)), [optionsProps, overviewFlag, schema.readOnly]);
+    const onUpdate = React.useCallback((value) => {
+        onFocus();
+        onChange(value);
+        onBlur();
+    }, [onFocus, onChange, onBlur]);
+    const editorDidMount = React.useMemo(() => {
+        if (ignoreMonacoErrors) {
+            return undefined;
+        }
+        return (editor, monaco) => {
+            const model = editor.getModel();
+            if (model) {
+                const modelUri = model.uri.toString();
+                modelUrisRef.current.push(modelUri);
+                model.onWillDispose(() => {
+                    modelUrisRef.current = modelUrisRef.current.filter((u) => u !== modelUri);
+                });
+                monaco.editor.onDidChangeMarkers((uris) => {
+                    const editedUri = uris.find((u) => modelUrisRef.current.includes(u.toString()));
+                    if (!editedUri) {
+                        return;
+                    }
+                    const marker = monaco.editor
+                        .getModelMarkers({ resource: editedUri })
+                        .find((m) => m.severity === monaco.MarkerSeverity.Error);
+                    if (marker) {
+                        const error = `${marker.message}${marker.message[marker.message.length - 1] === '.' ? '' : '.'} ${marker.source}(${marker.code}) [Line ${marker.startLineNumber}, Column ${marker.startColumn}]`;
+                        if (innerErrorRef.current !== error) {
+                            innerErrorRef.current = error;
+                            addExternalErrors === null || addExternalErrors === void 0 ? void 0 : addExternalErrors({ headName, regularErrors: { [name]: error } });
+                        }
+                    }
+                    else if (innerErrorRef.current) {
+                        innerErrorRef.current = null;
+                        removeExternalErrors === null || removeExternalErrors === void 0 ? void 0 : removeExternalErrors({ headName, removeFunctionOrNames: [name] });
+                    }
+                });
+            }
+            return;
+        };
+    }, [addExternalErrors, headName, name, ignoreMonacoErrors, removeExternalErrors]);
+    if (!MonacoEditor) {
+        return null;
+    }
+    if (overviewFlag && !value) {
+        return React.createElement(EmptyEntityValue, null);
+    }
+    const control = (React.createElement(MonacoEditor, Object.assign({}, restEntityProps, { language: language, value: value, onChange: onUpdate, options: options, editorDidMount: editorDidMount })));
+    return (React.createElement(EntityContainer, { className: b({ error: getBooleanValidationState(meta) }), stretch: "max", fill: "populated" },
+        React.createElement(MonacoContainer, { dialog: false, height: height, language: language, toggleDialogVisibility: toggleDialogOpen, width: width, withDialog: withDialog, qa: name }, control),
+        React.createElement(Dialog, { open: dialogOpen, onClose: toggleDialogOpen, hasCloseButton: false },
+            React.createElement(Dialog.Body, { className: b('dialog-body') },
+                React.createElement(MonacoContainer, { dialog: true, height: "90vh", language: language, toggleDialogVisibility: toggleDialogOpen, width: "80vw", withDialog: withDialog, qa: name }, control)))));
+};

package/build/esm/lib/unstable/kit/entities/Monaco/index.d.ts

@@ -0,0 +1 @@
+export { Monaco, type MonacoProps } from './Monaco';

package/build/esm/lib/unstable/kit/entities/Monaco/index.js

@@ -0,0 +1 @@
+export { Monaco } from './Monaco';

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

@@ -0,0 +1,6 @@
+import { type JsonSchemaObject, type NodeEntity } from '../../../core';
+export interface ObjectEntityProps {
+    disabled?: boolean;
+    order?: string[];
+}
+export declare const ObjectEntity: NodeEntity<JsonSchemaObject, ObjectEntityProps>;

package/build/esm/lib/unstable/kit/entities/ObjectEntity/ObjectEntity.js

@@ -0,0 +1,11 @@
+import React from 'react';
+import { SchemaRendererMode, SchemaRendererNode, } from '../../../core';
+import { EmptyEntityValue, EntityContainer } from '../../components';
+export const ObjectEntity = ({ headName, mode, input, props, schema, schemaPath, }) => {
+    const { name } = input;
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    if (overviewFlag && !Object.keys(schema.properties || {}).length) {
+        return React.createElement(EmptyEntityValue, null);
+    }
+    return (React.createElement(EntityContainer, { stretch: "by-child", fill: "by-child" }, (props.order || Object.keys(schema.properties || {})).map((property) => (React.createElement(SchemaRendererNode, { headName: headName, name: `${name ? name + '.' : ''}${property}`, schemaPath: `${schemaPath}/properties/${property}`, key: property })))));
+};

package/build/esm/lib/unstable/kit/entities/ObjectEntity/index.d.ts

@@ -0,0 +1 @@
+export { ObjectEntity, type ObjectEntityProps } from './ObjectEntity';

package/build/esm/lib/unstable/kit/entities/ObjectEntity/index.js

@@ -0,0 +1 @@
+export { ObjectEntity } from './ObjectEntity';

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

@@ -0,0 +1,11 @@
+.sr-object-inline .sr-object-inline__items > * {
+  margin-bottom: 0;
+}
+.sr-object-inline__items_overview .sr-object-inline__delimiter {
+  min-height: 18px;
+}
+.sr-object-inline__delimiter {
+  min-height: 28px;
+  display: flex;
+  align-items: center;
+}

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

@@ -0,0 +1,8 @@
+import { type JsonSchemaObject, type NodeEntity } from '../../../core';
+import './ObjectInline.css';
+export interface ObjectInlineProps {
+    delimiter?: string | Record<string, string>;
+    disabled?: boolean;
+    order?: string[];
+}
+export declare const ObjectInline: NodeEntity<JsonSchemaObject, ObjectInlineProps>;

package/build/esm/lib/unstable/kit/entities/ObjectInline/ObjectInline.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { Flex, Text } from '@gravity-ui/uikit';
+import isObject from 'lodash/isObject';
+import isString from 'lodash/isString';
+import { SchemaRendererMode, SchemaRendererNode, } from '../../../core';
+import { EmptyEntityValue, EntityContainer } from '../../components';
+import { block } from '../../utils';
+import './ObjectInline.css';
+const b = block('object-inline');
+export const ObjectInline = ({ headName, input, mode, props, schema, schemaPath, }) => {
+    const { delimiter, order } = props;
+    const { name } = input;
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    if (overviewFlag && !Object.keys(input.value || {}).length) {
+        return React.createElement(EmptyEntityValue, null);
+    }
+    return (React.createElement(EntityContainer, { stretch: overviewFlag ? 'by-child' : 'max', className: b(), fill: "by-child" },
+        React.createElement(Flex, { className: b('items', { overview: overviewFlag }), direction: "row", alignItems: "flex-start", gap: overviewFlag ? 1 : 2 }, (order || Object.keys(schema.properties || {})).map((property, index, array) => (React.createElement(React.Fragment, { key: property },
+            React.createElement(SchemaRendererNode, { headName: headName, name: `${name ? name + '.' : ''}${property}`, schemaPath: `${schemaPath}/properties/${property}` }),
+            isString(delimiter) && index + 1 !== array.length ? (React.createElement(Text, { className: b('delimiter') }, delimiter)) : null,
+            isObject(delimiter) && delimiter[property] ? (React.createElement(Text, { className: b('delimiter') }, delimiter[property])) : null))))));
+};

package/build/esm/lib/unstable/kit/entities/ObjectInline/index.d.ts

@@ -0,0 +1 @@
+export { ObjectInline, type ObjectInlineProps } from './ObjectInline';

package/build/esm/lib/unstable/kit/entities/ObjectInline/index.js

@@ -0,0 +1 @@
+export { ObjectInline } from './ObjectInline';

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

@@ -0,0 +1,17 @@
+.sr-one-of-nested__content {
+  margin-top: calc(var(--g-spacing-base) * 4);
+}
+.sr-one-of-nested__content_with-indent {
+  position: relative;
+  padding-left: calc(var(--g-spacing-base) * 7);
+}
+.sr-one-of-nested__content_with-indent:before {
+  content: "";
+  display: block;
+  width: 1px;
+  height: calc(100% + var(--g-spacing-base) * 2);
+  background-color: var(--g-color-line-generic);
+  position: absolute;
+  left: calc(var(--g-spacing-base) * 3 + 1.5px);
+  bottom: 0;
+}

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

@@ -0,0 +1,12 @@
+import { type JsonSchema, type JsonSchemaObject, type NodeEntity } from '../../../core';
+import './OneOfNested.css';
+export interface OneOfNestedProps {
+    toggler: JsonSchema;
+    booleanToKey?: {
+        true: string;
+        false: string;
+    };
+    withIndent?: boolean;
+    togglerArrayRemoveButton?: boolean;
+}
+export declare const OneOfNested: NodeEntity<JsonSchemaObject, OneOfNestedProps>;

package/build/esm/lib/unstable/kit/entities/OneOfNested/OneOfNested.js

@@ -0,0 +1,66 @@
+import React from 'react';
+import { NodeType, SchemaRendererEventType, SchemaRendererMode, SchemaRendererNode, getRenderKit, useSchemaRendererState, } from '../../../core';
+import { EntityContainer, LayoutContainer } from '../../components';
+import { block } from '../../utils';
+import './OneOfNested.css';
+const b = block('one-of-nested');
+export const OneOfNested = ({ Layout, headName, input, layoutProps, meta, mode, props, schema, schemaPath, }) => {
+    const { name, value } = input;
+    const { booleanToKey, togglerArrayRemoveButton = false, toggler: togglerSchema = {}, withIndent = false, } = props;
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    const srState = useSchemaRendererState({
+        headName,
+        subscriptions: [SchemaRendererEventType.Config],
+    });
+    const [togglerValue, setTogglerValue] = React.useState(Object.keys(value || (overviewFlag ? undefined : schema.properties) || {})[0]);
+    const toggler = React.useMemo(() => {
+        var _a;
+        let result = null;
+        const renderKit = getRenderKit({ config: srState === null || srState === void 0 ? void 0 : srState.config, schema: togglerSchema });
+        const { Entity, Layout, entityProps, independent, layoutProps } = renderKit[mode];
+        const togglerInput = Object.assign(Object.assign({}, input), { name: togglerArrayRemoveButton ? name : `${name}._____toggler`, value: ((_a = togglerSchema.nodeParameters) === null || _a === void 0 ? void 0 : _a.type) === NodeType.Boolean &&
+                booleanToKey &&
+                togglerValue !== undefined
+                ? booleanToKey.true === togglerValue
+                : togglerValue, onChange: (value) => {
+                const nextValue = `${value}`;
+                setTogglerValue((booleanToKey === null || booleanToKey === void 0 ? void 0 : booleanToKey[nextValue]) || nextValue);
+            } });
+        const togglerMeta = Object.assign(Object.assign({}, meta), { error: undefined });
+        if (Entity) {
+            result = (React.createElement(Entity, { Layout: independent ? Layout : undefined, headName: headName, input: togglerInput, layoutProps: independent ? layoutProps : undefined, meta: togglerMeta, mode: mode, props: entityProps, schema: togglerSchema, schemaPath: "___stub" }));
+            if (Layout && !independent) {
+                result = (React.createElement(Layout, { headName: headName, input: togglerInput, meta: togglerMeta, mode: mode, props: layoutProps, schema: togglerSchema, schemaPath: "___stub" }, result));
+            }
+        }
+        return result;
+    }, [
+        booleanToKey,
+        headName,
+        input,
+        meta,
+        mode,
+        name,
+        srState === null || srState === void 0 ? void 0 : srState.config,
+        togglerArrayRemoveButton,
+        togglerSchema,
+        togglerValue,
+    ]);
+    const wrapperInput = React.useMemo(() => {
+        if (!togglerArrayRemoveButton) {
+            return input;
+        }
+        return Object.assign(Object.assign({}, input), { name: `${name}._____wrapper` });
+    }, [name, input, togglerArrayRemoveButton]);
+    let content = (React.createElement(EntityContainer, { direction: "column-reverse", stretch: "by-child", fill: "populated" },
+        togglerValue === undefined ? null : (React.createElement(LayoutContainer, { className: b('content', { 'with-indent': withIndent }), hideEmpty: overviewFlag },
+            React.createElement(SchemaRendererNode, { headName: headName, name: `${name ? name + '.' : ''}${togglerValue}`, schemaPath: `${schemaPath}/properties/${togglerValue}` }))),
+        toggler));
+    if (overviewFlag && Object.values(value || {}).length === 0) {
+        content = React.createElement(React.Fragment, null, toggler);
+    }
+    if (Layout) {
+        content = (React.createElement(Layout, { headName: headName, input: wrapperInput, meta: meta, mode: mode, schema: schema, schemaPath: schemaPath, props: layoutProps || {} }, content));
+    }
+    return content;
+};

package/build/esm/lib/unstable/kit/entities/OneOfNested/index.d.ts

@@ -0,0 +1 @@
+export { OneOfNested, type OneOfNestedProps } from './OneOfNested';

package/build/esm/lib/unstable/kit/entities/OneOfNested/index.js

@@ -0,0 +1 @@
+export { OneOfNested } from './OneOfNested';

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

@@ -0,0 +1,19 @@
+.sr-text-content {
+  border: none;
+  box-shadow: none;
+}
+.sr-text-content.g-label .g-label__addon_side_start {
+  position: unset;
+}
+.sr-text-content.g-label .g-label__text {
+  margin-left: calc(var(--g-spacing-base) * 1);
+}
+.sr-text-content.g-label:not(:has(.g-label__addon_side_start)) .g-label__text {
+  margin-left: 0;
+}
+.sr-text-content.g-label .g-label__separator {
+  margin-left: 0;
+}
+.sr-text-content.g-label .g-label__addon {
+  width: auto;
+}

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

@@ -0,0 +1,9 @@
+import * as icons from '@gravity-ui/icons';
+import { type IconProps, type LabelProps as UIKitLabelProps } from '@gravity-ui/uikit';
+import { type JsonSchemaString, type NodeEntity } from '../../../core';
+import './TextContent.css';
+export interface TextContentProps extends Omit<UIKitLabelProps, 'theme'> {
+    iconName?: keyof typeof icons;
+    iconProps?: Partial<IconProps>;
+}
+export declare const TextContent: NodeEntity<JsonSchemaString, TextContentProps>;

package/build/esm/lib/unstable/kit/entities/TextContent/TextContent.js

@@ -0,0 +1,28 @@
+import { __rest } from "tslib";
+import React from 'react';
+import * as icons from '@gravity-ui/icons';
+import { Icon, Label as UIKitLabel, } from '@gravity-ui/uikit';
+import { SchemaRendererMode } from '../../../core';
+import { EntityContainer } from '../../components';
+import { block } from '../../utils';
+import './TextContent.css';
+const b = block('text-content');
+export const TextContent = ({ input, mode, props, schema, }) => {
+    const { className, iconName, iconProps, title: titleProp } = props, restEntityProps = __rest(props, ["className", "iconName", "iconProps", "title"]);
+    const overviewFlag = mode === SchemaRendererMode.Overview;
+    const icon = React.useMemo(() => iconName && icons[iconName] ? (React.createElement(Icon, Object.assign({ data: icons[iconName] }, iconProps))) : undefined, [iconName, iconProps]);
+    const content = React.useMemo(() => {
+        if (titleProp) {
+            if (typeof titleProp === 'string') {
+                return React.createElement("span", { dangerouslySetInnerHTML: { __html: titleProp } });
+            }
+            return titleProp;
+        }
+        if (schema.description) {
+            return React.createElement("span", { dangerouslySetInnerHTML: { __html: schema.description } });
+        }
+        return undefined;
+    }, [titleProp, schema.description]);
+    return (React.createElement(EntityContainer, { stretch: "fit", fill: "populated" },
+        React.createElement(UIKitLabel, Object.assign({ size: overviewFlag ? 'xs' : 'm', value: input.value, icon: icon, className: b(null, className) }, restEntityProps, { theme: "clear" }), content)));
+};

package/build/esm/lib/unstable/kit/entities/TextContent/index.d.ts

@@ -0,0 +1 @@
+export { TextContent, type TextContentProps } from './TextContent';

package/build/esm/lib/unstable/kit/entities/TextContent/index.js

@@ -0,0 +1 @@
+export { TextContent } from './TextContent';

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

@@ -0,0 +1,11 @@
+export { Alert, type AlertProps } from './Alert';
+export { ArrayEntity, type ArrayEntityProps } from './ArrayEntity';
+export { ArrayTable, type ArrayTableProps } from './ArrayTable';
+export { DotValue, type DotValueProps } from './DotValue';
+export { FewOfNested, type FewOfNestedProps } from './FewOfNested';
+export { Label, type LabelProps } from './Label';
+export { Monaco, type MonacoProps } from './Monaco';
+export { ObjectEntity, type ObjectEntityProps } from './ObjectEntity';
+export { ObjectInline, type ObjectInlineProps } from './ObjectInline';
+export { OneOfNested, type OneOfNestedProps } from './OneOfNested';
+export { TextContent, type TextContentProps } from './TextContent';

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

@@ -0,0 +1,11 @@
+export { Alert } from './Alert';
+export { ArrayEntity } from './ArrayEntity';
+export { ArrayTable } from './ArrayTable';
+export { DotValue } from './DotValue';
+export { FewOfNested } from './FewOfNested';
+export { Label } from './Label';
+export { Monaco } from './Monaco';
+export { ObjectEntity } from './ObjectEntity';
+export { ObjectInline } from './ObjectInline';
+export { OneOfNested } from './OneOfNested';
+export { TextContent } from './TextContent';

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

@@ -0,0 +1,9 @@
+.sr-checkbox-group-input__checkbox {
+  min-height: 28px;
+}
+.sr-checkbox-group-input__checkbox_error .g-control-label .g-checkbox__indicator:hover::before {
+  border: 1px solid var(--g-color-text-danger);
+}
+.sr-checkbox-group-input__checkbox_error .g-control-label .g-checkbox__indicator::before {
+  border: 1px solid var(--g-color-text-danger);
+}

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

@@ -0,0 +1,9 @@
+import type { JsonSchemaArray, NodeEntity } from '../../../core';
+import './CheckboxGroupInput.css';
+export interface CheckboxGroupInputProps {
+    enumDescriptions?: Record<string, string>;
+    optionsDisabled?: Record<string, boolean>;
+    direction?: 'row' | 'column';
+    disabled?: boolean;
+}
+export declare const CheckboxGroupInput: NodeEntity<JsonSchemaArray, CheckboxGroupInputProps>;

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

@@ -0,0 +1,38 @@
+import React from 'react';
+import { Checkbox, Flex } from '@gravity-ui/uikit';
+import { EntityContainer } from '../../components';
+import { block, getBooleanValidationState } from '../../utils';
+import './CheckboxGroupInput.css';
+const b = block('checkbox-group-input');
+export const CheckboxGroupInput = ({ input, props, meta, schema, }) => {
+    const { name, onBlur, onChange, onFocus, value: inputValue } = input;
+    const { enumDescriptions, direction = 'row', disabled, optionsDisabled } = props;
+    const value = React.useMemo(() => (Array.isArray(inputValue) ? inputValue : []), [inputValue]);
+    const options = React.useMemo(() => {
+        var _a, _b;
+        if (schema.items && 'enum' in schema.items) {
+            return (_b = (_a = schema === null || schema === void 0 ? void 0 : schema.items) === null || _a === void 0 ? void 0 : _a.enum) === null || _b === void 0 ? void 0 : _b.map((el) => {
+                const value = `${el}`;
+                return {
+                    value,
+                    text: (enumDescriptions === null || enumDescriptions === void 0 ? void 0 : enumDescriptions[value]) || value,
+                };
+            });
+        }
+        return;
+    }, [enumDescriptions, schema]);
+    const onUpdate = React.useCallback((optionValue, selected) => {
+        onFocus();
+        if (selected) {
+            onChange([...value, optionValue]);
+        }
+        else {
+            onChange(value.filter((el) => el !== optionValue));
+        }
+        onBlur();
+    }, [onBlur, onChange, onFocus, value]);
+    return (React.createElement(EntityContainer, { stretch: "fit", direction: direction, gap: direction === 'row' ? 2 : undefined }, options === null || options === void 0 ? void 0 : options.map(({ value: optionValue, text }) => (React.createElement(Flex, { className: b('checkbox', {
+            error: value.includes(optionValue) && getBooleanValidationState(meta),
+        }), alignItems: "center", key: optionValue },
+        React.createElement(Checkbox, { checked: value.includes(optionValue), onFocus: onFocus, onBlur: onBlur, onUpdate: (checked) => onUpdate(optionValue, checked), content: text, disabled: disabled || (optionsDisabled === null || optionsDisabled === void 0 ? void 0 : optionsDisabled[optionValue]) || schema.readOnly, qa: `${name}-${optionValue}` }))))));
+};

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

@@ -0,0 +1 @@
+export { CheckboxGroupInput, type CheckboxGroupInputProps } from './CheckboxGroupInput';

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

@@ -0,0 +1 @@
+export { CheckboxGroupInput } from './CheckboxGroupInput';

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

@@ -0,0 +1,11 @@
+.sr-checkbox-input {
+  min-height: 28px;
+  display: flex;
+  justify-content: center;
+}
+.sr-checkbox-input_error .g-control-label .g-checkbox__indicator:hover::before {
+  border: 1px solid var(--g-color-text-danger);
+}
+.sr-checkbox-input_error .g-control-label .g-checkbox__indicator::before {
+  border: 1px solid var(--g-color-text-danger);
+}

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

@@ -0,0 +1,6 @@
+import { type CheckboxProps } from '@gravity-ui/uikit';
+import type { JsonSchemaBoolean, NodeEntity } from '../../../core';
+import './CheckboxInput.css';
+export interface CheckboxInputProps extends Omit<CheckboxProps, 'checked' | 'onFocus' | 'onBlur' | 'onChange' | 'onUpdate' | 'qa'> {
+}
+export declare const CheckboxInput: NodeEntity<JsonSchemaBoolean, CheckboxInputProps>;

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

@@ -0,0 +1,16 @@
+import React from 'react';
+import { Checkbox } from '@gravity-ui/uikit';
+import { EntityContainer } from '../../components';
+import { block, getBooleanValidationState } from '../../utils';
+import './CheckboxInput.css';
+const b = block('checkbox-input');
+export const CheckboxInput = ({ input, props, meta, schema, }) => {
+    const { name, onBlur, onChange, onFocus, value } = input;
+    const onUpdate = React.useCallback((value) => {
+        onFocus();
+        onChange(value);
+        onBlur();
+    }, [onBlur, onChange, onFocus]);
+    return (React.createElement(EntityContainer, { stretch: "fit", className: b({ error: getBooleanValidationState(meta) }) },
+        React.createElement(Checkbox, Object.assign({ disabled: schema.readOnly }, props, { checked: value !== null && value !== void 0 ? value : false, onFocus: onFocus, onBlur: onBlur, onUpdate: onUpdate, qa: name }))));
+};

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

@@ -0,0 +1 @@
+export { CheckboxInput, type CheckboxInputProps } from './CheckboxInput';

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

@@ -0,0 +1 @@
+export { CheckboxInput } from './CheckboxInput';

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

@@ -0,0 +1,6 @@
+.sr-color-picker-input .g-color-picker__picker-wrapper {
+  width: 100%;
+}
+.sr-color-picker-input_error .g-color-picker__picker-wrapper .g-text-input__content {
+  border: 1px solid var(--g-color-text-danger);
+}