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

package/command/utils/index.js

@@ -8,8 +8,7 @@ function transformedProperties(command, handlerContext) {
     const disabled = (0, utils_1.checkCommandCondition)(handlerContext, command.disabled);
     const onClick = command.onClick
         ? () => {
-            var _a;
-            (_a = command.onClick(handlerContext)) === null || _a === void 0 ? void 0 : _a.catch(console.error);
+            command.onClick(handlerContext)?.catch(console.error);
         }
         : undefined;
     return {
@@ -23,11 +22,33 @@ function transformCommand(command, handlerContext) {
     const commandType = command.type;
     switch (command.type) {
         case 'icon':
-            return Object.assign({ type: command.type, isQuickAction: command.isQuickAction, danger: command.danger, iconPosition: command.iconPosition }, transformedProperties(command, handlerContext));
+            return {
+                type: command.type,
+                isQuickAction: command.isQuickAction,
+                danger: command.danger,
+                iconPosition: command.iconPosition,
+                ...transformedProperties(command, handlerContext),
+            };
         case 'button':
-            return Object.assign({ type: command.type, isQuickAction: command.isQuickAction, text: command.text, danger: command.danger, iconPosition: command.iconPosition, localizedTexts: command.localizedText }, transformedProperties(command, handlerContext));
+            return {
+                type: command.type,
+                isQuickAction: command.isQuickAction,
+                text: command.text,
+                danger: command.danger,
+                iconPosition: command.iconPosition,
+                localizedTexts: command.localizedText,
+                ...transformedProperties(command, handlerContext),
+            };
         case 'menu':
-            return Object.assign(Object.assign({ type: command.type, text: command.text, danger: command.danger, localizedTexts: command.localizedTexts, iconPosition: command.iconPosition }, transformedProperties(command, handlerContext)), { items: command.items.map((item) => transformMenuItems(item, handlerContext)) });
+            return {
+                type: command.type,
+                text: command.text,
+                danger: command.danger,
+                localizedTexts: command.localizedTexts,
+                iconPosition: command.iconPosition,
+                ...transformedProperties(command, handlerContext),
+                items: command.items.map((item) => transformMenuItems(item, handlerContext)),
+            };
         default:
             throw new Error(`Unknown command type: ${commandType}`);
     }
@@ -36,14 +57,18 @@ function transformMenuItems(items, handlerContext) {
     return items.map((item) => transformMenuItem(item, handlerContext));
 }
 function transformMenuItem(item, handlerContext) {
-    var _a;
-    return Object.assign(Object.assign({ danger: item.danger, text: item.text, localizedTexts: item.localizedTexts }, transformedProperties(item, handlerContext)), { items: (_a = item.items) === null || _a === void 0 ? void 0 : _a.map((item) => transformMenuItems(item, handlerContext)) });
+    return {
+        danger: item.danger,
+        text: item.text,
+        localizedTexts: item.localizedTexts,
+        ...transformedProperties(item, handlerContext),
+        items: item.items?.map((item) => transformMenuItems(item, handlerContext)),
+    };
 }
 function transformCommandGroup(group, handlerContext, selector) {
     return group
         .map((command) => {
-        var _a;
-        if (!((_a = selector === null || selector === void 0 ? void 0 : selector(command)) !== null && _a !== void 0 ? _a : true)) {
+        if (!(selector?.(command) ?? true)) {
             return false; // Skip command
         }
         const transformedCommand = transformCommand(command, handlerContext);

package/components/ScrollView/index.d.ts

@@ -1,5 +1,5 @@
 import { FC, PropsWithChildren } from 'react';
-import { ScrollbarProps } from 'react-custom-scrollbars-2';
+import { type ScrollbarProps } from 'react-custom-scrollbars-2';
 interface ScrollViewProps {
     className?: string;
     autoHide?: boolean;

package/components/ScrollView/index.js

@@ -6,6 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScrollView = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const clsx_1 = __importDefault(require("clsx"));
-const react_custom_scrollbars_2_1 = __importDefault(require("react-custom-scrollbars-2"));
-const ScrollView = ({ children, className, rtl, autoHide, onScroll, }) => ((0, jsx_runtime_1.jsx)(react_custom_scrollbars_2_1.default, { autoHide: autoHide, className: (0, clsx_1.default)(className, 'hdl-scrollbar', rtl && 'rtl'), onScroll: onScroll, children: children }));
+const react_custom_scrollbars_2_1 = require("react-custom-scrollbars-2");
+const ScrollView = ({ children, className, rtl, autoHide, onScroll, }) => ((0, jsx_runtime_1.jsx)(react_custom_scrollbars_2_1.Scrollbars, { autoHide: autoHide, className: (0, clsx_1.default)(className, 'hdl-scrollbar', rtl && 'rtl'), onScroll: onScroll, children: children }));
 exports.ScrollView = ScrollView;

package/components/ScrollbarWithMoreDataRequest/index.d.ts

@@ -0,0 +1,9 @@
+import { FC, PropsWithChildren } from 'react';
+interface ScrollbarWithMoreDataRequest {
+    data: any;
+    hasMore: boolean;
+    onRequestMore: () => void;
+    rtl?: boolean;
+}
+export declare const ScrollbarWithMoreDataRequest: FC<PropsWithChildren<ScrollbarWithMoreDataRequest>>;
+export {};

package/components/ScrollbarWithMoreDataRequest/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollbarWithMoreDataRequest = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const ScrollView_1 = require("../ScrollView");
+function getReaminingSpace(div) {
+    return div.scrollHeight - div.scrollTop - div.clientHeight;
+}
+const ScrollbarWithMoreDataRequest = ({ data, onRequestMore, hasMore, children, rtl }) => {
+    const divRef = (0, react_1.useRef)(null);
+    const onRequestMoreRef = (0, react_1.useRef)(onRequestMore);
+    onRequestMoreRef.current = onRequestMore;
+    (0, react_1.useEffect)(() => {
+        const div = divRef.current?.parentElement;
+        if (!div) {
+            return;
+        }
+        const remainingSpace = getReaminingSpace(div);
+        if (remainingSpace <= 0 && hasMore) {
+            onRequestMoreRef.current();
+        }
+    }, [data, hasMore]);
+    return ((0, jsx_runtime_1.jsx)(ScrollView_1.ScrollView, { autoHide: true, rtl: rtl, onScroll: (e) => {
+            const div = e.target;
+            const remainingSpace = getReaminingSpace(div);
+            if (remainingSpace <= 0 && hasMore) {
+                onRequestMoreRef.current();
+            }
+        }, children: (0, jsx_runtime_1.jsx)("div", { ref: divRef, children: children }) }));
+};
+exports.ScrollbarWithMoreDataRequest = ScrollbarWithMoreDataRequest;

package/dataform/DataFormProvider/CustomHookExecuter.d.ts

@@ -0,0 +1,5 @@
+interface CustomHookExecuterProps {
+    useHookFn: (() => void) | undefined | null;
+}
+export declare function CustomHookExecuter({ useHookFn, }: Readonly<CustomHookExecuterProps>): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dataform/DataFormProvider/CustomHookExecuter.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomHookExecuter = CustomHookExecuter;
+const jsx_runtime_1 = require("react/jsx-runtime");
+function CustomHookExecuter({ useHookFn, }) {
+    if (!useHookFn) {
+        return null;
+    }
+    return (0, jsx_runtime_1.jsx)(CustomHookExecuterInternal, { useHookFn: useHookFn });
+}
+function CustomHookExecuterInternal({ useHookFn, }) {
+    useHookFn();
+    return null;
+}

package/dataform/DataFormProvider/DataResolver.d.ts

@@ -1,5 +1,7 @@
-import { Form } from '@headless-adminapp/core/experience/form';
 import { SchemaAttributes } from '@headless-adminapp/core/schema';
-export declare function getControls(form: Form): (import("@headless-adminapp/core/experience/form/SectionControl").SectionSubgridControl | import("@headless-adminapp/core/experience/form/SectionControl").SectionQuickViewControl<SchemaAttributes> | import("@headless-adminapp/core/experience/form").SectionEditableGridControl<SchemaAttributes> | import("@headless-adminapp/core/experience/form/SectionControl").SectionSpacerControl | import("@headless-adminapp/core/experience/form/SectionControl").SectionStatndardControl<SchemaAttributes>)[];
-export declare function getColumns(form: Form): string[];
-export declare function DataResolver(): null;
+import { RetriveRecordFn } from './types';
+interface DataResolverProps<SA extends SchemaAttributes> {
+    retriveRecordFn: RetriveRecordFn<SA>;
+}
+export declare function DataResolver<SA extends SchemaAttributes>({ retriveRecordFn, }: DataResolverProps<SA>): null;
+export {};

package/dataform/DataFormProvider/DataResolver.js

@@ -1,113 +1,30 @@
 "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 transport_1 = 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, schemaStore, }) {
-        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 = schemaStore.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 utils_1 = require("./utils");
+function DataResolver({ retriveRecordFn, }) {
     const schema = (0, hooks_2.useDataFormSchema)();
     const form = (0, hooks_2.useSelectedForm)();
-    const dataService = (0, transport_2.useDataService)();
+    const dataService = (0, transport_1.useDataService)();
     const recordId = (0, hooks_2.useRecordId)();
     const { schemaStore } = (0, hooks_1.useMetadata)();
     const setState = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);
-    const columns = (0, react_1.useMemo)(() => getColumns(form), [form]);
+    const columns = (0, react_1.useMemo)(() => (0, utils_1.getColumns)(form, schema), [form, schema]);
     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* () {
+        queryFn: async () => {
             if (!recordId) {
                 return null;
             }
-            const record = getRecord({
+            const record = retriveRecordFn({
                 columns,
                 dataService,
                 form,
@@ -116,7 +33,7 @@ function DataResolver() {
                 schemaStore,
             });
             return record;
-        }),
+        },
         placeholderData: react_query_1.keepPreviousData,
         staleTime: 1000 * 60 * 5, // 5 minutes
     });
@@ -134,9 +51,9 @@ function DataResolver() {
     }, [isPending, setState]);
     (0, react_1.useEffect)(() => {
         setState({
-            refresh: () => __awaiter(this, void 0, void 0, function* () {
-                yield refetch();
-            }),
+            refresh: async () => {
+                await refetch();
+            },
         });
     }, [refetch, setState]);
     return null;

package/dataform/DataFormProvider/InitialValueResolver.js

@@ -6,6 +6,7 @@ const mutable_1 = require("../../mutable");
 const context_1 = require("../context");
 const hooks_1 = require("../hooks");
 const utils_1 = require("../utils");
+const defaultParameters_1 = require("../utils/defaultParameters");
 function InitialValueResolver() {
     const formConfig = (0, hooks_1.useSelectedForm)();
     const schema = (0, hooks_1.useDataFormSchema)();
@@ -13,14 +14,14 @@ function InitialValueResolver() {
     const record = (0, mutable_1.useContextSelector)(context_1.DataFormContext, (state) => state.record);
     const formInstance = (0, hooks_1.useFormInstance)();
     const initialValues = (0, react_1.useMemo)(() => {
+        const defaultParameters = (0, defaultParameters_1.getFormDefaultParameters)(schema, formConfig.experience) ?? {};
         return (0, utils_1.getInitialValues)({
             cloneRecord: undefined,
             form: formConfig,
             record: record,
             recordId: recordId,
             schema: schema,
-            defaultParameters: {},
-            // defaultParameters,
+            defaultParameters,
         });
     }, [formConfig, record, recordId, schema]);
     const setValue = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);

package/dataform/DataFormProvider/ReadonlyInfoResolver.js

@@ -6,14 +6,13 @@ 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) {
+    if (schema.restrictions?.disableCreate && !recordId) {
         readonly = true;
     }
-    if (((_b = schema.restrictions) === null || _b === void 0 ? void 0 : _b.disableUpdate) && recordId) {
+    if (schema.restrictions?.disableUpdate && recordId) {
         readonly = true;
     }
     const setValue = (0, mutable_1.useContextSetValue)(context_1.DataFormContext);

package/dataform/DataFormProvider/getRecord.d.ts

@@ -0,0 +1,3 @@
+import { SchemaAttributes } from '@headless-adminapp/core/schema';
+import { RetriveRecordFnOptions } from './types';
+export declare function getRecord<SA extends SchemaAttributes = SchemaAttributes>({ recordId, dataService, form, schema, columns, schemaStore, }: RetriveRecordFnOptions<SA>): Promise<import("@headless-adminapp/core/transport").Data<SA> | null>;

package/dataform/DataFormProvider/getRecord.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecord = getRecord;
+const transport_1 = require("@headless-adminapp/core/transport");
+const utils_1 = require("./utils");
+async function getRecord({ recordId, dataService, form, schema, columns, schemaStore, }) {
+    let record = null;
+    try {
+        record = await 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 = (0, utils_1.getControls)(form);
+    const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
+    for (const control of editableGridControls) {
+        if (control.type !== 'editablegrid') {
+            continue;
+        }
+        const controlSchema = schemaStore.getSchema(control.logicalName);
+        const records = await dataService.retriveRecords({
+            logicalName: controlSchema.logicalName,
+            filter: {
+                type: 'and',
+                conditions: [
+                    {
+                        field: control.referenceAttribute,
+                        operator: 'eq',
+                        value: recordId,
+                    },
+                ],
+            },
+            sort: [
+                {
+                    field: controlSchema.createdAtAttribute ?? controlSchema.idAttribute,
+                    order: 'asc',
+                },
+            ],
+            limit: 5000,
+            search: '',
+            columns: [
+                controlSchema.idAttribute,
+                control.referenceAttribute,
+                ...control.attributes,
+            ],
+        });
+        record[control.attributeName] = records.records;
+    }
+    return record;
+}

package/dataform/DataFormProvider/index.d.ts

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

package/dataform/DataFormProvider/index.js

@@ -1,16 +1,8 @@
 "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 store_1 = require("@headless-adminapp/app/store");
 const react_1 = require("react");
 const react_hook_form_1 = require("react-hook-form");
 const FormValidationStringContext_1 = require("../../form/FormValidationStringContext");
@@ -19,13 +11,19 @@ const useMetadata_1 = require("../../metadata/hooks/useMetadata");
 const mutable_1 = require("../../mutable");
 const context_1 = require("../context");
 const utils_1 = require("../utils");
+const saveRecord_1 = require("../utils/saveRecord");
+const CustomHookExecuter_1 = require("./CustomHookExecuter");
 const DataResolver_1 = require("./DataResolver");
+const getRecord_1 = require("./getRecord");
 const InitialValueResolver_1 = require("./InitialValueResolver");
 const ReadonlyInfoResolver_1 = require("./ReadonlyInfoResolver");
+const utils_2 = require("./utils");
 function DataFormProvider(props) {
     const { schemaStore } = (0, useMetadata_1.useMetadata)();
-    const { language } = (0, useLocale_1.useLocale)();
+    const { language, region } = (0, useLocale_1.useLocale)();
     const formValidationStrings = (0, FormValidationStringContext_1.useFormValidationStrings)();
+    const eventManager = (0, react_1.useMemo)(() => new store_1.EventManager(), []);
+    const contextKey = (0, react_1.useRef)(0);
     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',
@@ -37,28 +35,52 @@ function DataFormProvider(props) {
             schema: props.schema,
             strings: formValidationStrings,
             formReadOnly,
+            region,
         }),
         shouldUnregister: false,
     });
+    const saveRecordFnRef = (0, react_1.useRef)(props.saveRecordFn);
+    saveRecordFnRef.current = props.saveRecordFn;
+    const saveRecordFnInternal = (0, react_1.useCallback)(async (options) => {
+        return saveRecordFnRef.current
+            ? saveRecordFnRef.current(options)
+            : (0, saveRecord_1.saveRecord)(options);
+    }, []);
     const contextValue = (0, mutable_1.useCreateContextStore)({
+        contextKey: contextKey.current,
         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
+        refresh: async () => { }, // Initial value, will be overridden
         cloneId: undefined,
         // formInstance,
         // formInstanceRenderCount: 0,
         initialValues: {},
+        saveRecordFn: saveRecordFnInternal,
+        eventManager,
+        disabledControls: {},
+        requiredFields: {},
+        hiddenControls: {},
+        hiddenSections: {},
+        hiddenTabs: {},
+        formInternal: (0, utils_2.transformFormInternal)(props.form),
     });
     (0, react_1.useEffect)(() => {
         contextValue.setValue({
+            contextKey: ++contextKey.current,
             form: props.form,
             schema: props.schema,
             recordId: props.recordId,
             cloneId: undefined,
             commands: props.commands,
+            disabledControls: {},
+            requiredFields: {},
+            hiddenControls: {},
+            hiddenSections: {},
+            hiddenTabs: {},
+            formInternal: (0, utils_2.transformFormInternal)(props.form),
         });
     }, [
         props.form,
@@ -68,5 +90,5 @@ function DataFormProvider(props) {
         schemaStore,
         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] })) }));
+    return ((0, jsx_runtime_1.jsx)(context_1.DataFormContext.Provider, { value: contextValue, children: (0, jsx_runtime_1.jsxs)(react_hook_form_1.FormProvider, { ...formInstance, children: [(0, jsx_runtime_1.jsx)(DataResolver_1.DataResolver, { retriveRecordFn: props.retriveRecordFn ?? getRecord_1.getRecord }), (0, jsx_runtime_1.jsx)(InitialValueResolver_1.InitialValueResolver, {}), (0, jsx_runtime_1.jsx)(ReadonlyInfoResolver_1.ReadonlyInfoResolver, { setFormReadOnly: setFormReadOnly }), (0, jsx_runtime_1.jsx)(CustomHookExecuter_1.CustomHookExecuter, { useHookFn: props.form.experience.useHookFn }), props.children] }) }));
 }

package/dataform/DataFormProvider/types.d.ts

@@ -0,0 +1,13 @@
+import { Form } from '@headless-adminapp/core/experience/form';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { Data, IDataService } from '@headless-adminapp/core/transport';
+export type RetriveRecordFnOptions<SA extends SchemaAttributes> = {
+    recordId: string;
+    dataService: IDataService;
+    form: Form<SA>;
+    schema: Schema<SA>;
+    columns: (keyof SA)[];
+    schemaStore: ISchemaStore;
+};
+export type RetriveRecordFn<SA extends SchemaAttributes> = (options: RetriveRecordFnOptions<SA>) => Promise<Data<InferredSchemaType<SA>>>;

package/dataform/DataFormProvider/types.js

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

package/dataform/DataFormProvider/utils.d.ts

@@ -0,0 +1,23 @@
+import { AttributeBase } from '@headless-adminapp/core/attributes/AttributeBase';
+import { Form, Section } from '@headless-adminapp/core/experience/form';
+import { SectionControl, SectionStatndardControl } from '@headless-adminapp/core/experience/form/SectionControl';
+import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { DataFormContextState } from '../context';
+export declare function getControls<SA extends SchemaAttributes>(form: Form<SA>): SectionControl<SA>[];
+export declare function getColumns<SA extends SchemaAttributes>(form: Form<SA>, schema: Schema<SA>): (keyof SA)[];
+export declare function transformFormInternal<SA extends SchemaAttributes>(form: Form<SA>): DataFormContextState<SA>['formInternal'];
+export declare function getIsFieldDisabled<S extends SchemaAttributes = SchemaAttributes>({ attribute, isFormReadonly, disabledFields, control, }: {
+    attribute: AttributeBase;
+    isFormReadonly: boolean | undefined;
+    disabledFields: Record<string, boolean>;
+    control: Section<S>['controls'][0];
+}): boolean;
+export declare function getIsControlHidden<S extends SchemaAttributes = SchemaAttributes>({ control, hiddenControls, }: {
+    hiddenControls: Record<string, boolean>;
+    control: Section<S>['controls'][0];
+}): boolean;
+export declare function getIsFieldRequired<S extends SchemaAttributes = SchemaAttributes>({ attribute, control, requiredFields, }: {
+    attribute: AttributeBase;
+    requiredFields: Record<string, boolean>;
+    control: SectionStatndardControl<S>;
+}): boolean;