@headless-adminapp/app 0.0.8-0.0.9-alpha.1.0

package/dist/dataform/DataFormProvider/DataResolver.js

@@ -0,0 +1,143 @@
+"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.getControls = getControls;
+exports.getColumns = getColumns;
+exports.DataResolver = DataResolver;
+const transport_1 = require("@headless-adminapp/core/transport");
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const hooks_1 = require("../../metadata/hooks");
+const mutable_1 = require("../../mutable");
+const transport_2 = require("../../transport");
+const context_1 = require("../context");
+const hooks_2 = require("../hooks");
+function getControls(form) {
+    const controls = form.experience.tabs
+        .flatMap((tab) => tab.tabColumns)
+        .flatMap((tabColumn) => tabColumn.sections)
+        .flatMap((section) => section.controls);
+    return controls;
+}
+function getColumns(form) {
+    var _a;
+    const columns = Array.from(new Set([
+        ...((_a = form.experience.includeAttributes) !== null && _a !== void 0 ? _a : []),
+        ...form.experience.headerControls,
+        ...getControls(form)
+            .filter((control) => control.type === 'standard')
+            .map((control) => control.attributeName),
+    ]));
+    return columns;
+}
+function getRecord(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ recordId, dataService, form, schema, columns, getSchema, }) {
+        var _b;
+        let record = null;
+        try {
+            record = yield dataService.retriveRecord(schema.logicalName, recordId, columns);
+        }
+        catch (error) {
+            if (error instanceof transport_1.HttpError && error.status === 404) {
+                return null;
+            }
+            throw error;
+        }
+        if (!record) {
+            return null;
+        }
+        const controls = getControls(form);
+        const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+        for (const control of editableGridControls) {
+            if (control.type !== 'editablegrid') {
+                continue;
+            }
+            const controlSchema = getSchema(control.logicalName);
+            const records = yield dataService.retriveRecords({
+                logicalName: controlSchema.logicalName,
+                filter: {
+                    type: 'and',
+                    conditions: [
+                        {
+                            field: control.referenceAttribute,
+                            operator: 'eq',
+                            value: recordId,
+                        },
+                    ],
+                },
+                sort: [
+                    {
+                        field: (_b = controlSchema.createdAtAttribute) !== null && _b !== void 0 ? _b : controlSchema.idAttribute,
+                        order: 'asc',
+                    },
+                ],
+                limit: 5000,
+                search: '',
+                columns: [
+                    controlSchema.idAttribute,
+                    control.referenceAttribute,
+                    ...control.attributes,
+                ],
+            });
+            record[control.attributeName] = records.records;
+        }
+        return record;
+    });
+}
+function DataResolver() {
+    const schema = (0, hooks_2.useDataFormSchema)();
+    const form = (0, hooks_2.useSelectedForm)();
+    const dataService = (0, transport_2.useDataService)();
+    const recordId = (0, hooks_2.useRecordId)();
+    const { getSchema } = (0, hooks_1.useMetadata)();
+    const setState = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);
+    const columns = (0, react_1.useMemo)(() => getColumns(form), [form]);
+    const queryKey = (0, react_1.useMemo)(() => ['data', 'retriveRecord', schema.logicalName, recordId, columns], [columns, recordId, schema.logicalName]);
+    const { data, refetch, isPending } = (0, react_query_1.useQuery)({
+        queryKey,
+        queryFn: () => __awaiter(this, void 0, void 0, function* () {
+            if (!recordId) {
+                return null;
+            }
+            const record = getRecord({
+                columns,
+                dataService,
+                form,
+                recordId,
+                schema,
+                getSchema,
+            });
+            return record;
+        }),
+        placeholderData: react_query_1.keepPreviousData,
+        staleTime: 1000 * 60 * 5, // 5 minutes
+    });
+    (0, react_1.useEffect)(() => {
+        setState({
+            record: data,
+        });
+    }, [data, setState]);
+    (0, react_1.useEffect)(() => {
+        setState({
+            dataState: {
+                isFetching: isPending,
+            },
+        });
+    }, [isPending, setState]);
+    (0, react_1.useEffect)(() => {
+        setState({
+            refresh: () => __awaiter(this, void 0, void 0, function* () {
+                yield refetch();
+            }),
+        });
+    }, [refetch, setState]);
+    return null;
+}

package/dist/dataform/DataFormProvider/InitialValueResolver.d.ts

@@ -0,0 +1 @@
+export declare function InitialValueResolver(): null;

package/dist/dataform/DataFormProvider/InitialValueResolver.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InitialValueResolver = InitialValueResolver;
+const react_1 = require("react");
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+const hooks_1 = require("../hooks");
+const utils_1 = require("../utils");
+function InitialValueResolver() {
+    const formConfig = (0, hooks_1.useSelectedForm)();
+    const schema = (0, hooks_1.useDataFormSchema)();
+    const recordId = (0, hooks_1.useRecordId)();
+    const record = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.record);
+    const formInstance = (0, hooks_1.useFormInstance)();
+    const initialValues = (0, react_1.useMemo)(() => {
+        return (0, utils_1.getInitialValues)({
+            cloneRecord: undefined,
+            form: formConfig,
+            record: record,
+            recordId: recordId,
+            schema: schema,
+            defaultParameters: {},
+            // defaultParameters,
+        });
+    }, [formConfig, record, recordId, schema]);
+    const setValue = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);
+    (0, react_1.useEffect)(() => {
+        setValue({
+            initialValues,
+        });
+    }, [setValue, initialValues]);
+    const formInstanceRef = (0, react_1.useRef)(formInstance);
+    formInstanceRef.current = formInstance;
+    (0, react_1.useEffect)(() => {
+        const timer = setTimeout(() => {
+            // console.log('resetting form', initialValues);
+            formInstanceRef.current.reset(initialValues);
+        });
+        return () => {
+            clearTimeout(timer);
+        };
+    }, [initialValues]);
+    return null;
+}

package/dist/dataform/DataFormProvider/ReadonlyInfoResolver.d.ts

@@ -0,0 +1,3 @@
+export declare function ReadonlyInfoResolver({ setFormReadOnly, }: {
+    setFormReadOnly: (value: boolean) => void;
+}): null;

package/dist/dataform/DataFormProvider/ReadonlyInfoResolver.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyInfoResolver = ReadonlyInfoResolver;
+const react_1 = require("react");
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+const hooks_1 = require("../hooks");
+function ReadonlyInfoResolver({ setFormReadOnly, }) {
+    var _a, _b;
+    const schema = (0, hooks_1.useDataFormSchema)();
+    const recordId = (0, hooks_1.useRecordId)();
+    let readonly = false;
+    if (((_a = schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableCreate) && !recordId) {
+        readonly = true;
+    }
+    if (((_b = schema.restrictions) === null || _b === void 0 ? void 0 : _b.disableUpdate) && recordId) {
+        readonly = true;
+    }
+    const setValue = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);
+    (0, react_1.useEffect)(() => {
+        setValue({
+            isReadonly: readonly,
+        });
+        setFormReadOnly(readonly);
+    }, [setValue, setFormReadOnly, readonly]);
+    return null;
+}

package/dist/dataform/DataFormProvider/index.d.ts

@@ -0,0 +1,10 @@
+import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
+import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { PropsWithChildren } from 'react';
+export interface DataFormProviderProps<S extends SchemaAttributes = SchemaAttributes> {
+    schema: Schema<S>;
+    form: Form<S>;
+    recordId?: string;
+    commands: EntityMainFormCommandItemExperience[][];
+}
+export declare function DataFormProvider<S extends SchemaAttributes = SchemaAttributes>(props: PropsWithChildren<DataFormProviderProps<S>>): import("react/jsx-runtime").JSX.Element;

package/dist/dataform/DataFormProvider/index.js

@@ -0,0 +1,72 @@
+"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.DataFormProvider = DataFormProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const react_hook_form_1 = require("react-hook-form");
+const FormValidationStringContext_1 = require("../../form/FormValidationStringContext");
+const useLocale_1 = require("../../locale/useLocale");
+const useMetadata_1 = require("../../metadata/hooks/useMetadata");
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+const utils_1 = require("../utils");
+const DataResolver_1 = require("./DataResolver");
+const InitialValueResolver_1 = require("./InitialValueResolver");
+const ReadonlyInfoResolver_1 = require("./ReadonlyInfoResolver");
+function DataFormProvider(props) {
+    const { getSchema } = (0, useMetadata_1.useMetadata)();
+    const [{ language }] = (0, useLocale_1.useLocale)();
+    const formValidationStrings = (0, FormValidationStringContext_1.useFormValidationStrings)();
+    const [formReadOnly, setFormReadOnly] = (0, react_1.useState)(false); // A trick to provide readOnly info to formInstance
+    const formInstance = (0, react_hook_form_1.useForm)({
+        mode: 'all',
+        defaultValues: {},
+        resolver: (0, utils_1.formValidator)({
+            form: props.form,
+            getSchema,
+            language,
+            schema: props.schema,
+            strings: formValidationStrings,
+            formReadOnly,
+        }),
+        shouldUnregister: false,
+    });
+    const contextValue = (0, mutable_1.useCreateContextStore)({
+        schema: props.schema,
+        form: props.form,
+        commands: props.commands,
+        dataState: { isFetching: false },
+        recordId: props.recordId,
+        refresh: () => __awaiter(this, void 0, void 0, function* () { }), // Initial value, will be overridden
+        cloneId: undefined,
+        // formInstance,
+        // formInstanceRenderCount: 0,
+        initialValues: {},
+    });
+    (0, react_1.useEffect)(() => {
+        contextValue.setValue({
+            form: props.form,
+            schema: props.schema,
+            recordId: props.recordId,
+            cloneId: undefined,
+            commands: props.commands,
+        });
+    }, [
+        props.form,
+        props.schema,
+        props.recordId,
+        contextValue,
+        getSchema,
+        props.commands,
+    ]);
+    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, Object.assign({}, formInstance, { children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, {}), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), props.children] })) }));
+}

package/dist/dataform/context.d.ts

@@ -0,0 +1,22 @@
+import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { Data } from '@headless-adminapp/core/transport';
+import { Nullable } from '@headless-adminapp/core/types';
+export type DataFormContextState<SA extends SchemaAttributes = SchemaAttributes> = {
+    schema: Schema<SA>;
+    form: Form<SA>;
+    recordId?: string | number;
+    cloneId?: string | number;
+    commands: EntityMainFormCommandItemExperience[][];
+    activeTab?: string;
+    record?: Data<InferredSchemaType<SA>>;
+    cloneRecord?: Data<InferredSchemaType<SA>>;
+    isReadonly?: boolean;
+    dataState: {
+        isFetching: boolean;
+        isError?: boolean;
+    };
+    refresh: () => Promise<void>;
+    initialValues: Nullable<InferredSchemaType<SA>>;
+};
+export declare const DataFormContext: import("react").Context<import("../mutable").ContextValue<DataFormContextState<SchemaAttributes>>>;

package/dist/dataform/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFormContext = void 0;
+const mutable_1 = require("../mutable");
+exports.DataFormContext = (0, mutable_1.createContext)();

package/dist/dataform/hooks/index.d.ts

@@ -0,0 +1,11 @@
+export * from './useFormInstance';
+export * from './useFormIsDirty';
+export * from './useFormIsReadonly';
+export * from './useFormNotifications';
+export * from './useFormRecord';
+export * from './useFormSave';
+export * from './useFormSchema';
+export * from './useMainFormCommands';
+export * from './useRecordId';
+export * from './useRecordTitle';
+export * from './useSelectedForm';

package/dist/dataform/hooks/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./useFormInstance"), exports);
+__exportStar(require("./useFormIsDirty"), exports);
+__exportStar(require("./useFormIsReadonly"), exports);
+__exportStar(require("./useFormNotifications"), exports);
+__exportStar(require("./useFormRecord"), exports);
+__exportStar(require("./useFormSave"), exports);
+__exportStar(require("./useFormSchema"), exports);
+__exportStar(require("./useMainFormCommands"), exports);
+__exportStar(require("./useRecordId"), exports);
+__exportStar(require("./useRecordTitle"), exports);
+__exportStar(require("./useSelectedForm"), exports);

package/dist/dataform/hooks/useFormInstance.d.ts

@@ -0,0 +1 @@
+export declare function useFormInstance(): import("react-hook-form").UseFormReturn<import("react-hook-form").FieldValues, any, undefined>;

package/dist/dataform/hooks/useFormInstance.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormInstance = useFormInstance;
+const react_hook_form_1 = require("react-hook-form");
+function useFormInstance() {
+    const formInstance = (0, react_hook_form_1.useFormContext)();
+    return formInstance;
+}

package/dist/dataform/hooks/useFormIsDirty.d.ts

@@ -0,0 +1 @@
+export declare function useFormIsDirty(): boolean;

package/dist/dataform/hooks/useFormIsDirty.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormIsDirty = useFormIsDirty;
+const useFormInstance_1 = require("./useFormInstance");
+function useFormIsDirty() {
+    const formInstance = (0, useFormInstance_1.useFormInstance)();
+    return Object.keys(formInstance.formState.dirtyFields).length > 0;
+}

package/dist/dataform/hooks/useFormIsReadonly.d.ts

@@ -0,0 +1 @@
+export declare function useFormIsReadonly(): boolean | undefined;

package/dist/dataform/hooks/useFormIsReadonly.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormIsReadonly = useFormIsReadonly;
+const mutable_1 = require("../../mutable");
+const context_1 = require("../context");
+function useFormIsReadonly() {
+    const readonly = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.isReadonly);
+    return readonly;
+}

package/dist/dataform/hooks/useFormNotifications.d.ts

@@ -0,0 +1,4 @@
+export declare function useFormNotifications(): {
+    level: "info" | "warning" | "error";
+    message: string;
+}[];

package/dist/dataform/hooks/useFormNotifications.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFormNotifications = useFormNotifications;
+const react_1 = require("react");
+const useFormInstance_1 = require("./useFormInstance");
+const useFormIsReadonly_1 = require("./useFormIsReadonly");
+function useFormNotifications() {
+    const readonly = (0, useFormIsReadonly_1.useFormIsReadonly)();
+    const formInstance = (0, useFormInstance_1.useFormInstance)();
+    const formInstanceAvailable = !!formInstance;
+    return (0, react_1.useMemo)(() => {
+        const notifications = [];
+        if (readonly) {
+            notifications.push({
+                level: 'warning',
+                message: 'This record is read only',
+            });
+        }
+        if (formInstanceAvailable &&
+            formInstance.formState.isSubmitted &&
+            Object.keys(formInstance.formState.errors).length > 0) {
+            notifications.push({
+                level: 'error',
+                message: 'Please fill in the required fields',
+            });
+        }
+        return notifications;
+    }, [
+        formInstanceAvailable,
+        formInstance === null || formInstance === void 0 ? void 0 : formInstance.formState.errors,
+        formInstance === null || formInstance === void 0 ? void 0 : formInstance.formState.isSubmitted,
+        readonly,
+    ]);
+}

package/dist/dataform/hooks/useFormRecord.d.ts

@@ -0,0 +1 @@
+export declare function useFormRecord(): import("@headless-adminapp/core/transport").Data<import("@headless-adminapp/core/schema").InferredSchemaType<import("@headless-adminapp/core/schema").SchemaAttributes>> | undefined;

package/dist/dataform/hooks/useFormRecord.js

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

package/dist/dataform/hooks/useFormSave.d.ts

@@ -0,0 +1,2 @@
+import { SaveMode } from '@headless-adminapp/core/experience/form';
+export declare function useFormSave(): (mode?: SaveMode) => Promise<void>;

package/dist/dataform/hooks/useFormSave.js

@@ -0,0 +1,135 @@
+"use strict";
+// Steps
+// 1. Show the loading indicator
+// 2. Extract modified fields from the form
+// 3. Preapre operations
+// 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;
+const react_query_1 = require("@tanstack/react-query");
+const react_1 = require("react");
+const react_hook_form_1 = require("react-hook-form");
+const useMetadata_1 = require("../../metadata/hooks/useMetadata");
+const context_1 = require("../../mutable/context");
+const useProgressIndicator_1 = require("../../progress-indicator/hooks/useProgressIndicator");
+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");
+function useFormSave() {
+    const form = (0, useSelectedForm_1.useSelectedForm)();
+    const formInstance = (0, react_hook_form_1.useFormContext)();
+    const record = (0, useFormRecord_1.useFormRecord)();
+    const { getSchema } = (0, useMetadata_1.useMetadata)();
+    const schema = (0, useFormSchema_1.useDataFormSchema)();
+    const initialValues = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.initialValues);
+    const refresh = (0, context_1.useContextSelector)(context_2.DataFormContext, (state) => state.refresh);
+    const dataService = (0, transport_1.useDataService)();
+    const { showProgressIndicator, hideProgressIndicator } = (0, useProgressIndicator_1.useProgressIndicator)();
+    const openToastNotification = (0, useOpenToastNotification_1.useOpenToastNotification)();
+    const client = (0, react_query_1.useQueryClient)();
+    function showMessageAfterSave({ isCreatedMode }) {
+        // Show notification
+        if (!isCreatedMode) {
+            openToastNotification({
+                type: 'success',
+                title: 'Record updated',
+                text: 'Record updated successfully',
+            });
+        }
+        else {
+            openToastNotification({
+                type: 'success',
+                title: 'Record created',
+                text: 'Record created successfully',
+            });
+        }
+    }
+    const _save = (mode) => __awaiter(this, void 0, void 0, function* () {
+        yield formInstance.handleSubmit((values) => __awaiter(this, void 0, void 0, function* () {
+            if (mode === 'background' && !record) {
+                // Background save should not be triggered if there is no record
+                return;
+            }
+            if (mode !== 'background') {
+                showProgressIndicator(undefined, 500);
+            }
+            try {
+                const result = yield (0, utils_1.saveRecord)({
+                    values,
+                    form: form,
+                    record: record,
+                    initialValues: initialValues,
+                    dataService,
+                    schema: schema,
+                    getSchema,
+                });
+                if (!result.success) {
+                    openToastNotification({
+                        type: result.isError ? 'error' : 'info',
+                        title: 'Error',
+                        text: result.message,
+                    });
+                    return;
+                }
+                // invalidateQueriesAfterSave({
+                //   client,
+                // });
+                if (mode === 'save' && record) {
+                    yield refresh();
+                    // client.invalidateQueries({ queryKey: ['data', 'retriveRecord'] });
+                }
+                else {
+                    yield client.invalidateQueries({
+                        queryKey: ['data', 'retriveRecord'],
+                    });
+                }
+                yield client.invalidateQueries({
+                    queryKey: ['data', 'retriveRecords'],
+                });
+                // redirectAfterSave({
+                //   navigation,
+                //   isCreatedMode: !context.state.record,
+                //   recordId: result.recordId,
+                //   reset: form.reset,
+                //   logicalName: schema.logicalName,
+                //   mode,
+                // });
+                showMessageAfterSave({
+                    isCreatedMode: !record,
+                });
+            }
+            catch (err) {
+                openToastNotification({
+                    type: 'error',
+                    title: 'Error',
+                    text: err.message,
+                });
+            }
+            finally {
+                if (mode !== 'background') {
+                    // Hide the loading indicator
+                    hideProgressIndicator();
+                }
+            }
+        }))();
+    });
+    const _saveRef = (0, react_1.useRef)(_save);
+    _saveRef.current = _save;
+    const save = (0, react_1.useCallback)((mode) => _saveRef.current(mode), [_saveRef]);
+    return save;
+}

package/dist/dataform/hooks/useFormSchema.d.ts

@@ -0,0 +1,2 @@
+import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+export declare function useDataFormSchema<S extends SchemaAttributes = SchemaAttributes>(): Schema<S>;

package/dist/dataform/hooks/useFormSchema.js

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

package/dist/dataform/hooks/useLoadFormGridPage.d.ts

@@ -0,0 +1,18 @@
+import { EntityMainFormCommandItemExperience, Form } from '@headless-adminapp/core/experience/form';
+import { Schema } from '@headless-adminapp/core/schema';
+type UseLoadMainFormPageResult = {
+    loading: true;
+} | {
+    loading: false;
+    error: true;
+    title: string;
+    message: string;
+} | {
+    loading: false;
+    error: false;
+    schema: Schema;
+    form: Form;
+    commands: EntityMainFormCommandItemExperience[][];
+};
+export declare function useLoadFormGridPage(logicalName: string, formId: string | undefined): UseLoadMainFormPageResult;
+export {};