@gravity-ui/dynamic-forms 5.19.1 → 5.21.0

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

@@ -0,0 +1,59 @@
+import { v4 as uuidv4 } from 'uuid';
+import { getServiceFieldName } from '../../utils';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../constants';
+export const getSubscribe = (form, headName) => {
+    const srName = getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName);
+    const subscribe = (subscriber) => {
+        var _a, _b;
+        const id = uuidv4();
+        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 };
+};

package/build/esm/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/esm/lib/unstable/core/useSchemaRenderer/utils/get-validate.js

@@ -1,62 +1,83 @@
 import get from 'lodash/get';
-import isBoolean from 'lodash/isBoolean';
 import isObjectLike from 'lodash/isObjectLike';
-import isString from 'lodash/isString';
-import { formatFinalFormPath, getValuePaths } from '../../utils';
-import { getAjvValidate } from './get-ajv-validate';
-import { processAjvValidateErrors } from './process-ajv-validate-errors';
-import { processErrorsState } from './process-errors-state';
-export const getValidate = ({ config, errorMessages, name, setAsyncValidationCache, setAsyncValidationWaiters, setErrors, }) => {
+import { SchemaRendererEventType } from '../../constants';
+import { arrayPathToDotBracket, dotBracketToArrayPath, getServiceFieldName, getValuePaths, } from '../../utils';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../constants';
+import { getSchemaRootNode } from './get-schema-root-node';
+import { getParser } from './parse-errors';
+export 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 ? get(allValues, headName) : allValues;
+        const srName = getServiceFieldName(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 = getAjvValidate({ config, schema });
+        if (srState.schema !== schema || srState.config !== config) {
+            config = srState.config;
+            schema = srState.schema;
+            schemaNode = getSchemaRootNode({ config, schema });
         }
-        ajvValidate(value);
-        const { ajvErrorItems, entityParametersErrorItems, waiters } = 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 = 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 } = 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 (isObjectLike(item.error)) {
-                getValuePaths(item.error).forEach((childPath) => {
-                    result.errors[formatFinalFormPath([name, ...item.path, ...childPath])] = get(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 (isObjectLike(e)) {
+                getValuePaths(e).forEach((childArrPath) => {
+                    const childName = arrayPathToDotBracket([
+                        ...dotBracketToArrayPath(n),
+                        ...childArrPath,
+                    ]);
+                    allErrors[childName] = get(e, childArrPath);
                 });
-                return;
             }
-            if (isBoolean(item.error) || isString(item.error)) {
-                result.errors[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: 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;
     };
 };

package/build/esm/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/esm/lib/unstable/core/useSchemaRenderer/utils/index.js

@@ -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/esm/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;

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

@@ -0,0 +1,334 @@
+import get from 'lodash/get';
+import isEqual from 'lodash/isEqual';
+import isFunction from 'lodash/isFunction';
+import isObject from 'lodash/isObject';
+import isString from 'lodash/isString';
+import omit from 'lodash/omit';
+import { arrayPathToDotBracket, dotBracketToArrayPath, getSchemaByPointer, pointerToArrayPath, } from '../../utils';
+const getNameFromRoot = (headName, pointer) => arrayPathToDotBracket([...dotBracketToArrayPath(headName), ...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 (isString(messageBySchema)) {
+        return messageBySchema;
+    }
+    if (isFunction(messageBySchema)) {
+        return messageBySchema(error);
+    }
+    const codeToPropertyKey = {
+        'missing-dependency-error': 'missingProperty',
+        'required-property-error': 'key',
+    };
+    const propertyKey = codeToPropertyKey[error.code];
+    if (isObject(messageBySchema) && propertyKey) {
+        const message = get(messageBySchema, get(error.data, propertyKey));
+        if (isString(message)) {
+            return message;
+        }
+        if (isFunction(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 = 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 = omit(error.data, 'pointer');
+    const cache = state.cache[nameFromRoot];
+    const cacheItem = cache === null || cache === void 0 ? void 0 : cache.find((c) => isEqual(params, omit(c, 'result')));
+    const waiter = state.waiters[nameFromRoot];
+    if (cacheItem) {
+        setNPError(nameFromRoot, cacheItem.result);
+        return;
+    }
+    if (!waiter || !isEqual(params, omit(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);
+};
+export 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/esm/lib/unstable/core/useSchemaRendererState/index.d.ts

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

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

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

package/build/esm/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/esm/lib/unstable/core/useSchemaRendererState/useSchemaRendererState.js

@@ -0,0 +1,57 @@
+import React from 'react';
+import { useForm } from 'react-final-form';
+import { SchemaRendererEventType } from '../constants';
+import { SCHEMA_RENDERER_SERVICE_FIELD } from '../useSchemaRenderer';
+import { getSchemaByPointer, getServiceFieldName } from '../utils';
+export const useSchemaRendererState = ({ headName, name, schemaPath, subscriptions = Object.values(SchemaRendererEventType), }) => {
+    const form = useForm();
+    const uuidRef = React.useRef(null);
+    const [tick, setTick] = React.useState(0);
+    const srName = React.useMemo(() => getServiceFieldName(SCHEMA_RENDERER_SERVICE_FIELD, headName), [headName]);
+    React.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 = 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.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.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;
+};

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

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

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

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