@gravity-ui/dynamic-forms 5.20.0 → 5.21.0

package/build/esm/lib/unstable/core/Entity/Entity.js

@@ -1,74 +0,0 @@
-import React from 'react';
-import { useField } from 'react-final-form';
-import { SchemaRendererMode } from '../constants';
-import { useEntitiesState } from '../useSchemaRenderer';
-import { getSchemaBySchemaPath, smartMerge } from '../utils';
-import { getRenderKit } from './utils';
-const EntityComponent = ({ modeOverride, name, schema: schemaProps = {}, schemaOverride, }) => {
-    var _a, _b;
-    const { config, error, headName, mode: modeState, rootSchema } = useEntitiesState(name);
-    const getAccumulatedSchema = React.useCallback((schema, root, override) => {
-        let accumulatedSchema = schema;
-        if (override) {
-            accumulatedSchema = smartMerge(accumulatedSchema, override);
-        }
-        if (accumulatedSchema.$ref && root) {
-            const schemaByRef = getSchemaBySchemaPath(accumulatedSchema.$ref, root);
-            if (schemaByRef) {
-                accumulatedSchema = smartMerge(accumulatedSchema, schemaByRef);
-            }
-        }
-        return accumulatedSchema;
-    }, []);
-    const options = React.useMemo(() => {
-        const data = { headName, schema: schemaProps };
-        const accumulatedSchema = getAccumulatedSchema(schemaProps, rootSchema, schemaOverride);
-        return {
-            data,
-            defaultValue: accumulatedSchema.default,
-            subscription: {
-                data: true,
-                submitFailed: true,
-                touched: true,
-                validating: true,
-                value: true,
-            },
-        };
-    }, [headName, getAccumulatedSchema, rootSchema, schemaOverride, schemaProps]);
-    const field = useField(name, options);
-    const meta = React.useMemo(() => (Object.assign(Object.assign({}, field.meta), { error })), [field.meta, error]);
-    const schema = React.useMemo(() => { var _a; return getAccumulatedSchema((_a = field.meta.data) === null || _a === void 0 ? void 0 : _a.schema, rootSchema, schemaOverride); }, [(_a = field.meta.data) === null || _a === void 0 ? void 0 : _a.schema, schemaOverride, getAccumulatedSchema, rootSchema]);
-    const mode = modeOverride || ((_b = field.meta.data) === null || _b === void 0 ? void 0 : _b.mode) || modeState;
-    const renderKit = React.useMemo(() => getRenderKit({ config, schema }), [config, schema]);
-    let content = null;
-    if (mode === SchemaRendererMode.Form) {
-        const formKit = renderKit[SchemaRendererMode.Form];
-        if (formKit.Component) {
-            if (formKit.independent) {
-                content = (React.createElement(formKit.Component, { input: field.input, meta: meta, schema: schema, controlProps: formKit.props, Wrapper: formKit.Wrapper, wrapperProps: formKit.wrapperProps }));
-            }
-            else {
-                content = (React.createElement(formKit.Component, { input: field.input, meta: meta, schema: schema, controlProps: formKit.props }));
-                if (formKit.Wrapper) {
-                    content = (React.createElement(formKit.Wrapper, { input: field.input, meta: meta, schema: schema, wrapperProps: formKit.wrapperProps }, content));
-                }
-            }
-        }
-    }
-    if (mode === SchemaRendererMode.Overview) {
-        const overviewKit = renderKit[SchemaRendererMode.Overview];
-        if (overviewKit.Component) {
-            if (overviewKit.independent) {
-                content = (React.createElement(overviewKit.Component, { input: field.input, meta: meta, schema: schema, viewProps: overviewKit.props, Wrapper: overviewKit.Wrapper, wrapperProps: overviewKit.wrapperProps }));
-            }
-            else {
-                content = (React.createElement(overviewKit.Component, { input: field.input, meta: meta, schema: schema, viewProps: overviewKit.props }));
-                if (overviewKit.Wrapper) {
-                    content = (React.createElement(overviewKit.Wrapper, { input: field.input, meta: meta, schema: schema, wrapperProps: overviewKit.wrapperProps }, content));
-                }
-            }
-        }
-    }
-    return content;
-};
-export const Entity = React.memo(EntityComponent);

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

@@ -1,3 +0,0 @@
-export { Entity, type EntityProps } from './Entity';
-export type { EntityState } from './types';
-export { getRenderKit } from './utils';

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

@@ -1,2 +0,0 @@
-export { Entity } from './Entity';
-export { getRenderKit } from './utils';

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

@@ -1,27 +0,0 @@
-import type { SchemaRendererMode } from '../constants';
-import type { Control, JsonSchema, SchemaRendererConfig, View, Wrapper } from '../types';
-export type GetRenderKitParams<Schema extends JsonSchema> = {
-    config?: SchemaRendererConfig;
-    schema: Schema;
-};
-export type GetRenderKitReturn<Schema extends JsonSchema> = {
-    [SchemaRendererMode.Form]: {
-        Component: Control<Schema> | undefined;
-        props: Record<string, any>;
-        independent: boolean | undefined;
-        Wrapper: Wrapper<Schema> | undefined;
-        wrapperProps: Record<string, any>;
-    };
-    [SchemaRendererMode.Overview]: {
-        Component: View<Schema> | undefined;
-        props: Record<string, any>;
-        independent: boolean | undefined;
-        Wrapper: Wrapper<Schema> | undefined;
-        wrapperProps: Record<string, any>;
-    };
-};
-export interface EntityState<Schema extends JsonSchema = JsonSchema> {
-    headName?: string;
-    mode?: SchemaRendererMode;
-    schema?: Schema;
-}

package/build/esm/lib/unstable/core/Entity/utils.d.ts

@@ -1,3 +0,0 @@
-import type { JsonSchema } from '../types';
-import type { GetRenderKitParams, GetRenderKitReturn } from './types';
-export declare const getRenderKit: <Schema extends JsonSchema>({ config, schema, }: GetRenderKitParams<Schema>) => GetRenderKitReturn<Schema>;

package/build/esm/lib/unstable/core/Entity/utils.js

@@ -1,35 +0,0 @@
-import get from 'lodash/get';
-import { EMPTY_OBJECT, SchemaRendererMode } from '../constants';
-export const getRenderKit = ({ config, schema, }) => {
-    const entityType = get(schema, 'entityParameters.type');
-    const controlType = get(schema, 'entityParameters.controlType');
-    const ControlComponent = get(config, `${entityType}.controls.${controlType}.Component`);
-    const controlProps = get(schema, 'entityParameters.controlProps') || EMPTY_OBJECT;
-    const controlIndependent = get(config, `${entityType}.controls.${controlType}.independent`);
-    const controlWrapperType = get(schema, 'entityParameters.controlWrapperType');
-    const ControlWrapperComponent = get(config, `${entityType}.wrappers.${controlWrapperType}`);
-    const controlWrapperProps = get(schema, 'entityParameters.controlWrapperProps') || EMPTY_OBJECT;
-    const viewType = get(schema, 'entityParameters.viewType');
-    const ViewComponent = get(config, `${entityType}.views.${viewType}`);
-    const viewProps = get(schema, 'entityParameters.viewProps') || EMPTY_OBJECT;
-    const viewIndependent = get(config, `${entityType}.views.${viewType}.independent`);
-    const viewWrapperType = get(schema, 'entityParameters.viewWrapperType');
-    const ViewWrapperComponent = get(config, `${entityType}.wrappers.${viewWrapperType}`);
-    const viewWrapperProps = get(schema, 'entityParameters.viewWrapperProps') || EMPTY_OBJECT;
-    return {
-        [SchemaRendererMode.Form]: {
-            Component: ControlComponent,
-            props: controlProps,
-            independent: controlIndependent,
-            Wrapper: ControlWrapperComponent,
-            wrapperProps: controlWrapperProps,
-        },
-        [SchemaRendererMode.Overview]: {
-            Component: ViewComponent,
-            props: viewProps,
-            independent: viewIndependent,
-            Wrapper: ViewWrapperComponent,
-            wrapperProps: viewWrapperProps,
-        },
-    };
-};

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

@@ -1,2 +0,0 @@
-export { useEntitiesState } from './useEntitiesState';
-export { useSchemaRendererMutators } from './useSchemaRendererMutators';

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

@@ -1,2 +0,0 @@
-export { useEntitiesState } from './useEntitiesState';
-export { useSchemaRendererMutators } from './useSchemaRendererMutators';

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

@@ -1,7 +0,0 @@
-export declare const useEntitiesState: (name: string) => {
-    config: import("../..").SchemaRendererConfig | undefined;
-    error: import("../..").SyncValidateError;
-    headName: string | undefined;
-    mode: import("../..").SchemaRendererMode | undefined;
-    rootSchema: import("../..").JsonSchema | undefined;
-};

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;