@gravity-ui/dynamic-forms 5.20.0 → 5.22.0

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

@@ -0,0 +1,338 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getParser = getParser;
+const tslib_1 = require("tslib");
+const get_1 = tslib_1.__importDefault(require("lodash/get"));
+const isEqual_1 = tslib_1.__importDefault(require("lodash/isEqual"));
+const isFunction_1 = tslib_1.__importDefault(require("lodash/isFunction"));
+const isObject_1 = tslib_1.__importDefault(require("lodash/isObject"));
+const isString_1 = tslib_1.__importDefault(require("lodash/isString"));
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const utils_1 = require("../../utils");
+const getNameFromRoot = (headName, pointer) => (0, utils_1.arrayPathToDotBracket)([...(0, utils_1.dotBracketToArrayPath)(headName), ...(0, utils_1.pointerToArrayPath)(pointer)]);
+const extractMessage = (messages, error) => {
+    const codeToKeyword = {
+        'additional-items-error': 'additionalItems',
+        'any-of-error': 'anyOf',
+        'const-error': 'const',
+        'contains-any-error': 'contains',
+        'contains-min-error': 'contains',
+        'enum-error': 'enum',
+        'exclusive-maximum-error': 'exclusiveMaximum',
+        'exclusive-minimum-error': 'exclusiveMinimum',
+        'invalid-property-name-error': 'propertyNames',
+        'max-items-error': 'maxItems',
+        'max-length-error': 'maxLength',
+        'max-properties-error': 'maxProperties',
+        'maximum-error': 'maximum',
+        'min-items-error': 'minItems',
+        'min-length-error': 'minLength',
+        'min-properties-error': 'minProperties',
+        'minimum-error': 'minimum',
+        'missing-dependency-error': 'dependencies',
+        'multiple-of-error': 'multipleOf',
+        'no-additional-properties-error': 'additionalProperties',
+        'node-parameters-error': undefined,
+        'not-error': 'not',
+        'one-of-error': 'oneOf',
+        'pattern-error': 'pattern',
+        'required-property-error': 'required',
+        'type-error': 'type',
+        'unique-items-error': 'uniqueItems',
+    };
+    const keyword = codeToKeyword[error.code];
+    const messageBySchema = keyword ? messages === null || messages === void 0 ? void 0 : messages[keyword] : undefined;
+    if ((0, isString_1.default)(messageBySchema)) {
+        return messageBySchema;
+    }
+    if ((0, isFunction_1.default)(messageBySchema)) {
+        return messageBySchema(error);
+    }
+    const codeToPropertyKey = {
+        'missing-dependency-error': 'missingProperty',
+        'required-property-error': 'key',
+    };
+    const propertyKey = codeToPropertyKey[error.code];
+    if ((0, isObject_1.default)(messageBySchema) && propertyKey) {
+        const message = (0, get_1.default)(messageBySchema, (0, get_1.default)(error.data, propertyKey));
+        if ((0, isString_1.default)(message)) {
+            return message;
+        }
+        if ((0, isFunction_1.default)(message)) {
+            return message(error);
+        }
+    }
+    return undefined;
+};
+const getInstanceSchema = ({ error, form, headName, state, }) => {
+    var _a;
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const field = form.getFieldState(nameFromRoot);
+    const schemaPath = (_a = field === null || field === void 0 ? void 0 : field.data) === null || _a === void 0 ? void 0 : _a.schemaPath;
+    if (schemaPath) {
+        const schema = (0, utils_1.getSchemaByPointer)(state.schema, schemaPath);
+        if (schema) {
+            return schema;
+        }
+    }
+    return undefined;
+};
+const parseError = (params) => {
+    var _a, _b, _c;
+    const { error, headName, setJSLError, state } = params;
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const message = extractMessage((_a = error.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+        extractMessage((_c = (_b = getInstanceSchema(params)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, error) ||
+        extractMessage(state.errorMessages, error) ||
+        error.message;
+    setJSLError(nameFromRoot, message);
+};
+const parseAdditionalItemsError = (params) => {
+    var _a, _b, _c, _d, _e;
+    const { error, form, headName, setJSLError, state } = params;
+    if (error.code !== 'additional-items-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const parentPointer = error.data.pointer.replace(/\/[^/]*$/, '');
+    const parentError = Object.assign(Object.assign({}, error), { data: Object.assign(Object.assign({}, error.data), { pointer: parentPointer }) });
+    const parentParams = Object.assign(Object.assign({}, params), { error: parentError });
+    if (form.getFieldState(nameFromRoot)) {
+        const message = extractMessage((_a = error.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+            extractMessage((_c = (_b = getInstanceSchema(params)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, error) ||
+            extractMessage((_e = (_d = getInstanceSchema(parentParams)) === null || _d === void 0 ? void 0 : _d.nodeParameters) === null || _e === void 0 ? void 0 : _e.errorMessages, error) ||
+            extractMessage(state.errorMessages, error) ||
+            error.message;
+        setJSLError(nameFromRoot, message);
+    }
+    else {
+        parseError(parentParams);
+    }
+};
+const parseSchemaContainsError = (params) => {
+    var _a, _b, _c, _d;
+    const { error, headName, setJSLError, state } = params;
+    if (error.code !== 'contains-min-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const message = extractMessage((_a = error.data.schema.contains.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+        extractMessage((_b = error.data.schema.nodeParameters) === null || _b === void 0 ? void 0 : _b.errorMessages, error) ||
+        extractMessage((_d = (_c = getInstanceSchema(params)) === null || _c === void 0 ? void 0 : _c.nodeParameters) === null || _d === void 0 ? void 0 : _d.errorMessages, error) ||
+        extractMessage(state.errorMessages, error) ||
+        error.message;
+    setJSLError(nameFromRoot, message);
+};
+const parseInvalidPropertyNameError = (params) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const { error, form, headName, setJSLError, state } = params;
+    if (error.code !== 'invalid-property-name-error') {
+        return;
+    }
+    const nestedError = error.data.validationError;
+    const propertyNameFromRoot = getNameFromRoot(headName, nestedError.data.pointer);
+    if (form.getFieldState(propertyNameFromRoot)) {
+        const nestedParams = Object.assign(Object.assign({}, params), { error: nestedError });
+        const message = extractMessage((_a = nestedError.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, nestedError) ||
+            extractMessage((_c = (_b = getInstanceSchema(nestedParams)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, nestedError) ||
+            extractMessage((_d = error.data.schema.nodeParameters) === null || _d === void 0 ? void 0 : _d.errorMessages, error) ||
+            extractMessage((_f = (_e = getInstanceSchema(params)) === null || _e === void 0 ? void 0 : _e.nodeParameters) === null || _f === void 0 ? void 0 : _f.errorMessages, error) ||
+            extractMessage(state.errorMessages, nestedError) ||
+            extractMessage(state.errorMessages, error) ||
+            nestedError.message;
+        setJSLError(propertyNameFromRoot, message);
+    }
+    else {
+        const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+        const message = extractMessage((_g = nestedError.data.schema.nodeParameters) === null || _g === void 0 ? void 0 : _g.errorMessages, error) ||
+            extractMessage((_h = error.data.schema.nodeParameters) === null || _h === void 0 ? void 0 : _h.errorMessages, error) ||
+            extractMessage((_k = (_j = getInstanceSchema(params)) === null || _j === void 0 ? void 0 : _j.nodeParameters) === null || _k === void 0 ? void 0 : _k.errorMessages, error) ||
+            extractMessage(state.errorMessages, error) ||
+            error.message;
+        setJSLError(nameFromRoot, message);
+    }
+};
+const parseMissingDependencyError = (params) => {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const { error, form, headName, setJSLError, state } = params;
+    if (error.code !== 'missing-dependency-error') {
+        return;
+    }
+    const propertyPointer = `${error.data.pointer}/${error.data.missingProperty}`;
+    const propertyNameFromRoot = getNameFromRoot(headName, propertyPointer);
+    if (form.getFieldState(propertyNameFromRoot)) {
+        const propertyError = Object.assign(Object.assign({}, error), { data: Object.assign(Object.assign({}, error.data), { pointer: propertyPointer }) });
+        const message = extractMessage((_a = propertyError.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, propertyError) ||
+            extractMessage((_c = (_b = getInstanceSchema(Object.assign(Object.assign({}, params), { error: propertyError }))) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, propertyError) ||
+            extractMessage((_e = (_d = getInstanceSchema(params)) === null || _d === void 0 ? void 0 : _d.nodeParameters) === null || _e === void 0 ? void 0 : _e.errorMessages, propertyError) ||
+            extractMessage(state.errorMessages, propertyError) ||
+            propertyError.message;
+        setJSLError(propertyNameFromRoot, message);
+    }
+    else {
+        const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+        const message = extractMessage((_f = error.data.schema.nodeParameters) === null || _f === void 0 ? void 0 : _f.errorMessages, error) ||
+            extractMessage((_h = (_g = getInstanceSchema(params)) === null || _g === void 0 ? void 0 : _g.nodeParameters) === null || _h === void 0 ? void 0 : _h.errorMessages, error) ||
+            extractMessage(state.errorMessages, error) ||
+            error.message;
+        setJSLError(nameFromRoot, message);
+    }
+};
+const parseAdditionalPropertiesError = (params) => {
+    var _a, _b, _c, _d, _e;
+    const { error, form, headName, setJSLError, state } = params;
+    if (error.code !== 'no-additional-properties-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const parentPointer = error.data.pointer.replace(/\/[^/]*$/, '');
+    const parentError = Object.assign(Object.assign({}, error), { data: Object.assign(Object.assign({}, error.data), { pointer: parentPointer }) });
+    const parentParams = Object.assign(Object.assign({}, params), { error: parentError });
+    if (form.getFieldState(nameFromRoot)) {
+        const message = extractMessage((_a = error.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+            extractMessage((_c = (_b = getInstanceSchema(params)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, error) ||
+            extractMessage((_e = (_d = getInstanceSchema(parentParams)) === null || _d === void 0 ? void 0 : _d.nodeParameters) === null || _e === void 0 ? void 0 : _e.errorMessages, error) ||
+            extractMessage(state.errorMessages, error) ||
+            error.message;
+        setJSLError(nameFromRoot, message);
+    }
+    else {
+        parseError(parentParams);
+    }
+};
+const parseNPError = ({ allValues, error, headName, setNPError, setWaiter, state, }) => {
+    if (error.code !== 'node-parameters-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const params = (0, omit_1.default)(error.data, 'pointer');
+    const cache = state.cache[nameFromRoot];
+    const cacheItem = cache === null || cache === void 0 ? void 0 : cache.find((c) => (0, isEqual_1.default)(params, (0, omit_1.default)(c, 'result')));
+    const waiter = state.waiters[nameFromRoot];
+    if (cacheItem) {
+        setNPError(nameFromRoot, cacheItem.result);
+        return;
+    }
+    if (!waiter || !(0, isEqual_1.default)(params, (0, omit_1.default)(waiter, 'promise'))) {
+        const errorOrPromise = params.validator(params.value, allValues);
+        if (errorOrPromise instanceof Promise) {
+            const w = Object.assign(Object.assign({}, params), { promise: errorOrPromise });
+            setWaiter(nameFromRoot, w);
+            errorOrPromise.then((result) => {
+                // eslint-disable-next-line no-param-reassign
+                state.cache[nameFromRoot] = [
+                    ...(state.cache[nameFromRoot] || []),
+                    Object.assign(Object.assign({}, params), { result }),
+                ];
+                if (state.waiters[nameFromRoot] === w) {
+                    // eslint-disable-next-line no-param-reassign
+                    state.waiters[nameFromRoot] = undefined;
+                    state.runValidate();
+                }
+            });
+        }
+        else {
+            setNPError(nameFromRoot, errorOrPromise);
+        }
+    }
+};
+const parseNotError = (params) => {
+    var _a, _b, _c, _d;
+    const { error, headName, setJSLError, state } = params;
+    if (error.code !== 'not-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const message = extractMessage((_a = error.data.not.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+        extractMessage((_b = error.data.schema.nodeParameters) === null || _b === void 0 ? void 0 : _b.errorMessages, error) ||
+        extractMessage((_d = (_c = getInstanceSchema(params)) === null || _c === void 0 ? void 0 : _c.nodeParameters) === null || _d === void 0 ? void 0 : _d.errorMessages, error) ||
+        extractMessage(state.errorMessages, error) ||
+        error.message;
+    setJSLError(nameFromRoot, message);
+};
+const parseOneOfError = (params) => {
+    var _a, _b, _c;
+    const { error, headName, setJSLError, state } = params;
+    if (error.code !== 'one-of-error') {
+        return;
+    }
+    const nameFromRoot = getNameFromRoot(headName, error.data.pointer);
+    const message = extractMessage((_a = error.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, error) ||
+        extractMessage((_c = (_b = getInstanceSchema(params)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, error);
+    if (message) {
+        setJSLError(nameFromRoot, message);
+    }
+    else {
+        const firstError = error.data.errors[0];
+        const parser = getParser(firstError.code);
+        if (parser) {
+            parser(Object.assign(Object.assign({}, params), { error: firstError }));
+        }
+        else {
+            setJSLError(nameFromRoot, extractMessage(state.errorMessages, error) || error.message);
+        }
+    }
+};
+const parseRequiredPropertyError = (params) => {
+    var _a, _b, _c, _d, _e;
+    const { error, form, headName, setJSLError, state } = params;
+    if (error.code !== 'required-property-error') {
+        return;
+    }
+    const propertyPointer = `${error.data.pointer}/${error.data.key}`;
+    const propertyNameFromRoot = getNameFromRoot(headName, propertyPointer);
+    const propertyError = Object.assign(Object.assign({}, error), { data: Object.assign(Object.assign({}, error.data), { pointer: propertyPointer }) });
+    const propertyParams = Object.assign(Object.assign({}, params), { error: propertyError });
+    if (form.getFieldState(propertyNameFromRoot)) {
+        const message = extractMessage((_a = error.data.schema.nodeParameters) === null || _a === void 0 ? void 0 : _a.errorMessages, propertyError) ||
+            extractMessage((_c = (_b = getInstanceSchema(propertyParams)) === null || _b === void 0 ? void 0 : _b.nodeParameters) === null || _c === void 0 ? void 0 : _c.errorMessages, propertyError) ||
+            extractMessage((_e = (_d = getInstanceSchema(params)) === null || _d === void 0 ? void 0 : _d.nodeParameters) === null || _e === void 0 ? void 0 : _e.errorMessages, propertyError) ||
+            extractMessage(state.errorMessages, propertyError) ||
+            propertyError.message;
+        setJSLError(propertyNameFromRoot, message);
+    }
+    else {
+        parseError(params);
+    }
+};
+const parseUniqueItemsError = (params) => {
+    const { error } = params;
+    if (error.code !== 'unique-items-error') {
+        return;
+    }
+    const parentError = Object.assign(Object.assign({}, error), { data: Object.assign(Object.assign({}, error.data), { pointer: error.data.arrayPointer }) });
+    const parentParams = Object.assign(Object.assign({}, params), { error: parentError });
+    parseError(parentParams);
+};
+function getParser(code) {
+    const parserByCode = {
+        'additional-items-error': parseAdditionalItemsError,
+        'any-of-error': parseError,
+        'const-error': parseError,
+        'contains-any-error': parseError,
+        'contains-min-error': parseSchemaContainsError,
+        'enum-error': parseError,
+        'exclusive-maximum-error': parseError,
+        'exclusive-minimum-error': parseError,
+        'invalid-property-name-error': parseInvalidPropertyNameError,
+        'max-items-error': parseError,
+        'max-length-error': parseError,
+        'max-properties-error': parseError,
+        'maximum-error': parseError,
+        'min-items-error': parseError,
+        'min-length-error': parseError,
+        'min-properties-error': parseError,
+        'minimum-error': parseError,
+        'missing-dependency-error': parseMissingDependencyError,
+        'multiple-of-error': parseError,
+        'no-additional-properties-error': parseAdditionalPropertiesError,
+        'node-parameters-error': parseNPError,
+        'not-error': parseNotError,
+        'one-of-error': parseOneOfError,
+        'pattern-error': parseError,
+        'required-property-error': parseRequiredPropertyError,
+        'type-error': parseError,
+        'unique-items-error': parseUniqueItemsError,
+    };
+    return parserByCode[code];
+}

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

@@ -0,0 +1 @@
+export { type UseSchemaRendererStateParams, useSchemaRendererState } from './useSchemaRendererState';

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

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

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

@@ -0,0 +1,9 @@
+import { SchemaRendererEventType } from '../constants';
+import { type SchemaRendererState } from '../useSchemaRenderer';
+export interface UseSchemaRendererStateParams {
+    headName: string;
+    name?: string;
+    schemaPath?: string;
+    subscriptions?: SchemaRendererEventType[];
+}
+export declare const useSchemaRendererState: <UserContext extends Record<string, unknown> = Record<string, unknown>>({ headName, name, schemaPath, subscriptions, }: UseSchemaRendererStateParams) => SchemaRendererState<UserContext> | undefined;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchemaRendererState = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const react_final_form_1 = require("react-final-form");
+const constants_1 = require("../constants");
+const useSchemaRenderer_1 = require("../useSchemaRenderer");
+const utils_1 = require("../utils");
+const useSchemaRendererState = ({ headName, name, schemaPath, subscriptions = Object.values(constants_1.SchemaRendererEventType), }) => {
+    const form = (0, react_final_form_1.useForm)();
+    const uuidRef = react_1.default.useRef(null);
+    const [tick, setTick] = react_1.default.useState(0);
+    const srName = react_1.default.useMemo(() => (0, utils_1.getServiceFieldName)(useSchemaRenderer_1.SCHEMA_RENDERER_SERVICE_FIELD, headName), [headName]);
+    react_1.default.useMemo(() => {
+        var _a;
+        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) {
+            if (uuidRef.current) {
+                srState.unsubscribe(uuidRef.current);
+            }
+            const subscription = subscriptions.reduce((acc, s) => (Object.assign(Object.assign({}, acc), { [s]: true })), {});
+            const walk = (path, paths = new Set()) => {
+                if (path && !paths.has(path)) {
+                    paths.add(path);
+                    const schema = (0, utils_1.getSchemaByPointer)(srState.schema || {}, path);
+                    return [path, ...walk(schema === null || schema === void 0 ? void 0 : schema.$ref, paths)];
+                }
+                return [];
+            };
+            const schemaPaths = walk(schemaPath);
+            uuidRef.current = srState.subscribe({
+                name,
+                schemaPaths,
+                callback: () => setTick((t) => t + 1),
+                subscription,
+            });
+        }
+    }, [form, name, schemaPath, srName, subscriptions.join(',')]);
+    const state = react_1.default.useMemo(() => {
+        var _a;
+        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 Object.assign({}, srState);
+        }
+        return undefined;
+    }, [form, srName, tick]);
+    react_1.default.useEffect(() => {
+        return () => {
+            var _a;
+            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 && uuidRef.current) {
+                srState.unsubscribe(uuidRef.current);
+            }
+        };
+    }, []);
+    return state;
+};
+exports.useSchemaRendererState = useSchemaRendererState;

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { type AddExternalErrorsParams, type AddSchemaPatchesParams, type RemoveExternalErrorsParams, type RemoveSchemaPatchesParams, type UpdateUserContextParams } from './utils';
+export declare const useSchemaRendererTools: () => {
+    addExternalErrors: ({ headName, priorityErrors, regularErrors, }: Omit<AddExternalErrorsParams, "form">) => void;
+    addSchemaPatches: ({ patches }: Omit<AddSchemaPatchesParams, "form">) => void;
+    removeExternalErrors: ({ headName, removeFunctionOrNames, }: Omit<RemoveExternalErrorsParams, "form">) => void;
+    removeSchemaPatches: ({ patchesToRemove }: Omit<RemoveSchemaPatchesParams, "form">) => void;
+    updateUserContext: ({ headName, userContext, replace, }: Omit<UpdateUserContextParams, "form">) => void;
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSchemaRendererTools = void 0;
+const tslib_1 = require("tslib");
+const react_1 = tslib_1.__importDefault(require("react"));
+const react_final_form_1 = require("react-final-form");
+const utils_1 = require("./utils");
+const useSchemaRendererTools = () => {
+    const form = (0, react_final_form_1.useForm)();
+    const tools = react_1.default.useMemo(() => ({
+        addExternalErrors: ({ headName, priorityErrors, regularErrors, }) => (0, utils_1.addExternalErrors)({ form, headName, priorityErrors, regularErrors }),
+        addSchemaPatches: ({ patches }) => (0, utils_1.addSchemaPatches)({ form, patches }),
+        removeExternalErrors: ({ headName, removeFunctionOrNames, }) => (0, utils_1.removeExternalErrors)({ form, headName, removeFunctionOrNames }),
+        removeSchemaPatches: ({ patchesToRemove }) => (0, utils_1.removeSchemaPatches)({ form, patchesToRemove }),
+        updateUserContext: ({ headName, userContext, replace, }) => (0, utils_1.updateUserContext)({ form, headName, userContext, replace }),
+    }), [form]);
+    return tools;
+};
+exports.useSchemaRendererTools = useSchemaRendererTools;

package/build/cjs/lib/unstable/core/useSchemaRendererTools/utils/external-errors.d.ts

@@ -0,0 +1,18 @@
+import type { FormApi } from 'final-form';
+import type { ValidationError } from '../../types';
+export interface AddExternalErrorsParams {
+    form: FormApi;
+    headName: string;
+    priorityErrors?: Record<string, ValidationError>;
+    regularErrors?: Record<string, ValidationError>;
+}
+export declare const addExternalErrors: ({ form, headName, priorityErrors, regularErrors, }: AddExternalErrorsParams) => void;
+export interface RemoveExternalErrorsParams {
+    form: FormApi;
+    headName: string;
+    removeFunctionOrNames: string[] | ((priorityErrors: Record<string, ValidationError>, regularErrors: Record<string, ValidationError>) => {
+        priorityErrors: Record<string, ValidationError>;
+        regularErrors: Record<string, ValidationError>;
+    });
+}
+export declare const removeExternalErrors: ({ form, headName, removeFunctionOrNames, }: RemoveExternalErrorsParams) => void;

package/build/cjs/lib/unstable/core/useSchemaRendererTools/utils/external-errors.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeExternalErrors = exports.addExternalErrors = void 0;
+const tslib_1 = require("tslib");
+const omit_1 = tslib_1.__importDefault(require("lodash/omit"));
+const useSchemaRenderer_1 = require("../../useSchemaRenderer");
+const utils_1 = require("../../utils");
+const addExternalErrors = ({ form, headName, priorityErrors, regularErrors, }) => {
+    var _a;
+    const srName = (0, utils_1.getServiceFieldName)(useSchemaRenderer_1.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 && (priorityErrors || regularErrors)) {
+        srState.priorityErrors = Object.assign(Object.assign({}, srState.priorityErrors), priorityErrors);
+        srState.regularErrors = Object.assign(Object.assign({}, srState.regularErrors), regularErrors);
+        srState.runValidate();
+    }
+};
+exports.addExternalErrors = addExternalErrors;
+const removeExternalErrors = ({ form, headName, removeFunctionOrNames, }) => {
+    var _a;
+    const srName = (0, utils_1.getServiceFieldName)(useSchemaRenderer_1.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 && removeFunctionOrNames) {
+        if (Array.isArray(removeFunctionOrNames)) {
+            srState.priorityErrors = (0, omit_1.default)(srState.priorityErrors, removeFunctionOrNames);
+            srState.regularErrors = (0, omit_1.default)(srState.regularErrors, removeFunctionOrNames);
+        }
+        else {
+            const { priorityErrors, regularErrors } = removeFunctionOrNames(Object.assign({}, srState.priorityErrors), Object.assign({}, srState.regularErrors));
+            srState.priorityErrors = priorityErrors;
+            srState.regularErrors = regularErrors;
+        }
+        srState.runValidate();
+    }
+};
+exports.removeExternalErrors = removeExternalErrors;

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

@@ -0,0 +1,3 @@
+export { type AddSchemaPatchesParams, type RemoveSchemaPatchesParams, addSchemaPatches, removeSchemaPatches, } from './schema-patch';
+export { type AddExternalErrorsParams, type RemoveExternalErrorsParams, addExternalErrors, removeExternalErrors, } from './external-errors';
+export { type UpdateUserContextParams, updateUserContext } from './user-context';

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateUserContext = exports.removeExternalErrors = exports.addExternalErrors = exports.removeSchemaPatches = exports.addSchemaPatches = void 0;
+var schema_patch_1 = require("./schema-patch");
+Object.defineProperty(exports, "addSchemaPatches", { enumerable: true, get: function () { return schema_patch_1.addSchemaPatches; } });
+Object.defineProperty(exports, "removeSchemaPatches", { enumerable: true, get: function () { return schema_patch_1.removeSchemaPatches; } });
+var external_errors_1 = require("./external-errors");
+Object.defineProperty(exports, "addExternalErrors", { enumerable: true, get: function () { return external_errors_1.addExternalErrors; } });
+Object.defineProperty(exports, "removeExternalErrors", { enumerable: true, get: function () { return external_errors_1.removeExternalErrors; } });
+var user_context_1 = require("./user-context");
+Object.defineProperty(exports, "updateUserContext", { enumerable: true, get: function () { return user_context_1.updateUserContext; } });

package/build/cjs/lib/unstable/core/useSchemaRendererTools/utils/schema-patch.d.ts

@@ -0,0 +1,12 @@
+import type { FormApi } from 'final-form';
+import { type SchemaPatch, type SchemaPatchRemover } from '../../useSchemaRenderer';
+export interface AddSchemaPatchesParams {
+    form: FormApi;
+    patches: SchemaPatch[];
+}
+export declare const addSchemaPatches: ({ form, patches }: AddSchemaPatchesParams) => void;
+export interface RemoveSchemaPatchesParams {
+    form: FormApi;
+    patchesToRemove: SchemaPatchRemover[];
+}
+export declare const removeSchemaPatches: ({ form, patchesToRemove }: RemoveSchemaPatchesParams) => void;