@headless-adminapp/app 0.0.17-alpha.57 → 0.0.17-alpha.61

package/dataform/FormManager.js

@@ -0,0 +1,247 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FormManager = void 0;
+const utils_1 = require("./DataFormProvider/utils");
+class FormManager {
+    contextState;
+    constructor(contextState) {
+        this.contextState = contextState;
+    }
+    get context() {
+        return this.contextState.value.current;
+    }
+    getAttribute(attributeName) {
+        return new FormAttribute(this.contextState, attributeName, this.context.schema.attributes[attributeName]);
+    }
+    getControl(name) {
+        const control = this.context.formInternal.controls.dict[name] ?? null;
+        if (!control) {
+            return null;
+        }
+        return new Control(this.contextState, control);
+    }
+    getSection(name) {
+        const section = this.context.formInternal.sections.dict[name];
+        if (!section) {
+            return null;
+        }
+        return new FormSection(this.contextState, section);
+    }
+    getTab(name) {
+        const tab = this.context.formInternal.tabs.dict[name];
+        if (!tab) {
+            return null;
+        }
+        return new FormTab(this.contextState, tab);
+    }
+}
+exports.FormManager = FormManager;
+class FormAttribute {
+    contextState;
+    attributeName;
+    attribute;
+    constructor(contextState, attributeName, attribute) {
+        this.contextState = contextState;
+        this.attributeName = attributeName;
+        this.attribute = attribute;
+    }
+    getInnerAttribute() {
+        return this.attribute;
+    }
+    setRequired(state) {
+        const control = this.contextState.value.current.formInternal.controls.dict[this.attributeName];
+        if (!control) {
+            return;
+        }
+        if (control.type !== 'standard') {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            return {
+                requiredFields: {
+                    ...prev.requiredFields,
+                    [this.attributeName]: state,
+                },
+            };
+        });
+    }
+    getRequired() {
+        const attribute = this.attribute;
+        const control = this.contextState.value.current.formInternal.controls.dict[this.attributeName];
+        if (control.type !== 'standard') {
+            return false;
+        }
+        return (0, utils_1.getIsFieldRequired)({
+            attribute,
+            control,
+            requiredFields: this.contextState.value.current.requiredFields,
+        });
+    }
+    resetRequired() {
+        this.contextState.setValue((prev) => {
+            const requiredFields = { ...prev.requiredFields };
+            delete requiredFields[this.attributeName];
+            return {
+                requiredFields,
+            };
+        });
+    }
+    getControls() {
+        return this.contextState.value.current.formInternal.controls.list
+            .filter((control) => control.type === 'standard' &&
+            control.attributeName === this.attributeName)
+            .map((control) => new Control(this.contextState, control));
+    }
+}
+class Control {
+    contextState;
+    control;
+    constructor(contextState, control) {
+        this.contextState = contextState;
+        this.control = control;
+    }
+    get context() {
+        return this.contextState.value.current;
+    }
+    getKey() {
+        let key = this.control.key;
+        if (!key && this.control.type === 'standard') {
+            key = this.control.attributeName;
+        }
+        return key;
+    }
+    getDisabled() {
+        if (this.control.type !== 'standard') {
+            return false;
+        }
+        const attributeName = this.control.attributeName;
+        return (0, utils_1.getIsFieldDisabled)({
+            control: this.control,
+            attribute: this.context.schema.attributes[attributeName],
+            disabledFields: this.context.disabledControls,
+            isFormReadonly: this.context.isReadonly,
+        });
+    }
+    setDisabled(state) {
+        if (this.control.type !== 'standard') {
+            return;
+        }
+        const key = this.control.attributeName;
+        this.contextState.setValue((prev) => {
+            return {
+                disabledControls: {
+                    ...prev.disabledControls,
+                    [key]: state,
+                },
+            };
+        });
+    }
+    resetDisabled() {
+        if (this.control.type !== 'standard') {
+            return;
+        }
+        const key = this.control.attributeName;
+        this.contextState.setValue((prev) => {
+            const disabledFields = { ...prev.disabledControls };
+            delete disabledFields[key];
+            return {
+                disabledControls: disabledFields,
+            };
+        });
+    }
+    getHidden() {
+        return (0, utils_1.getIsControlHidden)({
+            control: this.control,
+            hiddenControls: this.context.hiddenControls,
+        });
+    }
+    setHidden(state) {
+        const key = this.getKey();
+        if (!key) {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenControls: {
+                    ...prev.hiddenControls,
+                    [key]: state,
+                },
+            };
+        });
+    }
+    resetHidden() {
+        const key = this.getKey();
+        if (!key) {
+            return;
+        }
+        this.contextState.setValue((prev) => {
+            const hiddenControls = { ...prev.hiddenControls };
+            delete hiddenControls[key];
+            return {
+                hiddenControls,
+            };
+        });
+    }
+}
+class FormSection {
+    contextState;
+    section;
+    constructor(contextState, section) {
+        this.contextState = contextState;
+        this.section = section;
+    }
+    setHidden(state) {
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenSections: {
+                    ...prev.hiddenSections,
+                    [this.section.name]: state,
+                },
+            };
+        });
+    }
+    getHidden() {
+        return (this.contextState.value.current.hiddenSections[this.section.name] ??
+            this.section.hidden ??
+            false);
+    }
+    resetHidden() {
+        this.contextState.setValue((prev) => {
+            const hiddenSections = { ...prev.hiddenSections };
+            delete hiddenSections[this.section.name];
+            return {
+                hiddenSections,
+            };
+        });
+    }
+}
+class FormTab {
+    contextState;
+    tab;
+    constructor(contextState, tab) {
+        this.contextState = contextState;
+        this.tab = tab;
+    }
+    setHidden(state) {
+        this.contextState.setValue((prev) => {
+            return {
+                hiddenTabs: {
+                    ...prev.hiddenTabs,
+                    [this.tab.name]: state,
+                },
+            };
+        });
+    }
+    getHidden() {
+        return this.contextState.value.current.hiddenTabs[this.tab.name] ?? false;
+    }
+    resetHidden() {
+        this.contextState.setValue((prev) => {
+            const hiddenTabs = { ...prev.hiddenTabs };
+            delete hiddenTabs[this.tab.name];
+            return {
+                hiddenTabs,
+            };
+        });
+    }
+}

package/dataform/constants.d.ts

@@ -0,0 +1 @@
+export declare const EVENT_KEY_ON_FIELD_CHANGE = "onFieldChange";

package/dataform/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_KEY_ON_FIELD_CHANGE = void 0;
+exports.EVENT_KEY_ON_FIELD_CHANGE = 'onFieldChange';

package/dataform/context.d.ts

@@ -1,17 +1,42 @@
-import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
+import { EntityMainFormCommandItemExperience, Form, Section } from '@headless-adminapp/core/experience/form';
+import { SectionControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { Tab } from '@headless-adminapp/core/experience/form/Tab';
 import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { IEventManager } from '@headless-adminapp/core/store';
 import { Data } from '@headless-adminapp/core/transport';
 import { Nullable } from '@headless-adminapp/core/types';
+import { SaveRecordFn } from './utils/saveRecord';
 export type DataFormContextState<SA extends SchemaAttributes = SchemaAttributes> = {
+    contextKey: number;
     schema: Schema<SA>;
     form: Form<SA>;
     recordId?: string | number;
     cloneId?: string | number;
     commands: EntityMainFormCommandItemExperience[][];
+    saveRecordFn: SaveRecordFn;
     activeTab?: string;
+    disabledControls: Record<string, boolean>;
+    requiredFields: Record<string, boolean>;
+    hiddenControls: Record<string, boolean>;
+    hiddenSections: Record<string, boolean>;
+    hiddenTabs: Record<string, boolean>;
+    formInternal: {
+        controls: {
+            list: SectionControl<SA>[];
+            dict: Record<string, SectionControl<SA>>;
+        };
+        sections: {
+            list: Section<SA>[];
+            dict: Record<string, Section<SA>>;
+        };
+        tabs: {
+            dict: Record<string, Tab<SA>>;
+        };
+    };
     record?: Data<InferredSchemaType<SA>>;
     cloneRecord?: Data<InferredSchemaType<SA>>;
     isReadonly?: boolean;
+    eventManager: IEventManager;
     dataState: {
         isFetching: boolean;
         isError?: boolean;

package/dataform/hooks/index.d.ts

@@ -11,3 +11,13 @@ export * from './useRecordTitle';
 export * from './useSelectedForm';
 export * from './useLoadFormGridPage';
 export * from './useProcessFlowSteps';
+export * from './useEventManager';
+export * from './useIsControlHiddenByAttributeName';
+export * from './useIsControlHiddenByKey';
+export * from './useHiddenControlsManager';
+export * from './useDisabledControlsManager';
+export * from './useContextKey';
+export * from './useIsControlDisabled';
+export * from './useIsFieldRequired';
+export * from './useRequiredFieldManager';
+export * from './useFormManager';

package/dataform/hooks/index.js

@@ -27,3 +27,13 @@ __exportStar(require("./useRecordTitle"), exports);
 __exportStar(require("./useSelectedForm"), exports);
 __exportStar(require("./useLoadFormGridPage"), exports);
 __exportStar(require("./useProcessFlowSteps"), exports);
+__exportStar(require("./useEventManager"), exports);
+__exportStar(require("./useIsControlHiddenByAttributeName"), exports);
+__exportStar(require("./useIsControlHiddenByKey"), exports);
+__exportStar(require("./useHiddenControlsManager"), exports);
+__exportStar(require("./useDisabledControlsManager"), exports);
+__exportStar(require("./useContextKey"), exports);
+__exportStar(require("./useIsControlDisabled"), exports);
+__exportStar(require("./useIsFieldRequired"), exports);
+__exportStar(require("./useRequiredFieldManager"), exports);
+__exportStar(require("./useFormManager"), exports);

package/dataform/hooks/useContextKey.d.ts

@@ -0,0 +1 @@
+export declare function useContextKey(): number;

package/dataform/hooks/useContextKey.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContextKey = useContextKey;
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+function useContextKey() {
+    return (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.contextKey);
+}

package/dataform/hooks/useDisabledControlsManager.d.ts

@@ -0,0 +1,6 @@
+/*** @deprecated */
+export declare function useDisabledControlsManager(): {
+    getIsControlDisabled: (attributeName: string) => boolean;
+    setControlDisabled: (attributeName: string, state: boolean) => void;
+    resetControlDisabled: (key: string) => void;
+};

package/dataform/hooks/useDisabledControlsManager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDisabledControlsManager = useDisabledControlsManager;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("@headless-adminapp/app/mutable/context");
+const react_1 = require("react");
+const context_2 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+/*** @deprecated */
+function useDisabledControlsManager() {
+    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
+    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
+    const _getIsControlDisabled = (0, react_1.useCallback)((attributeName) => {
+        const attribute = dataFormContextValue.current.schema.attributes[attributeName];
+        return (0, utils_1.getIsFieldDisabled)({
+            attribute,
+            control: dataFormContextValue.current.formInternal.controls.dict[attributeName],
+            disabledFields: dataFormContextValue.current.disabledControls,
+            isFormReadonly: dataFormContextValue.current.isReadonly,
+        });
+    }, [dataFormContextValue]);
+    const _setControlDisabled = (0, react_1.useCallback)((attributeName, state) => {
+        setValue((prev) => {
+            return {
+                disabledControls: {
+                    ...prev.disabledControls,
+                    [attributeName]: state,
+                },
+            };
+        });
+    }, [setValue]);
+    const _resetControlDisabled = (0, react_1.useCallback)((key) => {
+        setValue((prev) => {
+            const _disabledControls = { ...prev.disabledControls };
+            delete _disabledControls[key];
+            return {
+                hiddenControls: _disabledControls,
+            };
+        });
+    }, [setValue]);
+    return {
+        getIsControlDisabled: _getIsControlDisabled,
+        setControlDisabled: _setControlDisabled,
+        resetControlDisabled: _resetControlDisabled,
+    };
+}

package/dataform/hooks/useEventManager.d.ts

@@ -0,0 +1 @@
+export declare function useEventManager(): import("@headless-adminapp/core/store").IEventManager;

package/dataform/hooks/useEventManager.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useEventManager = useEventManager;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("../context");
+function useEventManager() {
+    return (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.eventManager);
+}

package/dataform/hooks/useFormManager.d.ts

@@ -0,0 +1,2 @@
+import { FormManager } from '../FormManager';
+export declare function useFormManager(): FormManager<import("@headless-adminapp/core/schema").SchemaAttributes>;

package/dataform/hooks/useFormManager.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormManager = useFormManager;
+const react_1 = require("react");
+const context_1 = require("../context");
+const FormManager_1 = require("../FormManager");
+function useFormManager() {
+    const context = (0, react_1.useContext)(context_1.DataFormContext);
+    if (!context) {
+        throw new Error('useFormManager must be used within a DataFormProvider');
+    }
+    return (0, react_1.useMemo)(() => new FormManager_1.FormManager(context), [context]);
+}

package/dataform/hooks/useFormSave.js

@@ -21,7 +21,6 @@ const useProgressIndicator_1 = require("../../progress-indicator/hooks/useProgre
 const useOpenToastNotification_1 = require("../../toast-notification/hooks/useOpenToastNotification");
 const transport_1 = require("../../transport");
 const context_2 = require("../context");
-const utils_1 = require("../utils");
 const useFormRecord_1 = require("./useFormRecord");
 const useFormSchema_1 = require("./useFormSchema");
 const useSelectedForm_1 = require("./useSelectedForm");
@@ -37,6 +36,7 @@ function useFormSave() {
     const { showProgressIndicator, hideProgressIndicator } = (0, useProgressIndicator_1.useProgressIndicator)();
     const openToastNotification = (0, useOpenToastNotification_1.useOpenToastNotification)();
     const routeResolver = (0, route_1.useRouteResolver)();
+    const saveRecord = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.saveRecordFn);
     const client = (0, react_query_1.useQueryClient)();
     const router = (0, route_1.useRouter)();
     function showMessageAfterSave({ isCreatedMode }) {
@@ -66,7 +66,7 @@ function useFormSave() {
                 showProgressIndicator(undefined, 500);
             }
             try {
-                const result = await (0, utils_1.saveRecord)({
+                const result = await saveRecord({
                     values,
                     form: form,
                     record: record,

package/dataform/hooks/useHiddenControlsManager.d.ts

@@ -0,0 +1,7 @@
+/** @deprecated */
+export declare function useHiddenControlsManager(): {
+    getIsControlHiddenByAttributeName: (attributeName: string) => boolean;
+    getIsControlHiddenByKey: (key: string) => boolean;
+    setControlHiddenByKey: (key: string, state: boolean) => void;
+    resetControlHiddenByKey: (key: string) => void;
+};

package/dataform/hooks/useHiddenControlsManager.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHiddenControlsManager = useHiddenControlsManager;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("@headless-adminapp/app/mutable/context");
+const react_1 = require("react");
+const context_2 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+/** @deprecated */
+function useHiddenControlsManager() {
+    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
+    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
+    const _getIsControlHiddenByAttributeName = (0, react_1.useCallback)((attributeName) => {
+        return (0, utils_1.getIsControlHidden)({
+            control: dataFormContextValue.current.formInternal.controls.dict[attributeName],
+            hiddenControls: dataFormContextValue.current.hiddenControls,
+        });
+    }, [dataFormContextValue]);
+    const _getIsControlHiddenByKey = (0, react_1.useCallback)((key) => {
+        return (0, utils_1.getIsControlHidden)({
+            control: dataFormContextValue.current.formInternal.controls.dict[key],
+            hiddenControls: dataFormContextValue.current.hiddenControls,
+        });
+    }, [dataFormContextValue]);
+    const _setControlHiddenByKey = (0, react_1.useCallback)((key, state) => {
+        setValue((prev) => {
+            return {
+                hiddenControls: {
+                    ...prev.hiddenControls,
+                    [key]: state,
+                },
+            };
+        });
+    }, [setValue]);
+    const _resetControlHiddenByKey = (0, react_1.useCallback)((key) => {
+        setValue((prev) => {
+            const _hiddenControls = { ...prev.hiddenControls };
+            delete _hiddenControls[key];
+            return {
+                hiddenControls: _hiddenControls,
+            };
+        });
+    }, [setValue]);
+    return {
+        getIsControlHiddenByAttributeName: _getIsControlHiddenByAttributeName,
+        getIsControlHiddenByKey: _getIsControlHiddenByKey,
+        setControlHiddenByKey: _setControlHiddenByKey,
+        resetControlHiddenByKey: _resetControlHiddenByKey,
+    };
+}

package/dataform/hooks/useIsControlDisabled.d.ts

@@ -0,0 +1 @@
+export declare function useIsControlDisabled(attributeName: string): boolean;

package/dataform/hooks/useIsControlDisabled.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsControlDisabled = useIsControlDisabled;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+const useFormIsReadonly_1 = require("./useFormIsReadonly");
+const useFormSchema_1 = require("./useFormSchema");
+function useIsControlDisabled(attributeName) {
+    const disabledFields = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.disabledControls);
+    const controls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.formInternal.controls.dict);
+    const isFormReadonly = (0, useFormIsReadonly_1.useFormIsReadonly)();
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const attribute = schema.attributes[attributeName];
+    if (!attribute) {
+        return true;
+    }
+    if (!controls[attributeName]) {
+        return true;
+    }
+    return (0, utils_1.getIsFieldDisabled)({
+        attribute,
+        control: controls[attributeName],
+        disabledFields: disabledFields,
+        isFormReadonly: isFormReadonly,
+    });
+}

package/dataform/hooks/useIsControlHiddenByAttributeName.d.ts

@@ -0,0 +1 @@
+export declare function useIsControlHiddenByAttributeName(attributeName: string): boolean;

package/dataform/hooks/useIsControlHiddenByAttributeName.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsControlHiddenByAttributeName = useIsControlHiddenByAttributeName;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+function useIsControlHiddenByAttributeName(attributeName) {
+    const hiddenControls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.hiddenControls);
+    const controls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.formInternal.controls.dict);
+    if (!controls[attributeName]) {
+        return true;
+    }
+    return (0, utils_1.getIsControlHidden)({
+        control: controls[attributeName],
+        hiddenControls,
+    });
+}

package/dataform/hooks/useIsControlHiddenByKey.d.ts

@@ -0,0 +1 @@
+export declare function useIsControlHiddenByKey(key: string): boolean;

package/dataform/hooks/useIsControlHiddenByKey.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsControlHiddenByKey = useIsControlHiddenByKey;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+function useIsControlHiddenByKey(key) {
+    const hiddenControls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.hiddenControls);
+    const controls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.formInternal.controls.dict);
+    if (!controls[key]) {
+        return true;
+    }
+    return (0, utils_1.getIsControlHidden)({
+        control: controls[key],
+        hiddenControls,
+    });
+}

package/dataform/hooks/useIsFieldRequired.d.ts

@@ -0,0 +1 @@
+export declare function useIsFieldRequired(attributeName: string): boolean;

package/dataform/hooks/useIsFieldRequired.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsFieldRequired = useIsFieldRequired;
+const mutable_1 = require("@headless-adminapp/app/mutable");
+const context_1 = require("../context");
+const utils_1 = require("../DataFormProvider/utils");
+const useFormSchema_1 = require("./useFormSchema");
+function useIsFieldRequired(attributeName) {
+    const requiredFields = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.requiredFields);
+    const controls = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.formInternal.controls.dict);
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const attribute = schema.attributes[attributeName];
+    const control = controls[attributeName];
+    if (!attribute) {
+        return false;
+    }
+    if (!control || control.type !== 'standard') {
+        return false;
+    }
+    return (0, utils_1.getIsFieldRequired)({
+        attribute,
+        control,
+        requiredFields: requiredFields,
+    });
+}

package/dataform/hooks/useOnFieldValueChangeListener.d.ts

@@ -0,0 +1 @@
+export declare function useOnFieldValueChangeListener(key: string, callback: (value: unknown) => any): void;

package/dataform/hooks/useOnFieldValueChangeListener.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnFieldValueChangeListener = useOnFieldValueChangeListener;
+const react_1 = require("react");
+const constants_1 = require("../constants");
+const useEventManager_1 = require("./useEventManager");
+function useOnFieldValueChangeListener(key, callback) {
+    const eventManager = (0, useEventManager_1.useEventManager)();
+    const callbackRef = (0, react_1.useRef)(callback);
+    callbackRef.current = callback;
+    (0, react_1.useEffect)(() => {
+        const listener = (_key, value) => {
+            const _path = _key.split('.');
+            const path = key.split('.');
+            if (_path.length !== path.length) {
+                return;
+            }
+            for (let i = 0; i < path.length; i++) {
+                if (path[i] !== _path[i]) {
+                    return;
+                }
+            }
+            callbackRef.current(value);
+        };
+        eventManager.on(constants_1.EVENT_KEY_ON_FIELD_CHANGE, listener);
+        return () => {
+            eventManager.off(constants_1.EVENT_KEY_ON_FIELD_CHANGE, listener);
+        };
+    }, [key, callback, eventManager]);
+}

package/dataform/hooks/useRequiredFieldManager.d.ts

@@ -0,0 +1,6 @@
+/*** @deprecated */
+export declare function useRequiredFieldManager(): {
+    getIsFieldRequired: (attributeName: string) => boolean;
+    setFieldRequired: (attributeName: string, state: boolean) => void;
+    resetFieldRequired: (key: string) => void;
+};