@gravity-ui/dynamic-forms 3.2.0 → 3.3.0

package/build/esm/lib/core/components/Form/Controller/types.d.ts

@@ -0,0 +1,98 @@
+/// <reference types="react" />
+import { FormValue, Spec } from '../../../types';
+import { DynamicFormConfig, DynamicFormMutators, DynamicFormsContext, FieldRenderProps, FieldValue, IndependentInputEntity, InputEntity, LayoutType, ValidateError } from '../types';
+export interface GetSpecParams<SpecType extends Spec> {
+    name: string;
+    spec: SpecType;
+    mutators: DynamicFormMutators;
+}
+export interface GetComponentsParams<SpecType extends Spec> {
+    spec: SpecType;
+    config: DynamicFormConfig;
+}
+export interface GetComponentsReturn<DirtyValue extends FieldValue, SpecType extends Spec> {
+    inputEntity?: InputEntity<DirtyValue, SpecType> | IndependentInputEntity<DirtyValue, SpecType>;
+    Layout?: LayoutType<DirtyValue, SpecType>;
+}
+export interface GetRenderParams<DirtyValue extends FieldValue, SpecType extends Spec> {
+    name: string;
+    spec: SpecType;
+    inputEntity?: InputEntity<DirtyValue, SpecType> | IndependentInputEntity<DirtyValue, SpecType>;
+    Layout?: LayoutType<DirtyValue, SpecType>;
+}
+export interface GetValidateParams<SpecType extends Spec> {
+    spec: SpecType;
+    config: DynamicFormConfig;
+}
+export interface GetFieldInitialsParams<DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec> {
+    name: string;
+    spec: SpecType;
+    valueFromParent: DirtyValue;
+    initialValue: DirtyValue;
+    validate: (value?: Value) => ValidateError;
+    mutators: DynamicFormMutators;
+}
+export type FieldMethod<DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec, Params extends any = undefined> = (store: ControllerStore<DirtyValue, Value, SpecType>, params: Params) => ControllerStore<DirtyValue, Value, SpecType>;
+export interface GetFieldMethodsReturn<DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec> {
+    onChange: FieldMethod<DirtyValue, Value, SpecType, {
+        valOrSetter: DirtyValue | ((currentValue: DirtyValue) => DirtyValue);
+        childErrors?: Record<string, ValidateError>;
+        errorMutator?: ValidateError;
+    }>;
+    onDrop: FieldMethod<DirtyValue, Value, SpecType>;
+    onBlur: FieldMethod<DirtyValue, Value, SpecType>;
+    onFocus: FieldMethod<DirtyValue, Value, SpecType>;
+    parentOnUnmount: FieldMethod<DirtyValue, Value, SpecType, string>;
+    onItemAdd: FieldMethod<DirtyValue, Value, SpecType, FieldValue>;
+    onItemRemove: FieldMethod<DirtyValue, Value, SpecType, number | string>;
+}
+export interface InitializeStoreParams<DirtyValue extends FieldValue, SpecType extends Spec> {
+    name: string;
+    spec: SpecType;
+    mutators: DynamicFormMutators;
+    config: DynamicFormConfig;
+    valueFromParent: DirtyValue;
+    tools: DynamicFormsContext['tools'];
+    parentOnChange: ((childName: string, childValue: FieldValue, childErrors: Record<string, ValidateError>) => void) | null;
+    parentOnUnmount: ((childName: string) => void) | null;
+}
+export interface ControllerStore<DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec> {
+    name: string;
+    spec: SpecType;
+    initialSpec: SpecType;
+    config: DynamicFormConfig;
+    tools: DynamicFormsContext['tools'];
+    mutators: DynamicFormMutators;
+    render: (props: FieldRenderProps<DirtyValue>) => JSX.Element | null;
+    validate: (value?: Value) => ValidateError;
+    parentOnChange: ((childName: string, childValue: FieldValue, childErrors: Record<string, ValidateError>) => void) | null;
+    parentOnUnmount: ((childName: string) => void) | null;
+    state: {
+        initialValue: DirtyValue;
+        active: boolean;
+        dirty: boolean;
+        error: ValidateError;
+        invalid: boolean;
+        modified: boolean;
+        pristine: boolean;
+        touched: boolean;
+        valid: boolean;
+        value: DirtyValue;
+        visited: boolean;
+        childErrors: Record<string, ValidateError>;
+    };
+    afterStoreUpdateCB?: () => void;
+}
+export interface UpdateStoreParams<DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec> {
+    store: ControllerStore<DirtyValue, Value, SpecType>;
+    setStore: (store: ControllerStore<DirtyValue, Value, SpecType>) => void;
+    spec: SpecType;
+    name: string;
+    parentOnChange: ((childName: string, childValue: FieldValue, childErrors: Record<string, ValidateError>) => void) | null;
+    parentOnUnmount: ((childName: string) => void) | null;
+    mutators: DynamicFormMutators;
+    valueFromParent: DirtyValue;
+    config: DynamicFormConfig;
+    tools: DynamicFormsContext['tools'];
+    methodOnChange: GetFieldMethodsReturn<DirtyValue, Value, SpecType>['onChange'];
+}

package/build/esm/lib/core/components/Form/Controller/types.js

@@ -0,0 +1 @@
+export {};

package/build/esm/lib/core/components/Form/Controller/utils.d.ts

@@ -0,0 +1,26 @@
+import { FormValue, Spec } from '../../../types';
+import { FieldRenderProps, FieldValue, ValidateError } from '../types';
+import { ControllerStore, GetComponentsParams, GetComponentsReturn, GetFieldInitialsParams, GetFieldMethodsReturn, GetRenderParams, GetSpecParams, GetValidateParams, InitializeStoreParams, UpdateStoreParams } from './types';
+export declare const updateParentStore: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>(store: ControllerStore<DirtyValue, Value, SpecType>) => void;
+export declare const callUnmout: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>(store: ControllerStore<DirtyValue, Value, SpecType>) => void;
+export declare const getSpec: <SpecType extends Spec>({ name, spec, mutators, }: GetSpecParams<SpecType>) => SpecType;
+export declare const getComponents: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ spec, config, }: GetComponentsParams<SpecType>) => GetComponentsReturn<DirtyValue, SpecType>;
+export declare const getRender: <DirtyValue extends FieldValue, SpecType extends Spec>({ name, spec, inputEntity, Layout, }: GetRenderParams<DirtyValue, SpecType>) => (props: FieldRenderProps<DirtyValue>) => JSX.Element | null;
+export declare const getValidate: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ spec, config, }: GetValidateParams<SpecType>) => (value?: Value | undefined) => ValidateError;
+export declare const getFieldInitials: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ name, spec, valueFromParent, initialValue, validate, mutators, }: GetFieldInitialsParams<DirtyValue, Value, SpecType>) => {
+    initialValue: DirtyValue;
+    active: boolean;
+    dirty: boolean;
+    error: string | boolean | import("../types").AsyncValidateError | undefined;
+    invalid: boolean;
+    modified: boolean;
+    pristine: boolean;
+    touched: boolean;
+    valid: boolean;
+    value: DirtyValue;
+    visited: boolean;
+    childErrors: {};
+};
+export declare const getFieldMethods: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>() => GetFieldMethodsReturn<DirtyValue, Value, SpecType>;
+export declare const initializeStore: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ name, spec: _spec, mutators, config, valueFromParent, tools, parentOnChange, parentOnUnmount, }: InitializeStoreParams<DirtyValue, SpecType>) => ControllerStore<DirtyValue, Value, SpecType>;
+export declare const updateStore: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ store, setStore, spec: _spec, name, parentOnChange, parentOnUnmount, mutators, valueFromParent, config, tools, methodOnChange, }: UpdateStoreParams<DirtyValue, Value, SpecType>) => void;

package/build/esm/lib/core/components/Form/Controller/utils.js

@@ -0,0 +1,291 @@
+import React from 'react';
+import _ from 'lodash';
+import { isValidElementType } from 'react-is';
+import { SpecTypes } from '../../../constants';
+import { isArraySpec, isCorrectSpec, isNumberSpec, isObjectSpec } from '../../../helpers';
+import { EMPTY_MUTATOR, OBJECT_ARRAY_CNT, OBJECT_ARRAY_FLAG } from '../constants';
+import { isArrayItem, isCorrectConfig, transformArrIn, transformArrOut } from '../utils';
+const isErrorMutatorCorrect = (errorMutator) => errorMutator !== EMPTY_MUTATOR && (_.isString(errorMutator) || _.isBoolean(errorMutator));
+const isValueMutatorCorrect = (valueMutator, spec) => valueMutator !== EMPTY_MUTATOR &&
+    (typeof valueMutator === spec.type ||
+        (_.isArray(valueMutator) && spec.type === SpecTypes.Array));
+export const updateParentStore = (store) => {
+    (store.parentOnChange ? store.parentOnChange : store.tools.onChange)(store.name, store.state.value, Object.assign(Object.assign({}, store.state.childErrors), { [store.name]: store.state.error }));
+};
+export const callUnmout = (store) => {
+    (store.parentOnUnmount ? store.parentOnUnmount : store.tools.onUnmount)(store.name);
+};
+export const getSpec = ({ name, spec, mutators, }) => {
+    const mutator = _.get(mutators.spec, name, EMPTY_MUTATOR);
+    if (mutator !== EMPTY_MUTATOR) {
+        const mutatedSpec = _.merge(_.cloneDeep(spec), mutator);
+        if (isCorrectSpec(mutatedSpec)) {
+            return mutatedSpec;
+        }
+    }
+    return spec;
+};
+export const getComponents = ({ spec, config, }) => {
+    const result = {};
+    if (isCorrectConfig(config) && isCorrectSpec(spec)) {
+        const { inputs, layouts } = config[spec.type];
+        if (inputs) {
+            const entity = inputs[spec.viewSpec.type];
+            if (isValidElementType(entity === null || entity === void 0 ? void 0 : entity.Component)) {
+                result.inputEntity = entity;
+            }
+        }
+        if (layouts && _.isString(spec.viewSpec.layout)) {
+            const Component = layouts[spec.viewSpec.layout];
+            if (isValidElementType(Component)) {
+                result.Layout = Component;
+            }
+        }
+    }
+    return result;
+};
+export const getRender = ({ name, spec, inputEntity, Layout, }) => {
+    const render = (props) => {
+        if (inputEntity && isCorrectSpec(spec) && _.isString(name)) {
+            if (!spec.viewSpec.hidden) {
+                if (inputEntity.independent) {
+                    const InputComponent = inputEntity.Component;
+                    return React.createElement(InputComponent, Object.assign({ spec: spec, name: name, Layout: Layout }, props));
+                }
+                const InputComponent = inputEntity.Component;
+                const input = React.createElement(InputComponent, Object.assign({ spec: spec, name: name }, props));
+                if (Layout) {
+                    return (React.createElement(Layout, Object.assign({ spec: spec, name: name }, props), input));
+                }
+                return input;
+            }
+        }
+        return null;
+    };
+    return render;
+};
+export const getValidate = ({ spec, config, }) => {
+    let validate = () => undefined;
+    if (isCorrectConfig(config) && isCorrectSpec(spec)) {
+        const { validators } = config[spec.type];
+        if (validators) {
+            if ((!_.isString(spec.validator) || !spec.validator.length) &&
+                _.isFunction(validators.base)) {
+                validate = (value) => validators.base(spec, value);
+            }
+            if (_.isString(spec.validator) && _.isFunction(validators[spec.validator])) {
+                validate = (value) => validators[spec.validator](spec, value);
+            }
+        }
+    }
+    return validate;
+};
+export const getFieldInitials = ({ name, spec, valueFromParent, initialValue, validate, mutators, }) => {
+    const valueMutator = transformArrIn(_.get(mutators.values, name, EMPTY_MUTATOR));
+    let value = _.cloneDeep(valueFromParent);
+    if (isValueMutatorCorrect(valueMutator, spec)) {
+        value = valueMutator;
+    }
+    if (_.isNil(value)) {
+        if (spec.defaultValue) {
+            value = transformArrIn(spec.defaultValue);
+        }
+        // if the spec with type array or object, and this spec has "required === true",
+        // we immediately exclude empty value
+        else if (spec.required) {
+            if (isArraySpec(spec)) {
+                value = { [OBJECT_ARRAY_FLAG]: true, [OBJECT_ARRAY_CNT]: 0 };
+            }
+            else if (isObjectSpec(spec)) {
+                value = {};
+            }
+        }
+    }
+    let errorMutator = _.get(mutators.errors, name, EMPTY_MUTATOR);
+    if (!isErrorMutatorCorrect(errorMutator)) {
+        errorMutator = undefined;
+    }
+    const error = (validate === null || validate === void 0 ? void 0 : validate(transformArrOut(value))) || errorMutator;
+    const dirty = !_.isEqual(value, initialValue);
+    return {
+        initialValue,
+        active: false,
+        dirty,
+        error,
+        invalid: Boolean(error),
+        modified: dirty,
+        pristine: true,
+        touched: false,
+        valid: !error,
+        value,
+        visited: false,
+        childErrors: {},
+    };
+};
+export const getFieldMethods = () => {
+    const onChange = (store, { valOrSetter, childErrors, errorMutator }) => {
+        const { state, validate, spec } = store;
+        const _value = _.isFunction(valOrSetter) ? valOrSetter(state.value) : valOrSetter;
+        const error = (validate === null || validate === void 0 ? void 0 : validate(transformArrOut(_value))) || errorMutator;
+        let value = transformArrIn(_value);
+        if (isNumberSpec(spec) && !error) {
+            value = (value ? Number(value) : undefined);
+        }
+        let newChildErrors = Object.assign({}, state.childErrors);
+        if (childErrors) {
+            const nearestChildName = _.keys(childErrors).sort((a, b) => a.length - b.length)[0];
+            if (nearestChildName) {
+                const existingСhildNames = _.keys(newChildErrors).filter((childName) => childName.startsWith(nearestChildName));
+                newChildErrors = Object.assign(Object.assign({}, _.omit(newChildErrors, existingСhildNames)), childErrors);
+            }
+        }
+        const nextStore = Object.assign(Object.assign({}, store), { state: Object.assign(Object.assign({}, store.state), { dirty: !_.isEqual(value, state.initialValue), error, invalid: Boolean(error), modified: true, pristine: value === state.initialValue, touched: true, valid: !error, value, visited: true, childErrors: newChildErrors }) });
+        nextStore.afterStoreUpdateCB = () => updateParentStore(nextStore);
+        return nextStore;
+    };
+    const onDrop = (store) => {
+        const { name } = store;
+        if (isArrayItem(name)) {
+            const afterStoreUpdateCB = () => callUnmout(store);
+            return Object.assign(Object.assign({}, store), { afterStoreUpdateCB });
+        }
+        return onChange(store, {
+            valOrSetter: undefined,
+            childErrors: { [name]: false },
+        });
+    };
+    const onBlur = (store) => {
+        return Object.assign(Object.assign({}, store), { state: Object.assign(Object.assign({}, store.state), { active: false, touched: true }) });
+    };
+    const onFocus = (store) => {
+        return Object.assign(Object.assign({}, store), { state: Object.assign(Object.assign({}, store.state), { active: true, visited: true }) });
+    };
+    const parentOnUnmount = (store, childName) => {
+        const { name, spec } = store;
+        if (isArraySpec(spec) || isObjectSpec(spec)) {
+            return onChange(store, {
+                valOrSetter: (currentValue) => currentValue
+                    ? _.omit(currentValue, childName.split(`${name}.`)[1])
+                    : currentValue,
+                childErrors: { [childName]: false },
+            });
+        }
+        return store;
+    };
+    const onItemAdd = (store, _value) => {
+        const { validate, state } = store;
+        const stateValue = (state.value || {
+            [OBJECT_ARRAY_FLAG]: true,
+            [OBJECT_ARRAY_CNT]: 0,
+        });
+        const value = Object.assign(Object.assign({}, stateValue), { [`<${stateValue[OBJECT_ARRAY_CNT]}>`]: transformArrIn(_value), [OBJECT_ARRAY_CNT]: stateValue[OBJECT_ARRAY_CNT] + 1 });
+        const error = validate === null || validate === void 0 ? void 0 : validate(transformArrOut(value));
+        const nextStore = Object.assign(Object.assign({}, store), { state: Object.assign(Object.assign({}, store.state), { dirty: !_.isEqual(value, store.state.initialValue), error, invalid: Boolean(error), modified: true, pristine: value === store.state.initialValue, touched: true, valid: !error, value, visited: true }) });
+        nextStore.afterStoreUpdateCB = () => updateParentStore(nextStore);
+        return nextStore;
+    };
+    const onItemRemove = (store, idx) => {
+        return parentOnUnmount(store, `${store.name}.<${idx}>`);
+    };
+    return {
+        onChange,
+        onDrop,
+        onBlur,
+        onFocus,
+        parentOnUnmount,
+        onItemAdd,
+        onItemRemove,
+    };
+};
+export const initializeStore = ({ name, spec: _spec, mutators, config, valueFromParent, tools, parentOnChange, parentOnUnmount, }) => {
+    const spec = getSpec({ name, spec: _spec, mutators });
+    const components = getComponents({ spec, config });
+    const render = getRender(Object.assign({ name, spec }, components));
+    const validate = getValidate({ spec, config });
+    const state = getFieldInitials({
+        name,
+        spec,
+        valueFromParent,
+        validate,
+        mutators,
+        initialValue: _.get(tools.initialValue, name),
+    });
+    const initialsStore = {
+        name,
+        spec,
+        initialSpec: _spec,
+        config,
+        tools,
+        mutators,
+        render,
+        validate,
+        parentOnChange,
+        parentOnUnmount,
+        state,
+    };
+    if (!_.isEqual(valueFromParent, state.value) || state.error) {
+        initialsStore.afterStoreUpdateCB = () => updateParentStore(initialsStore);
+    }
+    return initialsStore;
+};
+export const updateStore = ({ store, setStore, spec: _spec, name, parentOnChange, parentOnUnmount, mutators, valueFromParent, config, tools, methodOnChange, }) => {
+    const storeSpecMutator = _.get(store.mutators.spec, store.name, EMPTY_MUTATOR);
+    const storeValueMutator = _.get(store.mutators.values, store.name, EMPTY_MUTATOR);
+    const storeErrorMutator = _.get(store.mutators.errors, store.name, EMPTY_MUTATOR);
+    const specMutator = _.get(mutators.errors, name, EMPTY_MUTATOR);
+    const valueMutator = _.get(mutators.values, name, EMPTY_MUTATOR);
+    const errorMutator = _.get(mutators.errors, name, EMPTY_MUTATOR);
+    const valueMutatorUpdated = isValueMutatorCorrect(valueMutator, getSpec({ name, spec: _spec, mutators })) &&
+        valueMutator !== storeValueMutator;
+    const errorMutatorUpdated = isErrorMutatorCorrect(errorMutator) && errorMutator !== storeErrorMutator;
+    const updateState = valueMutatorUpdated || errorMutatorUpdated;
+    const updateNonCritical = parentOnChange !== store.parentOnChange ||
+        parentOnUnmount !== store.parentOnUnmount ||
+        tools.onChange !== store.tools.onChange ||
+        tools.onUnmount !== store.tools.onUnmount;
+    const updateAllStore = !_.isEqual(_spec, store.initialSpec) ||
+        config !== store.config ||
+        (specMutator !== EMPTY_MUTATOR && specMutator !== storeSpecMutator);
+    const updateAllStoreAndClearParentValues = name !== store.name;
+    if (updateAllStoreAndClearParentValues) {
+        callUnmout(store);
+        setStore(initializeStore({
+            name,
+            spec: _spec,
+            mutators,
+            config,
+            valueFromParent,
+            tools,
+            parentOnChange,
+            parentOnUnmount,
+        }));
+    }
+    else if (updateAllStore) {
+        let nextStore = Object.assign(Object.assign({}, initializeStore({
+            name,
+            spec: _spec,
+            mutators,
+            config,
+            valueFromParent,
+            tools,
+            parentOnChange,
+            parentOnUnmount,
+        })), { state: store.state });
+        if (updateState) {
+            nextStore = methodOnChange(nextStore, Object.assign({ valOrSetter: (value) => valueMutatorUpdated ? valueMutator : value }, (errorMutatorUpdated ? { errorMutator } : {})));
+        }
+        setStore(nextStore);
+    }
+    else if (updateNonCritical) {
+        let nextStore = Object.assign(Object.assign({}, store), { parentOnChange,
+            parentOnUnmount,
+            tools });
+        if (updateState) {
+            nextStore = methodOnChange(nextStore, Object.assign({ valOrSetter: (value) => valueMutatorUpdated ? valueMutator : value }, (errorMutatorUpdated ? { errorMutator } : {})));
+        }
+        setStore(nextStore);
+    }
+    else if (updateState) {
+        setStore(methodOnChange(store, Object.assign({ valOrSetter: (value) => valueMutatorUpdated ? valueMutator : value }, (errorMutatorUpdated ? { errorMutator } : {}))));
+    }
+};

package/build/esm/lib/core/components/Form/hooks/index.d.ts

@@ -1,17 +1,13 @@
-export * from './useComponents';
 export * from './useControllerMirror';
 export * from './useCreateContext';
 export * from './useDynamicFieldMirror';
 export * from './useDynamicFormsCtx';
-export * from './useField';
 export * from './useGenerateRandomValue';
 export * from './useIntegrationFF';
 export * from './useMutateDFState';
 export * from './useMutators';
-export * from './useRender';
 export * from './useStore';
 export * from './useStoreValue';
-export * from './useValidate';
 export * from './useMonaco';
 export * from './useSearchStore';
 export * from './useSearchContext';

package/build/esm/lib/core/components/Form/hooks/index.js

@@ -1,17 +1,13 @@
-export * from './useComponents';
 export * from './useControllerMirror';
 export * from './useCreateContext';
 export * from './useDynamicFieldMirror';
 export * from './useDynamicFormsCtx';
-export * from './useField';
 export * from './useGenerateRandomValue';
 export * from './useIntegrationFF';
 export * from './useMutateDFState';
 export * from './useMutators';
-export * from './useRender';
 export * from './useStore';
 export * from './useStoreValue';
-export * from './useValidate';
 export * from './useMonaco';
 export * from './useSearchStore';
 export * from './useSearchContext';

package/build/esm/lib/core/components/Form/hooks/useMutators.js

@@ -4,7 +4,27 @@ export const useMutators = (externalMutators) => {
     const firstRenderRef = React.useRef(true);
     const [store, setStore] = React.useState(externalMutators || {});
     const mutateDFState = React.useCallback((mutators) => {
-        setStore((store) => (Object.assign(Object.assign(Object.assign(Object.assign({}, store), (mutators.errors ? { errors: _.merge(store.errors, mutators.errors) } : {})), (mutators.values ? { values: _.merge(store.values, mutators.values) } : {})), (mutators.spec ? { spec: _.merge(store.spec, mutators.spec) } : {}))));
+        const mergeSpec = (a, b) => {
+            const result = _.cloneDeep(a);
+            const getKeys = (parent) => {
+                if (_.isObjectLike(parent)) {
+                    return _.keys(parent).reduce((acc, parentKey) => {
+                        const childKeys = getKeys(parent[parentKey]);
+                        return [
+                            ...acc,
+                            ...(childKeys.length ? [] : [[parentKey]]),
+                            ...childKeys.map((childKey) => [parentKey, ...childKey]),
+                        ];
+                    }, []);
+                }
+                return [];
+            };
+            getKeys(b).forEach((key) => {
+                _.set(result, key, _.get(b, key));
+            });
+            return result;
+        };
+        setStore((store) => (Object.assign(Object.assign(Object.assign(Object.assign({}, store), (mutators.errors ? { errors: _.merge(store.errors, mutators.errors) } : {})), (mutators.values ? { values: _.merge(store.values, mutators.values) } : {})), (mutators.spec ? { spec: mergeSpec(store.spec || {}, mutators.spec) } : {}))));
     }, [setStore]);
     React.useEffect(() => {
         if (firstRenderRef.current) {

package/build/esm/lib/core/components/Form/types/mirror.d.ts

@@ -1,9 +1,7 @@
-import { useComponents, useField, useIntegrationFF, useRender, useSearch, useSearchStore, useStore, useValidate } from '../hooks';
+import { useIntegrationFF, useSearch, useSearchStore, useStore } from '../hooks';
+import { FieldRenderProps } from './field';
 export interface ControllerMirror {
-    useComponents?: ReturnType<typeof useComponents>;
-    useRender?: ReturnType<typeof useRender>;
-    useValidate?: ReturnType<typeof useValidate>;
-    useField?: ReturnType<typeof useField>;
+    useField?: FieldRenderProps<any>;
     useSearch?: ReturnType<typeof useSearch>;
 }
 export interface DynamicFieldMirror {

package/build/esm/lib/core/components/Form/types/mutators.d.ts

@@ -1,7 +1,18 @@
-import { FormValue, Spec } from '../../../types';
+import { ArraySpec, BooleanSpec, FormValue, NumberSpec, ObjectSpec, StringSpec } from '../../../types';
 import { BaseValidateError } from './';
+export type SpecMutator = Partial<(Omit<ArraySpec, 'viewSpec'> & {
+    viewSpec: Partial<ArraySpec['viewSpec']>;
+}) | (Omit<BooleanSpec, 'viewSpec'> & {
+    viewSpec: Partial<BooleanSpec['viewSpec']>;
+}) | (Omit<NumberSpec, 'viewSpec'> & {
+    viewSpec: Partial<NumberSpec['viewSpec']>;
+}) | (Omit<ObjectSpec, 'viewSpec'> & {
+    viewSpec: Partial<ObjectSpec['viewSpec']>;
+}) | (Omit<StringSpec, 'viewSpec'> & {
+    viewSpec: Partial<StringSpec['viewSpec']>;
+})>;
 export interface DynamicFormMutators {
     errors?: Record<string, BaseValidateError>;
     values?: Record<string, FormValue>;
-    spec?: Record<string, Partial<Spec>>;
+    spec?: Record<string, SpecMutator>;
 }

package/build/esm/lib/core/components/Form/utils/common.d.ts

@@ -1,9 +1,6 @@
 import { FormValue, Spec } from '../../../types';
-import { ValidateError } from '../types';
 export declare const isCorrectConfig: (candidate: any) => boolean;
 export declare const transformArrIn: <Type extends FormValue, ReturnType_1 extends FormValue = Type>(value: Type) => ReturnType_1;
 export declare const transformArrOut: <Type extends FormValue, ReturnType_1 extends FormValue = Type>(value: Type) => ReturnType_1;
 export declare const isArrayItem: (name: string) => boolean;
 export declare const withGenerateButton: (spec: Spec) => boolean | undefined;
-export declare const isErrorMutatorCorrect: (errorMutator: ValidateError) => boolean;
-export declare const isValueMutatorCorrect: (valueMutator: FormValue, spec: Spec) => boolean;

package/build/esm/lib/core/components/Form/utils/common.js

@@ -45,5 +45,3 @@ export const isArrayItem = (name) => name[name.length - 1] === '>';
 export const withGenerateButton = (spec) => isStringSpec(spec) &&
     SPEC_TYPE_FOR_GENERATE_BUTTON.includes(spec.viewSpec.type) &&
     spec.viewSpec.generateRandomValueButton;
-export const isErrorMutatorCorrect = (errorMutator) => _.isString(errorMutator) || _.isBoolean(errorMutator) || _.isUndefined(errorMutator);
-export const isValueMutatorCorrect = (valueMutator, spec) => typeof valueMutator === spec.type || (_.isArray(valueMutator) && spec.type === SpecTypes.Array);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gravity-ui/dynamic-forms",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "",
   "license": "MIT",
   "main": "build/cjs/index.js",

package/build/cjs/lib/core/components/Form/Controller.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = void 0;
-const tslib_1 = require("tslib");
-const react_1 = tslib_1.__importDefault(require("react"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const constants_1 = require("./constants");
-const hooks_1 = require("./hooks");
-const Controller = ({ spec: _spec, name, value, parentOnChange, parentOnUnmount, }) => {
-    const { tools, mutators, __mirror } = (0, hooks_1.useDynamicFormsCtx)();
-    const spec = react_1.default.useMemo(() => {
-        const specMutator = lodash_1.default.get(mutators.spec, name, constants_1.EMPTY_MUTATOR);
-        if (specMutator !== constants_1.EMPTY_MUTATOR) {
-            return lodash_1.default.merge(_spec, specMutator);
-        }
-        return _spec;
-    }, [_spec, mutators.spec, name]);
-    const { inputEntity, Layout } = (0, hooks_1.useComponents)(spec);
-    const render = (0, hooks_1.useRender)({ name, spec, inputEntity, Layout });
-    const validate = (0, hooks_1.useValidate)(spec);
-    const renderProps = (0, hooks_1.useField)({
-        name,
-        initialValue: lodash_1.default.get(tools.initialValue, name),
-        value,
-        spec,
-        validate,
-        tools,
-        parentOnChange,
-        parentOnUnmount,
-        mutators,
-    });
-    const withSearch = (0, hooks_1.useSearch)(spec, renderProps.input.value, name);
-    (0, hooks_1.useControllerMirror)(name, {
-        useComponents: { inputEntity, Layout },
-        useRender: render,
-        useValidate: validate,
-        useField: renderProps,
-        useSearch: withSearch,
-    }, __mirror);
-    return withSearch(render(renderProps));
-};
-exports.Controller = Controller;

package/build/cjs/lib/core/components/Form/hooks/useComponents.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useComponents = void 0;
-const tslib_1 = require("tslib");
-const react_1 = tslib_1.__importDefault(require("react"));
-const lodash_1 = tslib_1.__importDefault(require("lodash"));
-const react_is_1 = require("react-is");
-const helpers_1 = require("../../../helpers");
-const utils_1 = require("../utils");
-const _1 = require("./");
-const useComponents = (spec) => {
-    var _a, _b;
-    const { config } = (0, _1.useDynamicFormsCtx)();
-    const { inputs, layouts } = react_1.default.useMemo(() => {
-        if ((0, utils_1.isCorrectConfig)(config) && (0, helpers_1.isCorrectSpec)(spec)) {
-            return config[spec.type];
-        }
-        return {};
-    }, [config, spec]);
-    const inputEntity = react_1.default.useMemo(() => {
-        if (inputs) {
-            const entity = inputs[spec.viewSpec.type];
-            if ((0, react_is_1.isValidElementType)(entity === null || entity === void 0 ? void 0 : entity.Component)) {
-                return entity;
-            }
-        }
-        return;
-    }, [inputs, (_a = spec === null || spec === void 0 ? void 0 : spec.viewSpec) === null || _a === void 0 ? void 0 : _a.type]);
-    const Layout = react_1.default.useMemo(() => {
-        if (layouts && lodash_1.default.isString(spec.viewSpec.layout)) {
-            const Component = layouts[spec.viewSpec.layout];
-            if ((0, react_is_1.isValidElementType)(Component)) {
-                return Component;
-            }
-        }
-        return;
-    }, [layouts, (_b = spec === null || spec === void 0 ? void 0 : spec.viewSpec) === null || _b === void 0 ? void 0 : _b.layout]);
-    return { inputEntity, Layout };
-};
-exports.useComponents = useComponents;