@gravity-ui/dynamic-forms 3.2.0 → 3.4.0

package/build/cjs/lib/kit/components/LongValue/LongValue.css

@@ -11,5 +11,5 @@
   cursor: pointer;
 }
 .df-long-value_long:hover {
-  color: var(--yc-color-text-secondary);
+  color: var(--g-color-text-secondary);
 }

package/build/cjs/lib/kit/components/SimpleVerticalAccordeon/SimpleVerticalAccordeon.css

@@ -7,7 +7,7 @@
 .df-simple-vertical-accordeon_branch .df-simple-vertical-accordeon__body {
   padding-left: 20px;
   margin-left: 5px;
-  border-left: 1px solid var(--yc-color-line-generic-accent);
+  border-left: 1px solid var(--g-color-line-generic-accent);
 }
 .df-simple-vertical-accordeon__header {
   display: flex;
@@ -22,15 +22,15 @@
 }
 .df-simple-vertical-accordeon__title_size_s {
   margin-bottom: 0;
-  font-size: var(--yc-text-body-1-font-size);
+  font-size: var(--g-text-body-1-font-size);
 }
 .df-simple-vertical-accordeon__title_size_m {
   margin-bottom: 1px;
-  font-size: var(--yc-text-body2-font-size);
+  font-size: var(--g-text-body2-font-size);
 }
 .df-simple-vertical-accordeon__title_size_l {
   margin-bottom: 2px;
-  font-size: var(--yc-text-body3-font-size);
+  font-size: var(--g-text-body3-font-size);
 }
 .df-simple-vertical-accordeon__tooltip {
   margin: 0px 5px;

package/build/cjs/lib/kit/components/ViewLayouts/ViewRow/ViewRow.css

@@ -18,13 +18,13 @@
   white-space: nowrap;
   overflow: hidden;
   text-overflow: ellipsis;
-  color: var(--yc-color-text-secondary);
+  color: var(--g-color-text-secondary);
 }
 .df-view-row__dots {
   min-width: 40px;
   flex-grow: 1;
   margin: 0 2px;
-  border-bottom: 1px dotted var(--yc-color-text-secondary);
+  border-bottom: 1px dotted var(--g-color-text-secondary);
 }
 .df-view-row__right {
   max-width: 480px;

package/build/cjs/lib/kit/components/Views/MonacoInputView/MonacoBaseView.css

@@ -1,4 +1,4 @@
 .df-monaco-base-view {
-  border: 1px solid var(--yc-color-line-generic);
+  border: 1px solid var(--g-color-line-generic);
   width: 550px;
 }

package/build/cjs/lib/kit/components/Views/MonacoInputView/MonacoViewDialog.css

@@ -2,7 +2,7 @@
   padding: 10px 32px 32px;
 }
 .df-monaco-view-dialog__container {
-  border: 1px solid var(--yc-color-line-generic);
+  border: 1px solid var(--g-color-line-generic);
 }
 .df-monaco-view-dialog__dialog-header {
   height: 48px;

package/build/cjs/lib/kit/components/Views/ObjectValueInputView/ObjectValueInputView.js

@@ -20,7 +20,7 @@ const ObjectValueInputView = (_a) => {
     if (!childSpec) {
         return null;
     }
-    const content = (react_1.default.createElement(core_1.ViewController, { spec: childSpec, name: `${name}.${OBJECT_VALUE_PROPERTY_NAME}` }));
+    const content = (react_1.default.createElement(core_1.ViewController, { spec: childSpec, name: `${name ? name + '.' : ''}${OBJECT_VALUE_PROPERTY_NAME}` }));
     if (Layout) {
         return (react_1.default.createElement(Layout, Object.assign({ spec: spec, name: name }, restProps), content));
     }

package/build/cjs/lib/kit/validators/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/cjs/lib/kit/validators/validators.js

@@ -6,79 +6,83 @@ const lodash_1 = tslib_1.__importDefault(require("lodash"));
 const validators_1 = require("../validators");
 const helpers_1 = require("./helpers");
 const getArrayValidator = (params = {}) => {
-    const { ignoreRequiredCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck } = params;
+    const { ignoreRequiredCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck, customErrorMessages } = params;
+    const errorMessages = Object.assign(Object.assign({}, validators_1.ErrorMessages), customErrorMessages);
     return (spec, value) => {
         const valueLength = (value === null || value === void 0 ? void 0 : value.length) || 0;
         if (!ignoreRequiredCheck && spec.required && !lodash_1.default.isArray(value)) {
-            return validators_1.ErrorMessages.REQUIRED;
+            return errorMessages.REQUIRED;
         }
         if (!ignoreMaxLengthCheck &&
             typeof spec.maxLength === 'bigint' &&
             valueLength > spec.maxLength) {
-            return validators_1.ErrorMessages.maxLengthArr(spec.maxLength);
+            return errorMessages.maxLengthArr(spec.maxLength);
         }
         if (!ignoreMinLengthCheck &&
             typeof spec.minLength === 'bigint' &&
             valueLength < spec.minLength) {
-            return validators_1.ErrorMessages.minLengthArr(spec.minLength);
+            return errorMessages.minLengthArr(spec.minLength);
         }
         return false;
     };
 };
 exports.getArrayValidator = getArrayValidator;
 const getBooleanValidator = (params = {}) => {
-    const { ignoreRequiredCheck } = params;
+    const { ignoreRequiredCheck, customErrorMessages } = params;
+    const errorMessages = Object.assign(Object.assign({}, validators_1.ErrorMessages), customErrorMessages);
     return (spec, value) => {
         if (!ignoreRequiredCheck && spec.required && !value) {
-            return validators_1.ErrorMessages.REQUIRED;
+            return errorMessages.REQUIRED;
         }
         return false;
     };
 };
 exports.getBooleanValidator = getBooleanValidator;
 const getNumberValidator = (params = {}) => {
-    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreNumberCheck, ignoreMaximumCheck, ignoreMinimumCheck, ignoreIntCheck, ignoreDotEnd, ignoreZeroStart, } = params;
+    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreNumberCheck, ignoreMaximumCheck, ignoreMinimumCheck, ignoreIntCheck, ignoreDotEnd, ignoreZeroStart, customErrorMessages, } = params;
+    const errorMessages = Object.assign(Object.assign({}, validators_1.ErrorMessages), customErrorMessages);
+    // eslint-disable-next-line complexity
     return (spec, value = '') => {
         const stringValue = String(value);
         if (!ignoreRequiredCheck && spec.required && !stringValue.length) {
-            return validators_1.ErrorMessages.REQUIRED;
+            return errorMessages.REQUIRED;
         }
         if (stringValue.length) {
             if (!ignoreSpaceStartCheck && !stringValue[0].trim()) {
-                return validators_1.ErrorMessages.SPACE_START;
+                return errorMessages.SPACE_START;
             }
             if (!ignoreSpaceEndCheck && !stringValue[stringValue.length - 1].trim()) {
-                return validators_1.ErrorMessages.SPACE_END;
+                return errorMessages.SPACE_END;
             }
             if (!ignoreDotEnd && stringValue[stringValue.length - 1] === '.') {
-                return validators_1.ErrorMessages.DOT_END;
+                return errorMessages.DOT_END;
             }
             if (!ignoreNumberCheck && !(0, helpers_1.isFloat)(stringValue)) {
-                return validators_1.ErrorMessages.NUMBER;
+                return errorMessages.NUMBER;
             }
             if (!ignoreZeroStart &&
                 ((stringValue.length > 1 && stringValue[0] === '0' && stringValue[1] !== '.') ||
                     (stringValue.length > 2 &&
                         stringValue.substring(0, 2) === '-0' &&
                         stringValue[2] !== '.'))) {
-                return validators_1.ErrorMessages.ZERO_START;
+                return errorMessages.ZERO_START;
             }
         }
         if (!ignoreMaximumCheck &&
             lodash_1.default.isNumber(spec.maximum) &&
             stringValue.length &&
             Number(stringValue) > spec.maximum) {
-            return validators_1.ErrorMessages.maxNumber(spec.maximum);
+            return errorMessages.maxNumber(spec.maximum);
         }
         if (!ignoreMinimumCheck &&
             lodash_1.default.isNumber(spec.minimum) &&
             stringValue.length &&
             spec.minimum > Number(stringValue)) {
-            return validators_1.ErrorMessages.minNumber(spec.minimum);
+            return errorMessages.minNumber(spec.minimum);
         }
         if (lodash_1.default.isString(spec.format) && stringValue.length) {
             if (!ignoreIntCheck && spec.format === 'int64' && !(0, helpers_1.isInt)(stringValue)) {
-                return validators_1.ErrorMessages.INT;
+                return errorMessages.INT;
             }
         }
         return false;
@@ -86,46 +90,49 @@ const getNumberValidator = (params = {}) => {
 };
 exports.getNumberValidator = getNumberValidator;
 const getObjectValidator = (params = {}) => {
-    const { ignoreRequiredCheck } = params;
+    const { ignoreRequiredCheck, customErrorMessages } = params;
+    const errorMessages = Object.assign(Object.assign({}, validators_1.ErrorMessages), customErrorMessages);
     return (spec, value) => {
         if (!ignoreRequiredCheck && spec.required && !value) {
-            return validators_1.ErrorMessages.REQUIRED;
+            return errorMessages.REQUIRED;
         }
         return false;
     };
 };
 exports.getObjectValidator = getObjectValidator;
 const getStringValidator = (params = {}) => {
-    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck, ignoreRegExpCheck, } = params;
+    const { ignoreRequiredCheck, ignoreSpaceStartCheck, ignoreSpaceEndCheck, ignoreMaxLengthCheck, ignoreMinLengthCheck, ignoreRegExpCheck, customErrorMessages, } = params;
+    const errorMessages = Object.assign(Object.assign({}, validators_1.ErrorMessages), customErrorMessages);
+    // eslint-disable-next-line complexity
     return (spec, value = '') => {
         const valueLength = value === null || value === void 0 ? void 0 : value.length;
         if (!ignoreRequiredCheck && spec.required && !valueLength) {
-            return validators_1.ErrorMessages.REQUIRED;
+            return errorMessages.REQUIRED;
         }
         if (valueLength) {
             if (!ignoreSpaceStartCheck && !value[0].trim()) {
-                return validators_1.ErrorMessages.SPACE_START;
+                return errorMessages.SPACE_START;
             }
             if (!ignoreSpaceEndCheck && !value[value.length - 1].trim()) {
-                return validators_1.ErrorMessages.SPACE_END;
+                return errorMessages.SPACE_END;
             }
         }
         if (!ignoreMaxLengthCheck &&
             typeof spec.maxLength === 'bigint' &&
             valueLength > spec.maxLength) {
-            return validators_1.ErrorMessages.maxLength(spec.maxLength);
+            return errorMessages.maxLength(spec.maxLength);
         }
         if (!ignoreMinLengthCheck &&
             typeof spec.minLength === 'bigint' &&
             valueLength < spec.minLength) {
-            return validators_1.ErrorMessages.minLength(spec.minLength);
+            return errorMessages.minLength(spec.minLength);
         }
         if (lodash_1.default.isString(spec.pattern) && spec.pattern.length) {
             const regex = new RegExp(spec.pattern);
             if (!ignoreRegExpCheck && !regex.test(value)) {
                 return lodash_1.default.isString(spec.patternError) && spec.patternError.length
                     ? spec.patternError
-                    : validators_1.ErrorMessages.INVALID;
+                    : errorMessages.INVALID;
             }
         }
         return false;

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

@@ -0,0 +1,10 @@
+import { FormValue, Spec } from '../../../types';
+import { FieldValue, ValidateError } from '../types';
+export interface ControllerProps<DirtyValue extends FieldValue, SpecType extends Spec> {
+    spec: SpecType;
+    name: string;
+    value: DirtyValue;
+    parentOnChange: ((childName: string, childValue: FieldValue, childErrors: Record<string, ValidateError>) => void) | null;
+    parentOnUnmount: ((childName: string) => void) | null;
+}
+export declare const Controller: <DirtyValue extends FieldValue, Value extends FormValue, SpecType extends Spec>({ spec: _spec, name, value: valueFromParent, parentOnChange, parentOnUnmount, }: ControllerProps<DirtyValue, SpecType>) => JSX.Element | null;

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

@@ -0,0 +1,115 @@
+import React from 'react';
+import _ from 'lodash';
+import { useControllerMirror, useDynamicFormsCtx, useSearch } from '../hooks';
+import { callUnmout, getFieldMethods, initializeStore, updateStore } from './utils';
+export const Controller = ({ spec: _spec, name, value: valueFromParent, parentOnChange, parentOnUnmount, }) => {
+    const { config, tools, mutators, __mirror } = useDynamicFormsCtx();
+    const firstRenderRef = React.useRef(true);
+    const [store, setStore] = React.useState(initializeStore({
+        name,
+        spec: _spec,
+        mutators,
+        config,
+        valueFromParent,
+        tools,
+        parentOnChange,
+        parentOnUnmount,
+    }));
+    const { methods, fieldMethods } = React.useMemo(() => {
+        const fieldMethods = getFieldMethods();
+        const onChange = (valOrSetter, childErrors, errorMutator) => {
+            setStore((store) => fieldMethods.onChange(store, { valOrSetter, childErrors, errorMutator }));
+        };
+        const onDrop = () => {
+            setStore((store) => fieldMethods.onDrop(store, undefined));
+        };
+        const onBlur = () => {
+            setStore((store) => fieldMethods.onBlur(store, undefined));
+        };
+        const onFocus = () => {
+            setStore((store) => fieldMethods.onFocus(store, undefined));
+        };
+        const parentOnUnmount = (childName) => {
+            setStore((store) => fieldMethods.parentOnUnmount(store, childName));
+        };
+        const onItemAdd = (value) => {
+            setStore((store) => fieldMethods.onItemAdd(store, value));
+        };
+        const onItemRemove = (idx) => {
+            setStore((store) => fieldMethods.onItemRemove(store, idx));
+        };
+        return {
+            methods: {
+                onChange,
+                onDrop,
+                onBlur,
+                onFocus,
+                parentOnUnmount,
+                onItemAdd,
+                onItemRemove,
+            },
+            fieldMethods,
+        };
+    }, [setStore]);
+    const renderProps = React.useMemo(() => ({
+        input: {
+            name: store.name,
+            value: store.state.value,
+            onChange: methods.onChange,
+            onBlur: methods.onBlur,
+            onFocus: methods.onFocus,
+            onDrop: methods.onDrop,
+            parentOnUnmount: methods.parentOnUnmount,
+        },
+        arrayInput: {
+            name: store.name,
+            value: store.state.value,
+            onItemAdd: methods.onItemAdd,
+            onItemRemove: methods.onItemRemove,
+            onDrop: methods.onDrop,
+        },
+        meta: Object.assign(Object.assign({}, _.omit(store.state, 'value')), { submitFailed: store.tools.submitFailed }),
+    }), [methods, store.name, store.state, store.tools.submitFailed]);
+    const withSearch = useSearch(store.spec, store.state.value, store.name);
+    useControllerMirror(store.name, {
+        useField: renderProps,
+        useSearch: withSearch,
+    }, __mirror);
+    React.useEffect(() => {
+        var _a;
+        (_a = store.afterStoreUpdateCB) === null || _a === void 0 ? void 0 : _a.call(store);
+    }, [store.afterStoreUpdateCB]);
+    React.useEffect(() => {
+        if (!firstRenderRef.current) {
+            updateStore({
+                store,
+                setStore,
+                spec: _spec,
+                name,
+                parentOnChange,
+                parentOnUnmount,
+                mutators,
+                config,
+                tools,
+                methodOnChange: fieldMethods.onChange,
+                valueFromParent,
+            });
+        }
+    }, [
+        _spec,
+        name,
+        parentOnChange,
+        parentOnUnmount,
+        mutators,
+        config,
+        tools.onChange,
+        tools.onUnmount,
+    ]);
+    React.useEffect(() => {
+        firstRenderRef.current = false;
+        return () => {
+            callUnmout(store);
+        };
+    }, []);
+    return withSearch(store.render(renderProps));
+};

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

@@ -0,0 +1 @@
+export * from './Controller';

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

@@ -0,0 +1 @@
+export * from './Controller';

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;