@gravity-ui/dynamic-forms 5.19.1 → 5.21.0

package/build/esm/lib/unstable/core/useSchemaRenderer/hooks/useEntitiesState.js

@@ -1,20 +0,0 @@
-import React from 'react';
-import { useField, useForm } from 'react-final-form';
-import { ENTITY_SERVICE_FIELD } from '../constants';
-import { guessHeadName } from '../utils';
-export const useEntitiesState = (name) => {
-    var _a;
-    const form = useForm();
-    const headName = React.useMemo(() => guessHeadName(form.getRegisteredFields(), name), [form, name]);
-    const field = useField(`${ENTITY_SERVICE_FIELD}.${headName}`, { subscription: { data: true } });
-    const { config, errorsRef, mode, schema: rootSchema } = (field.meta.data || {});
-    const error = (_a = errorsRef === null || errorsRef === void 0 ? void 0 : errorsRef.current) === null || _a === void 0 ? void 0 : _a[name];
-    const state = React.useMemo(() => ({
-        config,
-        error,
-        headName,
-        mode,
-        rootSchema,
-    }), [config, error, headName, mode, rootSchema]);
-    return state;
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/hooks/useSchemaRendererMutators.d.ts

@@ -1,10 +0,0 @@
-import type { RemoveExternalErrorsMutator, RemoveSchemaMutatorsMutator, SetAsyncValidationCacheMutator, SetAsyncValidationWaitersMutator, SetExternalErrorsMutator, SetSchemaMutatorsMutator, TriggerFieldsMutator } from '../mutators';
-export declare const useSchemaRendererMutators: () => {
-    removeExternalErrors: RemoveExternalErrorsMutator | undefined;
-    removeSchemaMutators: RemoveSchemaMutatorsMutator | undefined;
-    setAsyncValidationCache: SetAsyncValidationCacheMutator | undefined;
-    setAsyncValidationWaiters: SetAsyncValidationWaitersMutator | undefined;
-    setExternalErrors: SetExternalErrorsMutator | undefined;
-    setSchemaMutators: SetSchemaMutatorsMutator | undefined;
-    triggerFields: TriggerFieldsMutator | undefined;
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/hooks/useSchemaRendererMutators.js

@@ -1,13 +0,0 @@
-import { useForm } from 'react-final-form';
-export const useSchemaRendererMutators = () => {
-    const { removeExternalErrors, removeSchemaMutators, setAsyncValidationCache, setAsyncValidationWaiters, setExternalErrors, setSchemaMutators, triggerFields, } = useForm().mutators;
-    return {
-        removeExternalErrors,
-        removeSchemaMutators,
-        setAsyncValidationCache,
-        setAsyncValidationWaiters,
-        setExternalErrors,
-        setSchemaMutators,
-        triggerFields,
-    };
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.d.ts

@@ -1,3 +0,0 @@
-import type { SetAsyncValidationCacheFunction, SetAsyncValidationWaitersFunction } from './types';
-export declare const setAsyncValidationWaiters: SetAsyncValidationWaitersFunction;
-export declare const setAsyncValidationCache: SetAsyncValidationCacheFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/async-validation.js

@@ -1,29 +0,0 @@
-import isEqual from 'lodash/isEqual';
-import omit from 'lodash/omit';
-export const setAsyncValidationWaiters = ([{ headName, waiters }], mutableState) => {
-    const field = mutableState.fields[headName];
-    if (field && waiters) {
-        Object.keys(waiters).forEach((waiterName) => {
-            field.data = Object.assign(Object.assign({}, field.data), { waiters: Object.assign(Object.assign({}, field.data.waiters), { [waiterName]: waiters[waiterName] }) });
-            const waiterField = mutableState.fields[waiterName];
-            if (waiterField) {
-                waiterField.validating = true;
-            }
-        });
-    }
-};
-export const setAsyncValidationCache = ([{ headName, cache }], mutableState) => {
-    const field = mutableState.fields[headName];
-    if (field && cache) {
-        Object.keys(cache).forEach((cacheName) => {
-            var _a, _b;
-            field.data = Object.assign(Object.assign({}, field.data), { cache: Object.assign(Object.assign({}, field.data.cache), { [cacheName]: [...(((_a = field.data.cache) === null || _a === void 0 ? void 0 : _a[cacheName]) || []), cache[cacheName]] }) });
-            const cacheField = mutableState.fields[cacheName];
-            const waiter = (_b = field.data.waiters) === null || _b === void 0 ? void 0 : _b[cacheName];
-            if (cacheField && waiter && isEqual(waiter, omit(cache[cacheName], 'result'))) {
-                field.data.waiters = omit(field.data.waiters, cacheName);
-                cacheField.validating = false;
-            }
-        });
-    }
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.d.ts

@@ -1,2 +0,0 @@
-export * from './async-validation';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/index.js

@@ -1,2 +0,0 @@
-export * from './async-validation';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/async-validation/types.d.ts

@@ -1,34 +0,0 @@
-import type { MutableState, Tools } from 'final-form';
-import type { FieldValue, JsonSchema, SyncValidateError, Validator } from '../../../types';
-export interface AsyncValidationWaiter {
-    schema: JsonSchema;
-    validator: Validator<JsonSchema>;
-    value: FieldValue;
-}
-export interface AsyncValidationCache extends AsyncValidationWaiter {
-    result: SyncValidateError;
-}
-export interface AsyncValidationState {
-    cache?: {
-        [key: string]: AsyncValidationCache[] | undefined;
-    };
-    waiters?: {
-        [key: string]: AsyncValidationWaiter | undefined;
-    };
-}
-export interface SetAsyncValidationWaitersParams {
-    headName: string;
-    waiters: {
-        [key: string]: AsyncValidationWaiter;
-    };
-}
-export type SetAsyncValidationWaitersFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationWaitersParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type SetAsyncValidationWaitersMutator = (params: SetAsyncValidationWaitersParams) => void;
-export interface SetAsyncValidationCacheParams {
-    cache: {
-        [key: string]: AsyncValidationCache;
-    };
-    headName: string;
-}
-export type SetAsyncValidationCacheFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetAsyncValidationCacheParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type SetAsyncValidationCacheMutator = (params: SetAsyncValidationCacheParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.d.ts

@@ -1,3 +0,0 @@
-import type { RemoveExternalErrorsFunction, SetExternalErrorsFunction } from './types';
-export declare const setExternalErrors: SetExternalErrorsFunction;
-export declare const removeExternalErrors: RemoveExternalErrorsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/external-errors.js

@@ -1,54 +0,0 @@
-import omit from 'lodash/omit';
-import { ENTITY_SERVICE_FIELD } from '../../constants';
-import { guessHeadName } from '../../utils';
-export const setExternalErrors = ([{ priorityErrors, regularErrors }], mutableState) => {
-    const registeredFields = Object.keys(mutableState.fields);
-    Object.entries(priorityErrors || {}).forEach(([key, value]) => {
-        const headName = guessHeadName(registeredFields, key);
-        if (headName) {
-            const field = mutableState.fields[headName];
-            if (field) {
-                field.data = Object.assign(Object.assign({}, field.data), { priorityErrors: Object.assign(Object.assign({}, field.data.priorityErrors), { [key]: value }) });
-            }
-        }
-    });
-    Object.entries(regularErrors || {}).forEach(([key, value]) => {
-        const headName = guessHeadName(registeredFields, key);
-        if (headName) {
-            const field = mutableState.fields[headName];
-            if (field) {
-                field.data = Object.assign(Object.assign({}, field.data), { regularErrors: Object.assign(Object.assign({}, field.data.regularErrors), { [key]: value }) });
-            }
-        }
-    });
-};
-export const removeExternalErrors = ([{ removeFunctionOrNames }], mutableState) => {
-    const registeredFields = Object.keys(mutableState.fields);
-    if (Array.isArray(removeFunctionOrNames)) {
-        removeFunctionOrNames.forEach((name) => {
-            const headName = guessHeadName(registeredFields, name);
-            if (headName) {
-                const field = mutableState.fields[headName];
-                if (field) {
-                    field.data = Object.assign(Object.assign({}, field.data), { priorityErrors: omit(Object.assign({}, field.data.priorityErrors), name), regularErrors: omit(Object.assign({}, field.data.regularErrors), name) });
-                }
-            }
-        });
-    }
-    else {
-        registeredFields.forEach((fieldName) => {
-            if (fieldName.startsWith(ENTITY_SERVICE_FIELD)) {
-                const headName = fieldName.slice(`${ENTITY_SERVICE_FIELD}.`.length);
-                const field = mutableState.fields[headName];
-                if (field) {
-                    const { priorityErrors, regularErrors } = removeFunctionOrNames(headName, {
-                        priorityErrors: field.data.priorityErrors,
-                        regularErrors: field.data.regularErrors,
-                    });
-                    field.data = Object.assign(Object.assign({}, field.data), { priorityErrors,
-                        regularErrors });
-                }
-            }
-        });
-    }
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.d.ts

@@ -1,2 +0,0 @@
-export * from './external-errors';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/index.js

@@ -1,2 +0,0 @@
-export * from './external-errors';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/external-errors/types.d.ts

@@ -1,25 +0,0 @@
-import type { MutableState, Tools } from 'final-form';
-import type { SyncValidateError } from '../../../types';
-export interface ExternalErrorsState {
-    priorityErrors?: {
-        [key: string]: SyncValidateError;
-    };
-    regularErrors?: {
-        [key: string]: SyncValidateError;
-    };
-}
-export interface SetExternalErrorsParams {
-    priorityErrors?: {
-        [key: string]: SyncValidateError;
-    };
-    regularErrors?: {
-        [key: string]: SyncValidateError;
-    };
-}
-export type SetExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type SetExternalErrorsMutator = (params: SetExternalErrorsParams) => void;
-export interface RemoveExternalErrorsParams {
-    removeFunctionOrNames: string[] | ((headName: string, state: ExternalErrorsState) => ExternalErrorsState);
-}
-export type RemoveExternalErrorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveExternalErrorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type RemoveExternalErrorsMutator = (params: RemoveExternalErrorsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/index.d.ts

@@ -1,13 +0,0 @@
-export type * from './async-validation';
-export type * from './external-errors';
-export type * from './schema-mutators';
-export type * from './trigger-fields';
-export declare const schemaRendererMutators: {
-    removeExternalErrors: import("./external-errors").RemoveExternalErrorsFunction;
-    removeSchemaMutators: import("./schema-mutators").RemoveSchemaMutatorsFunction;
-    setAsyncValidationCache: import("./async-validation").SetAsyncValidationCacheFunction;
-    setAsyncValidationWaiters: import("./async-validation").SetAsyncValidationWaitersFunction;
-    setExternalErrors: import("./external-errors").SetExternalErrorsFunction;
-    setSchemaMutators: import("./schema-mutators").SetSchemaMutatorsFunction;
-    triggerFields: import("./trigger-fields").TriggerFieldsFunction;
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/index.js

@@ -1,13 +0,0 @@
-import { setAsyncValidationCache, setAsyncValidationWaiters } from './async-validation';
-import { removeExternalErrors, setExternalErrors } from './external-errors';
-import { removeSchemaMutators, setSchemaMutators } from './schema-mutators';
-import { triggerFields } from './trigger-fields';
-export const schemaRendererMutators = {
-    removeExternalErrors,
-    removeSchemaMutators,
-    setAsyncValidationCache,
-    setAsyncValidationWaiters,
-    setExternalErrors,
-    setSchemaMutators,
-    triggerFields,
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/index.d.ts

@@ -1,2 +0,0 @@
-export * from './schema-mutators';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/index.js

@@ -1,2 +0,0 @@
-export * from './schema-mutators';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.d.ts

@@ -1,3 +0,0 @@
-import type { RemoveSchemaMutatorsFunction, SetSchemaMutatorsFunction } from './types';
-export declare const setSchemaMutators: SetSchemaMutatorsFunction;
-export declare const removeSchemaMutators: RemoveSchemaMutatorsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/schema-mutators.js

@@ -1,75 +0,0 @@
-import cloneDeep from 'lodash/cloneDeep';
-import get from 'lodash/get';
-import isEqual from 'lodash/isEqual';
-import { getSchemaPath, getValuePaths, parseSchemaPath, smartSet } from '../../../utils';
-import { guessHeadName } from '../../utils';
-const applyMutators = ({ mutableState, mutators, }) => {
-    const registeredFields = Object.keys(mutableState.fields);
-    mutators.forEach((m) => {
-        const headName = guessHeadName(registeredFields, m.name);
-        if (headName) {
-            const headField = mutableState.fields[headName];
-            const data = headField === null || headField === void 0 ? void 0 : headField.data;
-            const mutatedSchema = data === null || data === void 0 ? void 0 : data.schema;
-            if (mutatedSchema) {
-                const schemaPath = getSchemaPath(m.name, headName, mutatedSchema);
-                if (schemaPath) {
-                    smartSet(mutatedSchema, schemaPath, m.schema);
-                    const schemaField = mutableState.fields[m.name];
-                    if (schemaField) {
-                        schemaField.data = Object.assign(Object.assign({}, schemaField.data), { schema: get(mutatedSchema, schemaPath) });
-                    }
-                    headField.data.mutators = [...((data === null || data === void 0 ? void 0 : data.mutators) || []), m];
-                    headField.data.schema = mutatedSchema;
-                    const mutatedPaths = getValuePaths(m.schema).map((path) => [
-                        ...schemaPath,
-                        ...path,
-                    ]);
-                    Object.values(mutableState.fields).forEach((field) => {
-                        var _a;
-                        const data = field === null || field === void 0 ? void 0 : field.data;
-                        if (((_a = data === null || data === void 0 ? void 0 : data.schema) === null || _a === void 0 ? void 0 : _a.$ref) && (data === null || data === void 0 ? void 0 : data.headName) === headName) {
-                            const refPath = parseSchemaPath(data.schema.$ref);
-                            const mutationAffectRefSchema = mutatedPaths.some((mutatedPath) => refPath.every((subpath, index) => mutatedPath[index] === subpath));
-                            const fieldSchemaPath = getSchemaPath(field.name, headName, mutatedSchema);
-                            if (mutationAffectRefSchema && fieldSchemaPath) {
-                                field.data = Object.assign(Object.assign({}, field.data), { schema: Object.assign({}, get(mutatedSchema, fieldSchemaPath)) });
-                            }
-                        }
-                    });
-                }
-            }
-        }
-    });
-};
-export const setSchemaMutators = ([{ mutators }], mutableState) => {
-    applyMutators({ mutableState, mutators });
-};
-export const removeSchemaMutators = ([{ mutatorsToRemove }], mutableState) => {
-    const registeredFields = Object.keys(mutableState.fields);
-    [...new Set(mutatorsToRemove.map((m) => guessHeadName(registeredFields, m.name)))].forEach((name) => {
-        if (name) {
-            const headField = mutableState.fields[name];
-            const data = headField === null || headField === void 0 ? void 0 : headField.data;
-            const originalSchema = data === null || data === void 0 ? void 0 : data.originalSchema;
-            const mutators = (data === null || data === void 0 ? void 0 : data.mutators) || [];
-            if (headField && originalSchema) {
-                applyMutators({
-                    mutableState,
-                    mutators: mutators.map((m) => {
-                        const schemaPath = getSchemaPath(m.name, name, originalSchema);
-                        return Object.assign(Object.assign({}, m), { schema: schemaPath
-                                ? cloneDeep(get(originalSchema, schemaPath))
-                                : {} });
-                    }),
-                });
-                headField.data.mutators = [];
-                applyMutators({
-                    mutableState,
-                    mutators: mutators.filter((m) => !mutatorsToRemove.some(({ name, schema }) => name === m.name &&
-                        (isEqual(m.schema, schema) || schema === true))),
-                });
-            }
-        }
-    });
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/schema-mutators/types.d.ts

@@ -1,26 +0,0 @@
-import type { MutableState, Tools } from 'final-form';
-import type { JsonSchema } from '../../../types';
-export interface SchemaMutatorsState {
-    mutators?: {
-        name: string;
-        schema: JsonSchema;
-    }[];
-    originalSchema?: JsonSchema;
-    schema?: JsonSchema;
-}
-export interface SetSchemaMutatorsParams {
-    mutators: {
-        name: string;
-        schema: JsonSchema;
-    }[];
-}
-export type SetSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [SetSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type SetSchemaMutatorsMutator = (params: SetSchemaMutatorsParams) => void;
-export interface RemoveSchemaMutatorsParams {
-    mutatorsToRemove: {
-        name: string;
-        schema: JsonSchema | true;
-    }[];
-}
-export type RemoveSchemaMutatorsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [RemoveSchemaMutatorsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type RemoveSchemaMutatorsMutator = (params: RemoveSchemaMutatorsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.d.ts

@@ -1,2 +0,0 @@
-export * from './trigger-fields';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/index.js

@@ -1,2 +0,0 @@
-export * from './trigger-fields';
-export * from './types';

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.d.ts

@@ -1,2 +0,0 @@
-import type { TriggerFieldsFunction } from './types';
-export declare const triggerFields: TriggerFieldsFunction;

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/trigger-fields.js

@@ -1,8 +0,0 @@
-export const triggerFields = ([{ fields }], mutableState) => {
-    fields.forEach((fieldName) => {
-        const field = mutableState.fields[fieldName];
-        if (field) {
-            field.data = Object.assign(Object.assign({}, field.data), { count: (field.data.count || 0) + 1 });
-        }
-    });
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/mutators/trigger-fields/types.d.ts

@@ -1,6 +0,0 @@
-import type { MutableState, Tools } from 'final-form';
-export interface TriggerFieldsParams {
-    fields: string[];
-}
-export type TriggerFieldsFunction<FormValues = object, InitialFormValues = Partial<FormValues>> = (args: [TriggerFieldsParams], state: MutableState<FormValues, InitialFormValues>, tools: Tools<FormValues, InitialFormValues>) => void;
-export type TriggerFieldsMutator = (params: TriggerFieldsParams) => void;

package/build/esm/lib/unstable/core/useSchemaRenderer/types.d.ts

@@ -1,22 +0,0 @@
-import type { ErrorObject } from 'ajv';
-import type { SchemaRendererMode } from '../constants';
-import type { FieldValue, JsonSchema, SchemaRendererConfig, SyncValidateError, Validator } from '../types';
-import type { AsyncValidationState, ExternalErrorsState, SchemaMutatorsState } from './mutators';
-export type EntityParametersError = ErrorObject<'entityParameters', {
-    schema: JsonSchema;
-    validator: Validator<JsonSchema>;
-    value: FieldValue;
-}>;
-export interface ValidateErrorItem {
-    error: SyncValidateError;
-    path: string[];
-}
-export interface EntitiesState {
-    config?: SchemaRendererConfig;
-    errorsRef?: React.RefObject<Record<string, SyncValidateError>>;
-    headName?: string;
-    mode?: SchemaRendererMode;
-    schema?: SchemaMutatorsState['schema'];
-}
-export interface SchemaRendererState extends AsyncValidationState, ExternalErrorsState, SchemaMutatorsState {
-}

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/common.d.ts

@@ -1 +0,0 @@
-export declare const guessHeadName: (registeredFields: string[], name: string) => string | undefined;

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

@@ -1,7 +0,0 @@
-import { ENTITY_SERVICE_FIELD } from '../constants';
-export const guessHeadName = (registeredFields, name) => {
-    const registeredServiceFields = registeredFields
-        .filter((n) => n.startsWith(ENTITY_SERVICE_FIELD))
-        .map((n) => n.slice(`${ENTITY_SERVICE_FIELD}.`.length));
-    return registeredServiceFields.find((n) => name === n || name.startsWith(`${n}.`) || name.startsWith(`${n}[`));
-};

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

@@ -1,11 +0,0 @@
-import type { ErrorObject, ValidateFunction } from 'ajv';
-import type { JsonSchema, SchemaRendererConfig } from '../../types';
-import type { EntityParametersError } from '../types';
-export interface GetAjvValidateParams {
-    config: SchemaRendererConfig;
-    schema: JsonSchema;
-}
-export interface GetAjvValidateReturn extends ValidateFunction {
-    errors?: (ErrorObject | EntityParametersError)[];
-}
-export declare const getAjvValidate: ({ config, schema }: GetAjvValidateParams) => GetAjvValidateReturn;

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

@@ -1,34 +0,0 @@
-import Ajv from 'ajv';
-import get from 'lodash/get';
-export const getAjvValidate = ({ config, schema }) => {
-    function entityParametersValidate(_, value, schema) {
-        if (schema && schema.entityParameters) {
-            const entityType = get(schema, 'entityParameters.type');
-            const validatorType = schema.entityParameters.validatorType;
-            const validator = get(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({
-        allErrors: true,
-        allowMatchingProperties: true,
-        keywords: [
-            {
-                errors: true,
-                keyword: 'entityParameters',
-                validate: entityParametersValidate,
-            },
-        ],
-    });
-    const ajvValidate = ajv.compile(schema);
-    return ajvValidate;
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-error.d.ts

@@ -1,10 +0,0 @@
-import type { ErrorObject } from 'ajv';
-import type { ErrorMessages, JsonSchema } from '../../types';
-import type { ValidateErrorItem } from '../types';
-export interface ProcessAjvErrorParams<Schema extends JsonSchema> {
-    error: ErrorObject;
-    errorMessages: ErrorMessages;
-    schema: Schema;
-    onError: (error: ValidateErrorItem) => void;
-}
-export declare const processAjvError: <Schema extends JsonSchema>({ error, errorMessages, schema, onError, }: ProcessAjvErrorParams<Schema>) => void;

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

@@ -1,46 +0,0 @@
-import get from 'lodash/get';
-import isString from 'lodash/isString';
-import { getSchemaByInstancePath, getSchemaBySchemaPath, parseInstancePath } from '../../utils';
-export 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 = get(schema, `entityParameters.errorMessages.${keyword}`);
-        const message = isString(errorOrMap)
-            ? errorOrMap
-            : get(errorOrMap, propertyName);
-        return message;
-    };
-    onError({
-        path: parseInstancePath(instancePath),
-        error: getErrorMessageBySchema(getSchemaBySchemaPath(schemaPath, schema)) ||
-            getErrorMessageBySchema(getSchemaBySchemaPath(schemaPath.slice(0, -`/${keyword}`.length), schema)) ||
-            getErrorMessageBySchema(getSchemaByInstancePath(instancePath, schema)) ||
-            errorMessages[keyword] ||
-            error.message,
-    });
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-ajv-validate-errors.d.ts

@@ -1,20 +0,0 @@
-import type { ErrorObject } from 'ajv';
-import type { ErrorMessages, JsonSchema, ObjectValue } from '../../types';
-import type { AsyncValidationState, AsyncValidationWaiter, SetAsyncValidationCacheMutator } from '../mutators';
-import type { EntityParametersError, ValidateErrorItem } from '../types';
-export interface ProcessAjvValidateErrorsParams<Schema extends JsonSchema> {
-    ajvValidateErrors: (ErrorObject | EntityParametersError)[];
-    allValues: ObjectValue;
-    errorMessages: ErrorMessages;
-    name: string;
-    schema: Schema;
-    setAsyncValidationCache?: SetAsyncValidationCacheMutator;
-    validationState: AsyncValidationState | undefined;
-}
-interface ProcessAjvValidateErrorsReturn {
-    ajvErrorItems: ValidateErrorItem[];
-    entityParametersErrorItems: ValidateErrorItem[];
-    waiters: Record<string, AsyncValidationWaiter>;
-}
-export declare const processAjvValidateErrors: <Schema extends JsonSchema>({ ajvValidateErrors, allValues, errorMessages, name, schema, setAsyncValidationCache, validationState, }: ProcessAjvValidateErrorsParams<Schema>) => ProcessAjvValidateErrorsReturn;
-export {};

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

@@ -1,39 +0,0 @@
-import { processAjvError } from './process-ajv-error';
-import { processEntityParametersError } from './process-entity-parameters-error';
-export 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;
-            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;
-            processAjvError({
-                error,
-                errorMessages,
-                schema,
-                onError: (e) => ajvErrorItems.push(e),
-            });
-        }
-    });
-    return { ajvErrorItems, entityParametersErrorItems, waiters };
-};

package/build/esm/lib/unstable/core/useSchemaRenderer/utils/process-entity-parameters-error.d.ts

@@ -1,15 +0,0 @@
-import type { AsyncValidateError, ObjectValue } from '../../types';
-import type { AsyncValidationState } from '../mutators';
-import type { EntityParametersError, ValidateErrorItem } from '../types';
-export interface ProcessEntityParametersErrorParams {
-    allValues: ObjectValue;
-    error: EntityParametersError;
-    onAsyncError: (waiter: {
-        instancePath: string;
-        params: EntityParametersError['params'];
-        promise: AsyncValidateError;
-    }) => void;
-    onError: (error: ValidateErrorItem) => void;
-    validationState: AsyncValidationState | undefined;
-}
-export declare const processEntityParametersError: ({ allValues, error, onAsyncError, onError, validationState, }: ProcessEntityParametersErrorParams) => void;