@headless-adminapp/app 0.0.17-alpha.8 → 1.0.0

package/dataform/hooks/useFormSave.js

@@ -6,17 +6,12 @@
 // 4. Perform the operations
 // 5. Handle the response (success or error, navigation, clear some cache, etc)
 // 6. Hide the loading indicator
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFormSave = useFormSave;
+// Wrapper - Loader, response message
+// Core - Extract modified fields, prepare operations, perform operations
+const route_1 = require("@headless-adminapp/app/route");
+const app_1 = require("@headless-adminapp/core/experience/app");
 const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const react_hook_form_1 = require("react-hook-form");
@@ -26,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");
@@ -41,7 +35,10 @@ function useFormSave() {
     const dataService = (0, transport_1.useDataService)();
     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 }) {
         // Show notification
         if (!isCreatedMode) {
@@ -59,8 +56,8 @@ function useFormSave() {
             });
         }
     }
-    const _save = (mode) => __awaiter(this, void 0, void 0, function* () {
-        yield formInstance.handleSubmit((values) => __awaiter(this, void 0, void 0, function* () {
+    const _save = async (mode) => {
+        await formInstance.handleSubmit(async (values) => {
             if (mode === 'background' && !record) {
                 // Background save should not be triggered if there is no record
                 return;
@@ -69,7 +66,7 @@ function useFormSave() {
                 showProgressIndicator(undefined, 500);
             }
             try {
-                const result = yield (0, utils_1.saveRecord)({
+                const result = await saveRecord({
                     values,
                     form: form,
                     record: record,
@@ -86,29 +83,29 @@ function useFormSave() {
                     });
                     return;
                 }
-                // invalidateQueriesAfterSave({
-                //   client,
-                // });
-                if (mode === 'save' && record) {
-                    yield refresh();
-                    // client.invalidateQueries({ queryKey: ['data', 'retriveRecord'] });
+                if (mode === 'save') {
+                    if (record) {
+                        await refresh();
+                    }
+                    else {
+                        router.replace(routeResolver({
+                            type: app_1.PageType.EntityForm,
+                            logicalName: schema.logicalName,
+                            id: result.recordId,
+                        }));
+                    }
                 }
                 else {
-                    yield client.invalidateQueries({
+                    await client.invalidateQueries({
                         queryKey: ['data', 'retriveRecord'],
                     });
+                    if (mode === 'saveandclose') {
+                        router.back();
+                    }
                 }
-                yield client.invalidateQueries({
+                await client.invalidateQueries({
                     queryKey: ['data', 'retriveRecords'],
                 });
-                // redirectAfterSave({
-                //   navigation,
-                //   isCreatedMode: !context.state.record,
-                //   recordId: result.recordId,
-                //   reset: form.reset,
-                //   logicalName: schema.logicalName,
-                //   mode,
-                // });
                 showMessageAfterSave({
                     isCreatedMode: !record,
                 });
@@ -126,8 +123,8 @@ function useFormSave() {
                     hideProgressIndicator();
                 }
             }
-        }))();
-    });
+        })();
+    };
     const _saveRef = (0, react_1.useRef)(_save);
     _saveRef.current = _save;
     const save = (0, react_1.useCallback)((mode) => _saveRef.current(mode), [_saveRef]);

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/useLoadFormGridPage.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useLoadFormGridPage = useLoadFormGridPage;
 const app_1 = require("@headless-adminapp/app/app");
@@ -18,21 +9,21 @@ function useLoadFormGridPage(logicalName, formId) {
     const experienceStore = (0, hooks_1.useExperienceStore)();
     const { data: form, isFetching: isFetchingForm } = (0, react_query_1.useQuery)({
         queryKey: ['experience-schema-form', logicalName, formId],
-        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+        queryFn: async () => {
             return experienceStore.getForm(logicalName, formId);
-        }),
+        },
         placeholderData: react_query_1.keepPreviousData,
     });
-    const { app: { formCommands }, } = (0, app_1.useAppContext)();
+    const { appExperience: { formCommands }, } = (0, app_1.useAppContext)();
     const { data: commands } = (0, react_query_1.useQuery)({
         queryKey: ['experience-schema-form-commands', logicalName],
-        queryFn: () => __awaiter(this, void 0, void 0, function* () {
-            let commands = yield experienceStore.getFormCommands(logicalName);
+        queryFn: async () => {
+            let commands = await experienceStore.getFormCommands(logicalName);
             if (!commands) {
                 commands = formCommands;
             }
-            return [];
-        }),
+            return commands ?? [];
+        },
         initialData: [],
     });
     if (!schema) {
@@ -40,7 +31,7 @@ function useLoadFormGridPage(logicalName, formId) {
             loading: false,
             error: true,
             title: 'Schema not found',
-            message: 'The schema was not found',
+            message: `The schema "${logicalName}" was not found`,
         };
     }
     if (!form) {

package/dataform/hooks/useMainFormCommands.d.ts

@@ -1,16 +1,5 @@
 import { EntityFormCommandContext } from '@headless-adminapp/core/experience/form';
 import { CommandItemState } from '../../command';
-export declare function useFormControlContext(): {
-    data: any;
-    logicalName: string;
-    schema: import("@headless-adminapp/core/schema").Schema<import("@headless-adminapp/core/schema").SchemaAttributes>;
-    form: import("@headless-adminapp/core/experience/form").Form<import("@headless-adminapp/core/schema").SchemaAttributes>;
-    formId: string;
-    originalData: import("@headless-adminapp/core/transport").Data<import("@headless-adminapp/core/schema").InferredSchemaType<import("@headless-adminapp/core/schema").SchemaAttributes>> | null;
-    recordId: string | number;
-    refresh: () => Promise<void>;
-    save: (mode?: import("@headless-adminapp/core/experience/form").SaveMode) => Promise<void>;
-    readonly: boolean | undefined;
-};
+export declare function useFormControlContext(): EntityFormCommandContext['primaryControl'];
 export declare function useMainFormCommandHandlerContext(): EntityFormCommandContext;
 export declare function useMainFormCommands(): CommandItemState[][];

package/dataform/hooks/useMainFormCommands.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useFormControlContext = useFormControlContext;
 exports.useMainFormCommandHandlerContext = useMainFormCommandHandlerContext;
 exports.useMainFormCommands = useMainFormCommands;
+const route_1 = require("@headless-adminapp/app/route");
+const react_1 = require("react");
 const command_1 = require("../../command");
 const context_1 = require("../../mutable/context");
 const context_2 = require("../context");
@@ -20,25 +22,33 @@ function useFormControlContext() {
     const save = (0, useFormSave_1.useFormSave)();
     const refresh = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.refresh);
     const formInstance = (0, useFormInstance_1.useFormInstance)();
-    const readonly = (0, useFormIsReadonly_1.useFormIsReadonly)();
+    const readonly = (0, useFormIsReadonly_1.useFormIsReadonly)() ?? false;
     const data = formInstance.watch();
+    const router = (0, route_1.useRouter)();
+    const close = (0, react_1.useCallback)(() => {
+        router.back();
+    }, [router]);
     return {
         data,
         logicalName: schema.logicalName,
         schema,
         form,
         formId: form.id,
-        originalData: originalData !== null && originalData !== void 0 ? originalData : null,
+        originalData: originalData ?? null,
         recordId,
         refresh,
         save,
         readonly,
+        close,
     };
 }
 function useMainFormCommandHandlerContext() {
     const primaryControl = useFormControlContext();
     const baseHandlerContext = (0, command_1.useBaseCommandHandlerContext)();
-    return Object.assign(Object.assign({}, baseHandlerContext), { primaryControl });
+    return {
+        ...baseHandlerContext,
+        primaryControl,
+    };
 }
 function useMainFormCommands() {
     const commands = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.commands);

package/dataform/hooks/useOnFieldValueChangeListener.d.ts

@@ -0,0 +1 @@
+export declare function useOnFieldValueChangeListener(key: string, callback: (value: any) => 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/useProcessFlowSteps.d.ts

@@ -0,0 +1 @@
+export declare function useProcessFlowSteps(): import("@headless-adminapp/core/experience/form/ProcessFlowInfo").ProcessFlowStep[] | null | undefined;

package/dataform/hooks/useProcessFlowSteps.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProcessFlowSteps = useProcessFlowSteps;
+const command_1 = require("@headless-adminapp/app/command");
+const context_1 = require("../../mutable/context");
+const context_2 = require("../context");
+const useFormInstance_1 = require("./useFormInstance");
+const useFormIsReadonly_1 = require("./useFormIsReadonly");
+const useFormRecord_1 = require("./useFormRecord");
+const useFormSchema_1 = require("./useFormSchema");
+const useRecordId_1 = require("./useRecordId");
+const useSelectedForm_1 = require("./useSelectedForm");
+function useFormControlContext() {
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const form = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.form);
+    const originalData = (0, useFormRecord_1.useFormRecord)();
+    const recordId = (0, useRecordId_1.useRecordId)();
+    const formInstance = (0, useFormInstance_1.useFormInstance)();
+    const readonly = (0, useFormIsReadonly_1.useFormIsReadonly)() ?? false;
+    const data = formInstance.watch();
+    return {
+        data,
+        logicalName: schema.logicalName,
+        schema,
+        form,
+        formId: form.id,
+        originalData: originalData ?? null,
+        recordId,
+        readonly,
+    };
+}
+function useProcessFlowInfoContext() {
+    const primaryControl = useFormControlContext();
+    const baseHandlerContext = (0, command_1.useBaseCommandHandlerContext)();
+    return {
+        ...baseHandlerContext,
+        primaryControl,
+    };
+}
+function useProcessFlowSteps() {
+    const formConfig = (0, useSelectedForm_1.useSelectedForm)();
+    const context = useProcessFlowInfoContext();
+    const steps = formConfig.experience.processFlow?.getSteps(context);
+    return steps;
+}

package/dataform/hooks/useRecordTitle.d.ts

@@ -1 +1,3 @@
-export declare function useRecordTitle(): string;
+type UseRecordTitleResult = [string, boolean];
+export declare function useRecordTitle(): UseRecordTitleResult;
+export {};

package/dataform/hooks/useRecordTitle.js

@@ -5,16 +5,23 @@ const useFormInstance_1 = require("./useFormInstance");
 const useFormSchema_1 = require("./useFormSchema");
 const useRecordId_1 = require("./useRecordId");
 function useRecordTitle() {
-    var _a;
     const formInstance = (0, useFormInstance_1.useFormInstance)();
     const schema = (0, useFormSchema_1.useDataFormSchema)();
     const recordId = (0, useRecordId_1.useRecordId)();
-    const primaryAttributeValue = (_a = formInstance.watch(schema.primaryAttribute)) !== null && _a !== void 0 ? _a : '';
+    let primaryAttributeValue = formInstance.watch(schema.primaryAttribute);
+    const primaryAttribute = schema.attributes[schema.primaryAttribute];
+    if (primaryAttribute?.type === 'lookup') {
+        // Handle lookup attribute as primary
+        primaryAttributeValue = primaryAttributeValue?.name;
+    }
+    if (primaryAttributeValue && typeof primaryAttributeValue !== 'string') {
+        return [String(primaryAttributeValue), false];
+    }
     if (primaryAttributeValue) {
-        return primaryAttributeValue;
+        return [primaryAttributeValue, false];
     }
     if (recordId) {
-        return '(No name)';
+        return ['(No name)', true];
     }
-    return `New ${schema.label.toLowerCase()}`;
+    return [`New ${schema.label.toLowerCase()}`, true];
 }

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;
+};

package/dataform/hooks/useRequiredFieldManager.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRequiredFieldManager = useRequiredFieldManager;
+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 useRequiredFieldManager() {
+    const setValue = (0, mutable_1.useContextSetValue)(context_2.DataFormContext);
+    const dataFormContextValue = (0, context_1.useContextValue)(context_2.DataFormContext);
+    const _getIsFieldRequired = (0, react_1.useCallback)((attributeName) => {
+        const attribute = dataFormContextValue.current.schema.attributes[attributeName];
+        const control = dataFormContextValue.current.formInternal.controls.dict[attributeName];
+        if (control.type !== 'standard') {
+            return false;
+        }
+        return (0, utils_1.getIsFieldRequired)({
+            attribute,
+            control,
+            requiredFields: dataFormContextValue.current.requiredFields,
+        });
+    }, [dataFormContextValue]);
+    const _setFieldRequired = (0, react_1.useCallback)((attributeName, state) => {
+        setValue((prev) => {
+            return {
+                requiredFields: {
+                    ...prev.requiredFields,
+                    [attributeName]: state,
+                },
+            };
+        });
+    }, [setValue]);
+    const _resetFieldRequired = (0, react_1.useCallback)((key) => {
+        setValue((prev) => {
+            const _requiredFields = { ...prev.requiredFields };
+            delete _requiredFields[key];
+            return {
+                requiredFields: _requiredFields,
+            };
+        });
+    }, [setValue]);
+    return {
+        getIsFieldRequired: _getIsFieldRequired,
+        setFieldRequired: _setFieldRequired,
+        resetFieldRequired: _resetFieldRequired,
+    };
+}

package/dataform/test.d.ts

@@ -0,0 +1,57 @@
+import { Attribute } from '@headless-adminapp/core';
+import { SectionControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ContextValue } from '../mutable';
+import { DataFormContextState } from './context';
+import { Section } from '@headless-adminapp/core/experience/form';
+import { Tab } from '@headless-adminapp/core/experience/form/Tab';
+export declare class FormUiManager<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>);
+    private get context();
+    getAttribute(attributeName: keyof SA): FormAttribute<SA> | null;
+    getControl<C extends Control<SA>>(name: string): C | null;
+    getSection(name: string): FormSection<SA> | null;
+    getTab(name: string): FormTab<SA> | null;
+}
+declare class FormAttribute<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly attributeName;
+    private readonly attribute;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, attributeName: keyof SA, attribute: Attribute);
+    getInnerAttribute(): Attribute;
+    setRequired(state: boolean): void;
+    getRequired(): boolean;
+    resetRequired(): void;
+    getControls(): Control<SA>[];
+}
+declare class Control<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly control;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, control: SectionControl<SA>);
+    private get context();
+    getKey(): string | undefined;
+    getDisabled(): boolean;
+    setDisabled(state: boolean): void;
+    resetDisabled(): void;
+    getHidden(): boolean;
+    setHidden(state: boolean): void;
+    resetHidden(): void;
+}
+declare class FormSection<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly section;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, section: Section<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+declare class FormTab<SA extends SchemaAttributes = SchemaAttributes> {
+    private readonly contextState;
+    private readonly tab;
+    constructor(contextState: ContextValue<DataFormContextState<SA>>, tab: Tab<SA>);
+    setHidden(state: boolean): void;
+    getHidden(): boolean;
+    resetHidden(): void;
+}
+export {};