@gravity-ui/dynamic-forms 5.18.0 → 5.19.0

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchemaRenderer = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const cloneDeep_1 = tslib_1.__importDefault(require("lodash/cloneDeep"));
+const noop_1 = tslib_1.__importDefault(require("lodash/noop"));
+const react_final_form_1 = require("react-final-form");
+const constants_1 = require("../constants");
+const constants_2 = require("./constants");
+const hooks_1 = require("./hooks");
+const utils_1 = require("./utils");
+const useSchemaRenderer = ({ config, connectValidate = true, errorMessages = constants_1.EMPTY_OBJECT, mode, name, schema: originalSchema, }) => {
+    const form = (0, react_final_form_1.useForm)();
+    const { setAsyncValidationCache, setAsyncValidationWaiters, triggerFields } = (0, hooks_1.useSchemaRendererMutators)();
+    const errorsRef = react_1.default.useRef({});
+    const schemaRef = react_1.default.useRef(undefined);
+    const [schema, setSchema] = react_1.default.useState(undefined);
+    const [fieldsToTrigger, setFieldsToTrigger] = react_1.default.useState([]);
+    const setErrors = react_1.default.useCallback((errors) => {
+        const formState = form.getState();
+        const fieldsToTrigger = Object.keys(Object.assign(Object.assign({}, errorsRef.current), errors)).filter((key) => {
+            if (errorsRef.current[key] !== errors[key]) {
+                const field = form.getFieldState(key);
+                if ((field === null || field === void 0 ? void 0 : field.touched) || formState.submitFailed) {
+                    return true;
+                }
+            }
+            return false;
+        });
+        errorsRef.current = errors;
+        if (fieldsToTrigger.length) {
+            setFieldsToTrigger(fieldsToTrigger);
+        }
+    }, [form]);
+    const validate = react_1.default.useMemo(() => (0, utils_1.getValidate)({
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    }), [
+        config,
+        errorMessages,
+        name,
+        setAsyncValidationCache,
+        setAsyncValidationWaiters,
+        setErrors,
+    ]);
+    const returnValue = react_1.default.useMemo(() => {
+        if (connectValidate) {
+            return { schema };
+        }
+        return {
+            schema,
+            validate: (value) => {
+                const allValues = form.getState().values;
+                const meta = form.getFieldState(name);
+                return validate(value, allValues, meta);
+            },
+        };
+    }, [connectValidate, form, name, schema, validate]);
+    react_1.default.useEffect(() => {
+        schemaRef.current = (0, cloneDeep_1.default)(originalSchema);
+        setSchema(schemaRef.current);
+    }, [originalSchema]);
+    react_1.default.useEffect(() => {
+        const data = { originalSchema, schema: schemaRef.current };
+        const getValidator = connectValidate ? () => validate : undefined;
+        const unsubscribe = form.registerField(name, noop_1.default, constants_1.EMPTY_OBJECT, { data, getValidator });
+        return () => unsubscribe();
+    }, [connectValidate, form, name, originalSchema, validate]);
+    react_1.default.useEffect(() => {
+        const data = { config, errorsRef, headName: name, mode, schema: schemaRef.current };
+        const unsubscribe = form.registerField(`${constants_2.ENTITY_SERVICE_FIELD}.${name}`, noop_1.default, constants_1.EMPTY_OBJECT, { data });
+        return () => unsubscribe();
+    }, [config, form, mode, name]);
+    react_1.default.useEffect(() => {
+        if (fieldsToTrigger.length) {
+            triggerFields === null || triggerFields === void 0 ? void 0 : triggerFields({ fields: fieldsToTrigger });
+        }
+    }, [fieldsToTrigger, triggerFields]);
+    return returnValue;
+};
+exports.useSchemaRenderer = useSchemaRenderer;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/common.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.guessHeadName = void 0;
+const constants_1 = require("../constants");
+const guessHeadName = (registeredFields, name) => {
+    const registeredServiceFields = registeredFields
+        .filter((n) => n.startsWith(constants_1.ENTITY_SERVICE_FIELD))
+        .map((n) => n.slice(`${constants_1.ENTITY_SERVICE_FIELD}.`.length));
+    return registeredServiceFields.find((n) => name === n || name.startsWith(`${n}.`) || name.startsWith(`${n}[`));
+};
+exports.guessHeadName = guessHeadName;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAjvValidate = void 0;
+const tslib_1 = require("tslib");
+const ajv_1 = tslib_1.__importDefault(require("ajv"));
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const getAjvValidate = ({ config, schema }) => {
+    function entityParametersValidate(_, value, schema) {
+        if (schema && schema.entityParameters) {
+            const entityType = (0, get_1.default)(schema, 'entityParameters.type');
+            const validatorType = schema.entityParameters.validatorType;
+            const validator = (0, get_1.default)(config, `${entityType}.validators.${validatorType}`);
+            if (validator) {
+                const error = {
+                    keyword: 'entityParameters',
+                    message: '',
+                    params: { validator, value, schema },
+                };
+                entityParametersValidate.errors = [error];
+                return false;
+            }
+        }
+        return true;
+    }
+    const ajv = new ajv_1.default({
+        allErrors: true,
+        allowMatchingProperties: true,
+        keywords: [
+            {
+                errors: true,
+                keyword: 'entityParameters',
+                validate: entityParametersValidate,
+            },
+        ],
+    });
+    const ajvValidate = ajv.compile(schema);
+    return ajvValidate;
+};
+exports.getAjvValidate = getAjvValidate;

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

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidate = void 0;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isBoolean_1 = tslib_1.__importDefault(require("lodash/isBoolean"));
+const isObjectLike_1 = tslib_1.__importDefault(require("lodash/isObjectLike"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const utils_1 = require("../../utils");
+const get_ajv_validate_1 = require("./get-ajv-validate");
+const process_ajv_validate_errors_1 = require("./process-ajv-validate-errors");
+const process_errors_state_1 = require("./process-errors-state");
+const getValidate = ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }) => {
+    let schema;
+    let ajvValidate;
+    return (value, allValues, meta) => {
+        const data = meta === null || meta === void 0 ? void 0 : meta.data;
+        if (!(data === null || data === void 0 ? void 0 : data.schema)) {
+            return false;
+        }
+        if (schema !== data.schema) {
+            schema = data.schema;
+            ajvValidate = (0, get_ajv_validate_1.getAjvValidate)({ config, schema });
+        }
+        ajvValidate(value);
+        const { ajvErrorItems, entityParametersErrorItems, waiters } = (0, process_ajv_validate_errors_1.processAjvValidateErrors)({
+            ajvValidateErrors: ajvValidate.errors || [],
+            allValues: allValues,
+            errorMessages,
+            name,
+            schema,
+            setAsyncValidationCache,
+            validationState: data,
+        });
+        const { externalPriorityErrorItems, externalRegularErrorItems } = (0, process_errors_state_1.processErrorsState)({
+            errorsState: data,
+            name,
+        });
+        if (Object.keys(waiters).length) {
+            setAsyncValidationWaiters === null || setAsyncValidationWaiters === void 0 ? void 0 : setAsyncValidationWaiters({ headName: name, waiters });
+        }
+        const result = { errors: {} };
+        [
+            ...externalRegularErrorItems,
+            ...ajvErrorItems,
+            ...entityParametersErrorItems,
+            ...externalPriorityErrorItems,
+        ].forEach((item) => {
+            if (!item.error) {
+                return;
+            }
+            if ((0, isObjectLike_1.default)(item.error)) {
+                (0, utils_1.getValuePaths)(item.error).forEach((childPath) => {
+                    result.errors[(0, utils_1.formatFinalFormPath)([name, ...item.path, ...childPath])] = (0, get_1.default)(item.error, childPath);
+                });
+                return;
+            }
+            if ((0, isBoolean_1.default)(item.error) || (0, isString_1.default)(item.error)) {
+                result.errors[(0, utils_1.formatFinalFormPath)([name, ...item.path])] = item.error;
+                return;
+            }
+        });
+        setErrors(result.errors);
+        return Object.keys(result.errors).length ? 'error' : false;
+    };
+};
+exports.getValidate = getValidate;

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidate = exports.guessHeadName = void 0;
+var common_1 = require("./common");
+Object.defineProperty(exports, "guessHeadName", { enumerable: true, get: function () { return common_1.guessHeadName; } });
+var get_validate_1 = require("./get-validate");
+Object.defineProperty(exports, "getValidate", { enumerable: true, get: function () { return get_validate_1.getValidate; } });

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAjvError = void 0;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const utils_1 = require("../../utils");
+const processAjvError = ({ error, errorMessages, schema, onError, }) => {
+    let instancePath = error.instancePath;
+    let keyword = error.keyword;
+    let schemaPath = error.schemaPath;
+    if (keyword === 'anyOf' ||
+        (keyword === 'if' &&
+            (error.params.failingKeyword === 'then' || error.params.failingKeyword === 'else')) ||
+        keyword === 'false schema') {
+        return;
+    }
+    if (error.propertyName) {
+        instancePath += `/${error.propertyName}`;
+    }
+    if (keyword === 'required') {
+        instancePath += `/${error.params.missingProperty}`;
+    }
+    else if (keyword === 'dependencies') {
+        instancePath += `/${error.params.missingProperty}`;
+        schemaPath =
+            schemaPath.slice(0, -'dependencies'.length) +
+                `properties/${error.params.missingProperty}/dependencies`;
+    }
+    else if (keyword === 'if') {
+        keyword = error.params.failingKeyword;
+        schemaPath = schemaPath.slice(0, -'if'.length) + error.params.failingKeyword;
+    }
+    const getErrorMessageBySchema = (schema) => {
+        const propertyName = instancePath.split('/').pop();
+        const errorOrMap = (0, get_1.default)(schema, `entityParameters.errorMessages.${keyword}`);
+        const message = (0, isString_1.default)(errorOrMap)
+            ? errorOrMap
+            : (0, get_1.default)(errorOrMap, propertyName);
+        return message;
+    };
+    onError({
+        path: (0, utils_1.parseInstancePath)(instancePath),
+        error: getErrorMessageBySchema((0, utils_1.getSchemaBySchemaPath)(schemaPath, schema)) ||
+            getErrorMessageBySchema((0, utils_1.getSchemaBySchemaPath)(schemaPath.slice(0, -`/${keyword}`.length), schema)) ||
+            getErrorMessageBySchema((0, utils_1.getSchemaByInstancePath)(instancePath, schema)) ||
+            errorMessages[keyword] ||
+            error.message,
+    });
+};
+exports.processAjvError = processAjvError;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processAjvValidateErrors = void 0;
+const process_ajv_error_1 = require("./process-ajv-error");
+const process_entity_parameters_error_1 = require("./process-entity-parameters-error");
+const processAjvValidateErrors = ({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }) => {
+    const waiters = {};
+    const ajvErrorItems = [];
+    const entityParametersErrorItems = [];
+    ajvValidateErrors.forEach((ajvOrEntityParametersError) => {
+        if (ajvOrEntityParametersError.keyword === 'entityParameters') {
+            const error = ajvOrEntityParametersError;
+            (0, process_entity_parameters_error_1.processEntityParametersError)({
+                allValues,
+                error,
+                onAsyncError: (w) => {
+                    waiters[w.instancePath] = w.params;
+                    w.promise.then((result) => {
+                        setAsyncValidationCache === null || setAsyncValidationCache === void 0 ? void 0 : setAsyncValidationCache({
+                            headName: name,
+                            cache: {
+                                [w.instancePath]: Object.assign(Object.assign({}, w.params), { result }),
+                            },
+                        });
+                    });
+                },
+                onError: (e) => entityParametersErrorItems.push(e),
+                validationState,
+            });
+        }
+        else {
+            const error = ajvOrEntityParametersError;
+            (0, process_ajv_error_1.processAjvError)({
+                error,
+                errorMessages,
+                schema,
+                onError: (e) => ajvErrorItems.push(e),
+            });
+        }
+    });
+    return { ajvErrorItems, entityParametersErrorItems, waiters };
+};
+exports.processAjvValidateErrors = processAjvValidateErrors;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processEntityParametersError = void 0;
+const tslib_1 = require("tslib");
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const utils_1 = require("../../utils");
+const processEntityParametersError = ({ allValues, error, onAsyncError, onError, validationState, }) => {
+    var _a, _b;
+    const waiter = (_a = validationState === null || validationState === void 0 ? void 0 : validationState.waiters) === null || _a === void 0 ? void 0 : _a[error.instancePath];
+    const cache = (_b = validationState === null || validationState === void 0 ? void 0 : validationState.cache) === null || _b === void 0 ? void 0 : _b[error.instancePath];
+    const cacheItem = cache === null || cache === void 0 ? void 0 : cache.find((item) => (0, isEqual_1.default)(error.params, (0, omit_1.default)(item, 'result')));
+    if (cacheItem === null || cacheItem === void 0 ? void 0 : cacheItem.result) {
+        onError({
+            error: cacheItem.result,
+            path: (0, utils_1.parseInstancePath)(error.instancePath),
+        });
+    }
+    else if (!waiter || !(0, isEqual_1.default)(error.params, waiter)) {
+        const errorOrPromise = error.params.validator(error.params.value, allValues);
+        if (errorOrPromise instanceof Promise) {
+            onAsyncError({
+                instancePath: error.instancePath,
+                params: error.params,
+                promise: errorOrPromise,
+            });
+        }
+        else {
+            onError({
+                error: errorOrPromise,
+                path: (0, utils_1.parseInstancePath)(error.instancePath),
+            });
+        }
+    }
+};
+exports.processEntityParametersError = processEntityParametersError;

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processErrorsState = void 0;
+const tslib_1 = require("tslib");
+const mapValues_1 = tslib_1.__importDefault(require("lodash/mapValues"));
+const utils_1 = require("../../utils");
+const processErrorsState = ({ errorsState, name, }) => {
+    const getErrorItems = (errors) => Object.values((0, mapValues_1.default)(errors, (value, key) => ({
+        path: (0, utils_1.parseFinalFormName)(key).slice((0, utils_1.parseFinalFormName)(name).length),
+        error: value,
+    })));
+    return {
+        externalPriorityErrorItems: getErrorItems(errorsState === null || errorsState === void 0 ? void 0 : errorsState.priorityErrors),
+        externalRegularErrorItems: getErrorItems(errorsState === null || errorsState === void 0 ? void 0 : errorsState.regularErrors),
+    };
+};
+exports.processErrorsState = processErrorsState;

package/build/cjs/lib/unstable/core/utils/common.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.smartMerge = exports.smartSet = exports.getValuePaths = exports.getSchemaByFinalFormPath = exports.getSchemaByInstancePath = exports.getSchemaBySchemaPath = exports.getSchemaPath = exports.formatFinalFormPath = exports.parseFinalFormName = exports.parseInstancePath = exports.parseSchemaPath = void 0;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const set_1 = tslib_1.__importDefault(require("lodash/set"));
+/**
+ * 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']`.
+ */
+const parseSchemaPath = (schemaPath) => {
+    return decodeURIComponent(schemaPath)
+        .split('/')
+        .slice(1)
+        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+};
+exports.parseSchemaPath = parseSchemaPath;
+const parseInstancePath = (instancePath) => {
+    if (!instancePath.length) {
+        return [];
+    }
+    return instancePath
+        .slice('/'.length)
+        .split('/')
+        .map((segment) => segment.replace(/~1/g, '/').replace(/~0/g, '~'));
+};
+exports.parseInstancePath = parseInstancePath;
+const parseFinalFormName = (finalFormName) => {
+    const result = [];
+    const regex = /([^[.\]]+)|\[(\d+)\]/g;
+    let match;
+    while ((match = regex.exec(finalFormName)) !== null) {
+        if (match[1] !== undefined) {
+            result.push(match[1]);
+        }
+        else if (match[2] !== undefined) {
+            result.push(match[2]);
+        }
+    }
+    return result;
+};
+exports.parseFinalFormName = parseFinalFormName;
+const formatFinalFormPath = (finalFormPath) => {
+    return finalFormPath.reduce((result, segment) => {
+        if (/^\d+$/.test(segment)) {
+            return `${result}[${segment}]`;
+        }
+        return result ? `${result}.${segment}` : segment;
+    }, '');
+};
+exports.formatFinalFormPath = formatFinalFormPath;
+const getSchemaPath = (finalFormNameOrPath, finalFormHeadName, schema) => {
+    const finalFormPath = Array.isArray(finalFormNameOrPath)
+        ? finalFormNameOrPath
+        : (0, exports.parseFinalFormName)(finalFormNameOrPath);
+    const schemaPath = finalFormPath
+        .slice((0, exports.parseFinalFormName)(finalFormHeadName).length)
+        .reduce((path, segment, index) => {
+        if (path === undefined) {
+            return path;
+        }
+        const schemaByPath = index === 0 ? schema : (0, get_1.default)(schema, path);
+        if ((0, get_1.default)(schemaByPath, ['properties', segment])) {
+            return [...path, 'properties', segment];
+        }
+        const items = (0, get_1.default)(schemaByPath, 'items');
+        if (items) {
+            if (Array.isArray(items)) {
+                return [...path, 'items', segment];
+            }
+            return [...path, 'items'];
+        }
+        return undefined;
+    }, []);
+    return schemaPath;
+};
+exports.getSchemaPath = getSchemaPath;
+/**
+ * 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.
+ */
+const getSchemaBySchemaPath = (schemaPath, schema) => {
+    const pathArr = (0, exports.parseSchemaPath)(schemaPath);
+    if (!pathArr.length) {
+        return schema;
+    }
+    return (0, get_1.default)(schema, pathArr);
+};
+exports.getSchemaBySchemaPath = getSchemaBySchemaPath;
+const getSchemaByInstancePath = (instancePath, schema) => {
+    const schemaPath = (0, exports.getSchemaPath)((0, exports.parseInstancePath)(instancePath), '', schema);
+    if (schemaPath) {
+        return schemaPath.length ? (0, get_1.default)(schema, schemaPath) : schema;
+    }
+    return undefined;
+};
+exports.getSchemaByInstancePath = getSchemaByInstancePath;
+const getSchemaByFinalFormPath = (finalFormNameOrPath, finalFormHeadName, schema) => {
+    const schemaPath = (0, exports.getSchemaPath)(finalFormNameOrPath, finalFormHeadName, schema);
+    if (schemaPath) {
+        return schemaPath.length ? (0, get_1.default)(schema, schemaPath) : schema;
+    }
+    return undefined;
+};
+exports.getSchemaByFinalFormPath = getSchemaByFinalFormPath;
+const getValuePaths = (value, path = []) => {
+    const result = [];
+    const isObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+    if (Array.isArray(value)) {
+        value.forEach((_, index) => {
+            result.push(...(0, exports.getValuePaths)(value[index], [...path, `${index}`]));
+        });
+    }
+    else if (isObject(value)) {
+        Object.keys(value).forEach((key) => {
+            result.push(...(0, exports.getValuePaths)((0, get_1.default)(value, key), [...path, key]));
+        });
+    }
+    else if (path.length) {
+        result.push(path);
+    }
+    return result;
+};
+exports.getValuePaths = getValuePaths;
+const smartSet = (object, path, value) => {
+    const valuePaths = (0, exports.getValuePaths)(value);
+    if (valuePaths.length) {
+        (0, set_1.default)(object, path, Object.assign({}, (0, get_1.default)(object, path)));
+        valuePaths.forEach((valuePath) => {
+            (0, set_1.default)(object, [...path, ...valuePath], (0, get_1.default)(value, valuePath));
+        });
+    }
+    return object;
+};
+exports.smartSet = smartSet;
+const smartMerge = (first, second, deep = false) => {
+    let result = {};
+    if (deep) {
+        (0, exports.getValuePaths)(first).forEach((path) => {
+            (0, set_1.default)(result, path, (0, get_1.default)(first, path));
+        });
+    }
+    else {
+        result = Object.assign({}, first);
+    }
+    (0, exports.getValuePaths)(second).forEach((path) => {
+        (0, set_1.default)(result, path, (0, get_1.default)(second, path));
+    });
+    return result;
+};
+exports.smartMerge = smartMerge;

package/build/cjs/lib/unstable/core/utils/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./common"), exports);

package/build/cjs/lib/unstable/kit/Accordeon.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Accordeon = void 0;
+const tslib_1 = require("tslib");
+// import {ArrayLayoutProps, ObjectLayoutProps, isArrayItem} from '../../../../core';
+const react_1 = tslib_1.__importDefault(require("react"));
+const components_1 = require("../../kit/components");
+// import {useErrorChecker} from '../../../hooks';
+// import {RemoveButton} from '../../kit/components/RemoveButton';
+const SimpleVerticalAccordeon_1 = require("../../kit/components/SimpleVerticalAccordeon");
+const Accordeon = ({ schema, input, meta, children, wrapperProps, }) => {
+    const [open, setOpen] = react_1.default.useState(Boolean(wrapperProps === null || wrapperProps === void 0 ? void 0 : wrapperProps.open));
+    // const onDrop = React.useCallback(() => {
+    //     setOpen(false);
+    //     input.onDrop();
+    // }, [input.onDrop, setOpen]);
+    // const removeButton = React.useMemo(() => {
+    //     if (!isArrayItem(name) && (spec.required || !input.value)) {
+    //         return null;
+    //     }
+    //     return <RemoveButton name={name} onDrop={onDrop} />;
+    // }, [spec.required, input.value, onDrop, name]);
+    // useErrorChecker({name, meta, open, setOpen});
+    return (react_1.default.createElement(SimpleVerticalAccordeon_1.SimpleVerticalAccordeon, { name: input.name, title: schema.title || '', note: schema.description || '', open: open, onOpenChange: setOpen, 
+        // headerActionsTemplate={removeButton}
+        hideInsteadOfDestroy: true, withBranchView: true },
+        react_1.default.createElement(components_1.ErrorWrapper, { name: input.name, meta: meta, 
+            // ff
+            withoutChildErrorStyles: true }, children)));
+};
+exports.Accordeon = Accordeon;

package/build/cjs/lib/unstable/kit/Any.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyInput = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const uikit_1 = require("@gravity-ui/uikit");
+const core_1 = require("../core");
+const AnyInput = ({ input, schema }) => {
+    var _a;
+    const [state, setState] = react_1.default.useState(true);
+    // React.useEffect(() => {
+    //     input.onChange(undefined);
+    // }, []);
+    return (react_1.default.createElement(react_1.default.Fragment, null,
+        react_1.default.createElement(core_1.Entity, { name: `${input.name}.bla`, schema: (_a = schema.oneOf) === null || _a === void 0 ? void 0 : _a[state ? 0 : 1] }),
+        react_1.default.createElement(uikit_1.Button, { onClick: () => {
+                input.onChange(undefined);
+                setState(!state);
+            } }, "Toggle")));
+};
+exports.AnyInput = AnyInput;

package/build/cjs/lib/unstable/kit/ArrayBase.css

@@ -0,0 +1,23 @@
+.array-base_add-button-right {
+  display: flex;
+  align-items: flex-end;
+}
+.array-base_add-button-right .transparent {
+  align-items: flex-end;
+}
+.array-base__items-wrapper_add-button-down {
+  margin-bottom: 15px;
+}
+.array-base__items-wrapper_items-primitive {
+  min-width: 100%;
+}
+.array-base__items-wrapper_items-primitive:empty {
+  min-width: unset;
+}
+.array-base__item-prefix {
+  margin-top: -7px;
+  margin-bottom: 8px;
+}
+.array-base__add-button_right {
+  margin-left: 4px;
+}