@gravity-ui/dynamic-forms 5.20.0 → 5.22.0

package/build/cjs/lib/unstable/core/useSchemaRenderer/utils/get-schema-root-node.js

@@ -0,0 +1,136 @@
+"use strict";
+/* eslint-disable complexity */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSchemaRootNode = void 0;
+const tslib_1 = require("tslib");
+const decimal_js_1 = tslib_1.__importDefault(require("decimal.js"));
+const json_schema_library_1 = require("json-schema-library");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const constants_1 = require("../../constants");
+const getSchemaRootNode = ({ config, keywords, schema: rootSchema, }) => {
+    const nodeParametersKeyword = {
+        id: 'nodeParameters',
+        keyword: 'nodeParameters',
+        addValidate: (node) => { var _a; return ((_a = node.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.validator) !== undefined; },
+        validate: ({ node, data: value, pointer }) => {
+            const schema = node.schema;
+            if (schema.nodeParameters) {
+                let validator;
+                if ((0, isString_1.default)(schema.nodeParameters.validator)) {
+                    const nodeType = schema.nodeParameters.type;
+                    const validatorType = schema.nodeParameters.validator;
+                    validator = (0, get_1.default)(config, `${nodeType}.validators.${validatorType}`);
+                }
+                else {
+                    validator = schema.nodeParameters.validator;
+                }
+                if (validator) {
+                    return node.createError('node-parameters-error', { pointer, schema, value, validator }, '');
+                }
+            }
+            return undefined;
+        },
+    };
+    const stringNumberKeyword = {
+        id: 'stringNumber',
+        keyword: 'stringNumber',
+        addValidate: (node) => node.schema.stringNumber !== undefined,
+        validate: ({ node, data: value, pointer }) => {
+            const schema = node.schema;
+            const stringNumber = schema.stringNumber;
+            if (!stringNumber) {
+                return undefined;
+            }
+            const isStringInt = (v) => /^-?(0|[1-9][0-9]*)$/.test(`${v}`);
+            const isStringFloat = (v) => /^-?(0|[1-9][0-9]*)(\.[0-9]+)?$/.test(`${v}`);
+            const isStringNumber = (v) => isStringInt(v) || isStringFloat(v);
+            if (stringNumber.type) {
+                const types = Array.isArray(stringNumber.type)
+                    ? stringNumber.type
+                    : [stringNumber.type];
+                const satisfactoryByType = {
+                    [constants_1.JsonSchemaType.Integer]: isStringInt(value),
+                    [constants_1.JsonSchemaType.Number]: isStringFloat(value),
+                    [constants_1.JsonSchemaType.Null]: value === null,
+                };
+                if (!types.some((type) => satisfactoryByType[type])) {
+                    return node.createError('type-error', {
+                        pointer,
+                        schema,
+                        value,
+                        received: (0, json_schema_library_1.getTypeOf)(value),
+                        expected: types.join(', '),
+                    });
+                }
+            }
+            if (stringNumber.exclusiveMaximum &&
+                isStringNumber(stringNumber.exclusiveMaximum) &&
+                isStringNumber(value) &&
+                !new decimal_js_1.default(`${value}`).lessThan(stringNumber.exclusiveMaximum)) {
+                return node.createError('exclusive-maximum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    maximum: stringNumber.exclusiveMaximum,
+                    length: value,
+                });
+            }
+            if (stringNumber.exclusiveMinimum &&
+                isStringNumber(stringNumber.exclusiveMinimum) &&
+                isStringNumber(value) &&
+                !new decimal_js_1.default(`${value}`).greaterThan(stringNumber.exclusiveMinimum)) {
+                return node.createError('exclusive-minimum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    minimum: stringNumber.exclusiveMinimum,
+                    length: value,
+                });
+            }
+            if (stringNumber.maximum &&
+                isStringNumber(stringNumber.maximum) &&
+                isStringNumber(value) &&
+                !new decimal_js_1.default(`${value}`).lessThanOrEqualTo(stringNumber.maximum)) {
+                return node.createError('maximum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    maximum: stringNumber.maximum,
+                    length: value,
+                });
+            }
+            if (stringNumber.minimum &&
+                isStringNumber(stringNumber.minimum) &&
+                isStringNumber(value) &&
+                !new decimal_js_1.default(`${value}`).greaterThanOrEqualTo(stringNumber.minimum)) {
+                return node.createError('minimum-error', {
+                    pointer,
+                    schema,
+                    value,
+                    minimum: stringNumber.minimum,
+                    length: value,
+                });
+            }
+            if (stringNumber.multipleOf &&
+                isStringNumber(stringNumber.multipleOf) &&
+                stringNumber.multipleOf !== '0' &&
+                isStringNumber(value) &&
+                !new decimal_js_1.default(`${value}`).mod(stringNumber.multipleOf).isZero()) {
+                return node.createError('multiple-of-error', {
+                    pointer,
+                    schema,
+                    value,
+                    multipleOf: stringNumber.multipleOf,
+                });
+            }
+            return undefined;
+        },
+    };
+    const draft = (0, json_schema_library_1.addKeywords)(json_schema_library_1.draft07, ...(keywords || []), nodeParametersKeyword, stringNumberKeyword);
+    return (0, json_schema_library_1.compileSchema)(rootSchema, {
+        drafts: [draft],
+        formatAssertion: false,
+    });
+};
+exports.getSchemaRootNode = getSchemaRootNode;

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

@@ -0,0 +1,6 @@
+import type { FormApi } from 'final-form';
+import type { SchemaRendererSubscriber } from '../types';
+export declare const getSubscribe: (form: FormApi, headName: string) => {
+    subscribe: (subscriber: SchemaRendererSubscriber) => string;
+    unsubscribe: (id: string) => void;
+};

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSubscribe = void 0;
+const uuid_1 = require("uuid");
+const utils_1 = require("../../utils");
+const constants_1 = require("../constants");
+const getSubscribe = (form, headName) => {
+    const srName = (0, utils_1.getServiceFieldName)(constants_1.SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    const subscribe = (subscriber) => {
+        var _a, _b;
+        const id = (0, uuid_1.v4)();
+        const srField = form.getFieldState(srName);
+        const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+        if (srState) {
+            const { subscribers } = srState;
+            subscribers.byId[id] = subscriber;
+            (_b = subscriber.schemaPaths) === null || _b === void 0 ? void 0 : _b.forEach((schemaPath) => {
+                let set = subscribers.byPath.get(schemaPath);
+                if (!set) {
+                    set = new Set();
+                    subscribers.byPath.set(schemaPath, set);
+                }
+                set.add(id);
+            });
+            if (subscriber.name) {
+                let set = subscribers.byName.get(subscriber.name);
+                if (!set) {
+                    set = new Set();
+                    subscribers.byName.set(subscriber.name, set);
+                }
+                set.add(id);
+            }
+        }
+        return id;
+    };
+    const unsubscribe = (id) => {
+        var _a, _b, _c, _d;
+        const srField = form.getFieldState(srName);
+        const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+        if (srState) {
+            const { subscribers } = srState;
+            const subscriber = subscribers.byId[id];
+            if (subscriber) {
+                (_b = subscriber.schemaPaths) === null || _b === void 0 ? void 0 : _b.forEach((schemaPath) => {
+                    var _a, _b;
+                    (_a = subscribers.byPath.get(schemaPath)) === null || _a === void 0 ? void 0 : _a.delete(id);
+                    if (((_b = subscribers.byPath.get(schemaPath)) === null || _b === void 0 ? void 0 : _b.size) === 0) {
+                        subscribers.byPath.delete(schemaPath);
+                    }
+                });
+                if (subscriber.name) {
+                    (_c = subscribers.byName.get(subscriber.name)) === null || _c === void 0 ? void 0 : _c.delete(id);
+                    if (((_d = subscribers.byName.get(subscriber.name)) === null || _d === void 0 ? void 0 : _d.size) === 0) {
+                        subscribers.byName.delete(subscriber.name);
+                    }
+                }
+                delete subscribers.byId[id];
+            }
+        }
+    };
+    return { subscribe, unsubscribe };
+};
+exports.getSubscribe = getSubscribe;

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

@@ -1,14 +1,3 @@
-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 {};
+import type { FormApi } from 'final-form';
+import type { ValidationError } from '../../types';
+export declare const getValidate: (form: FormApi, headName: string) => () => ValidationError | Promise<ValidationError>;

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

@@ -3,65 +3,86 @@ 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 constants_1 = require("../../constants");
 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, }) => {
+const constants_2 = require("../constants");
+const get_schema_root_node_1 = require("./get-schema-root-node");
+const parse_errors_1 = require("./parse-errors");
+const getValidate = (form, headName) => {
+    let config;
     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)) {
+    let schemaNode;
+    return () => {
+        var _a;
+        const allValues = form.getState().values;
+        const value = headName ? (0, get_1.default)(allValues, headName) : allValues;
+        const srName = (0, utils_1.getServiceFieldName)(constants_2.SCHEMA_RENDERER_SERVICE_FIELD, headName);
+        const srField = form.getFieldState(srName);
+        const srState = (_a = srField === null || srField === void 0 ? void 0 : srField.data) === null || _a === void 0 ? void 0 : _a.state;
+        if (!srState) {
             return false;
         }
-        if (schema !== data.schema) {
-            schema = data.schema;
-            ajvValidate = (0, get_ajv_validate_1.getAjvValidate)({ config, schema });
+        if (srState.schema !== schema || srState.config !== config) {
+            config = srState.config;
+            schema = srState.schema;
+            schemaNode = (0, get_schema_root_node_1.getSchemaRootNode)({ 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 validateErrors = schemaNode.validate(value).errors;
+        const waiters = {};
+        const jslErrors = {};
+        const npErrors = {};
+        validateErrors.forEach((error) => {
+            const parser = (0, parse_errors_1.getParser)(error.code);
+            parser({
+                allValues,
+                error,
+                form,
+                headName,
+                setJSLError: (n, e) => {
+                    jslErrors[n] = e;
+                },
+                setNPError: (n, e) => {
+                    npErrors[n] = e;
+                },
+                setWaiter: (n, w) => {
+                    waiters[n] = w;
+                },
+                state: srState,
+            });
         });
-        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);
+        const allErrors = {};
+        Object.entries(Object.assign(Object.assign(Object.assign(Object.assign({}, srState === null || srState === void 0 ? void 0 : srState.regularErrors), jslErrors), npErrors), srState === null || srState === void 0 ? void 0 : srState.priorityErrors)).forEach(([n, e]) => {
+            if ((0, isObjectLike_1.default)(e)) {
+                (0, utils_1.getValuePaths)(e).forEach((childArrPath) => {
+                    const childName = (0, utils_1.arrayPathToDotBracket)([
+                        ...(0, utils_1.dotBracketToArrayPath)(n),
+                        ...childArrPath,
+                    ]);
+                    allErrors[childName] = (0, get_1.default)(e, childArrPath);
                 });
-                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;
+            else {
+                allErrors[n] = e;
             }
         });
-        setErrors(result.errors);
-        return Object.keys(result.errors).length ? 'error' : false;
+        const newErrors = {};
+        Object.keys(Object.assign(Object.assign({}, srState.errors), allErrors)).forEach((key) => {
+            if (srState.errors[key] !== allErrors[key]) {
+                newErrors[key] = allErrors[key];
+            }
+        });
+        srState.errors = allErrors;
+        srState.waiters = Object.assign(Object.assign({}, srState.waiters), waiters);
+        if (Object.values(newErrors).length) {
+            srState.dispatchEvent([
+                { type: constants_1.SchemaRendererEventType.Error, names: Object.keys(newErrors) },
+            ]);
+        }
+        if (Object.values(waiters).length) {
+            return Promise.race(Object.values(waiters).map((w) => w.promise)).then(() => Object.values(allErrors).some(Boolean) ? 'error' : false);
+        }
+        return Object.values(allErrors).some(Boolean) ? 'error' : false;
     };
 };
 exports.getValidate = getValidate;

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

@@ -1,2 +1,4 @@
-export { guessHeadName } from './common';
+export { getDispatch } from './get-dispatch';
+export { getRunValidate } from './get-run-validate';
 export { getValidate } from './get-validate';
+export { getSubscribe } from './get-subscribe';

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

@@ -1,7 +1,11 @@
 "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; } });
+exports.getSubscribe = exports.getValidate = exports.getRunValidate = exports.getDispatch = void 0;
+var get_dispatch_1 = require("./get-dispatch");
+Object.defineProperty(exports, "getDispatch", { enumerable: true, get: function () { return get_dispatch_1.getDispatch; } });
+var get_run_validate_1 = require("./get-run-validate");
+Object.defineProperty(exports, "getRunValidate", { enumerable: true, get: function () { return get_run_validate_1.getRunValidate; } });
 var get_validate_1 = require("./get-validate");
 Object.defineProperty(exports, "getValidate", { enumerable: true, get: function () { return get_validate_1.getValidate; } });
+var get_subscribe_1 = require("./get-subscribe");
+Object.defineProperty(exports, "getSubscribe", { enumerable: true, get: function () { return get_subscribe_1.getSubscribe; } });

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

@@ -0,0 +1,14 @@
+import type { FormApi } from 'final-form';
+import type { JSLErrors, ObjectValue, ValidationError } from '../../types';
+import type { SchemaRendererState, ValidationWaiter } from '../types';
+export interface ParseErrorParams {
+    allValues: ObjectValue;
+    error: JSLErrors.Error;
+    form: FormApi<any>;
+    headName: string;
+    setJSLError: (name: string, error: ValidationError) => void;
+    setNPError: (name: string, error: ValidationError) => void;
+    setWaiter: (name: string, waiter: ValidationWaiter) => void;
+    state: SchemaRendererState;
+}
+export declare function getParser(code: JSLErrors.ErrorCode): (params: ParseErrorParams) => void;