@headless-adminapp/app 0.0.17-alpha.4 → 0.0.17-alpha.7

package/builders/CommandBuilder.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandBuilder = void 0;
 exports.localizedLabel = localizedLabel;
 exports.createLocalizedSelector = createLocalizedSelector;
+const utils_1 = require("./utils");
 function localizedLabel(language, value, fallback) {
     var _a, _b, _c, _d, _e;
     return ((_e = (_d = (_b = (_a = value.localizedLabels) === null || _a === void 0 ? void 0 : _a[language]) !== null && _b !== void 0 ? _b : (_c = fallback === null || fallback === void 0 ? void 0 : fallback.localizedLabels) === null || _c === void 0 ? void 0 : _c[language]) !== null && _d !== void 0 ? _d : value.label) !== null && _e !== void 0 ? _e : fallback === null || fallback === void 0 ? void 0 : fallback.label);
@@ -28,6 +29,32 @@ var CommandBuilder;
 (function (CommandBuilder) {
     let View;
     (function (View) {
+        let EnabledRules;
+        (function (EnabledRules) {
+            function HasCreatePermisssion(context) {
+                var _a;
+                return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableCreate);
+            }
+            EnabledRules.HasCreatePermisssion = HasCreatePermisssion;
+            function HasUpdatePermission(context) {
+                var _a;
+                return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableUpdate);
+            }
+            EnabledRules.HasUpdatePermission = HasUpdatePermission;
+            function HasDeletePermission(context) {
+                var _a;
+                return !((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableDelete);
+            }
+            EnabledRules.HasDeletePermission = HasDeletePermission;
+            function HasSingleRecordSelected(context) {
+                return context.primaryControl.selectedIds.length === 1;
+            }
+            EnabledRules.HasSingleRecordSelected = HasSingleRecordSelected;
+            function HasAtLeastOneRecordSelected(context) {
+                return context.primaryControl.selectedIds.length > 0;
+            }
+            EnabledRules.HasAtLeastOneRecordSelected = HasAtLeastOneRecordSelected;
+        })(EnabledRules || (EnabledRules = {}));
         function createNewRecordCommand({ Icon, text, localizedTexts, }) {
             return {
                 type: 'button',
@@ -35,11 +62,14 @@ var CommandBuilder;
                 text,
                 localizedText: localizedTexts,
                 onClick: (context) => {
-                    console.log('New record', context);
+                    context.navigation.openForm({
+                        logicalName: context.primaryControl.schema.logicalName,
+                    });
                 },
                 hidden: (context) => {
-                    console.log(context);
-                    // TODO: Implement logic to hide the button
+                    if (!EnabledRules.HasCreatePermisssion(context)) {
+                        return true;
+                    }
                     return false;
                 },
             };
@@ -53,9 +83,17 @@ var CommandBuilder;
                 localizedText: localizedTexts,
                 isContextMenu: true,
                 onClick: (context) => {
-                    console.log('Edit record', context);
+                    context.primaryControl.openRecord(context.primaryControl.selectedIds[0]);
+                },
+                hidden: (context) => {
+                    if (!EnabledRules.HasUpdatePermission(context)) {
+                        return true;
+                    }
+                    if (!EnabledRules.HasSingleRecordSelected(context)) {
+                        return true;
+                    }
+                    return false;
                 },
-                hidden: (context) => context.primaryControl.selectedIds.length !== 1, // TODO: check permissions
             };
         }
         View.createEditRecordCommand = createEditRecordCommand;
@@ -97,7 +135,6 @@ var CommandBuilder;
                 localizedText,
                 danger: true,
                 isContextMenu: true,
-                hidden: [(context) => context.primaryControl.selectedIds.length === 0], // TODO: check permissions
                 onClick: (context) => __awaiter(this, void 0, void 0, function* () {
                     const recordIds = context.primaryControl.selectedIds;
                     if (!recordIds.length) {
@@ -115,7 +152,9 @@ var CommandBuilder;
                             return;
                         }
                         context.utility.showProgressIndicator(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
-                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        for (const recordId of recordIds) {
+                            yield context.dataService.deleteRecord(context.primaryControl.logicalName, recordId);
+                        }
                         context.utility.showNotification({
                             title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
                             text: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.text)),
@@ -134,6 +173,10 @@ var CommandBuilder;
                         context.utility.hideProgressIndicator();
                     }
                 }),
+                hidden: [
+                    (context) => !EnabledRules.HasAtLeastOneRecordSelected(context),
+                    (context) => !EnabledRules.HasDeletePermission(context),
+                ],
             };
         }
         View.createDeleteRecordCommand = createDeleteRecordCommand;
@@ -161,17 +204,67 @@ var CommandBuilder;
                             Icon: excel.Icon,
                             text: excel.text,
                             localizedTexts: excel.localizedTexts,
-                            onClick: (context) => {
-                                console.log('Export to Excel', context);
-                            },
+                            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                                context.utility.showProgressIndicator('Exporting to Excel...');
+                                try {
+                                    const result = yield (0, utils_1.retriveRecords)({
+                                        columnFilters: context.primaryControl.columnFilter,
+                                        dataService: context.dataService,
+                                        gridColumns: context.primaryControl.gridColumns,
+                                        schema: context.primaryControl.schema,
+                                        schemaStore: context.stores.schemaStore,
+                                        view: context.primaryControl.view,
+                                        search: context.primaryControl.searchText,
+                                        extraFilter: context.primaryControl.extraFilter,
+                                        sorting: context.primaryControl.sorting,
+                                        skip: 0,
+                                        limit: 5000,
+                                    });
+                                    yield (0, utils_1.exportRecordsXLS)({
+                                        fileName: context.primaryControl.view.name + '.xlsx',
+                                        gridColumns: context.primaryControl.gridColumns,
+                                        records: result.records,
+                                        schema: context.primaryControl.schema,
+                                        schemaStore: context.stores.schemaStore,
+                                    });
+                                }
+                                finally {
+                                    context.utility.hideProgressIndicator();
+                                }
+                            }),
                         },
                         {
                             Icon: csv.Icon,
                             text: csv.text,
                             localizedTexts: csv.localizedTexts,
-                            onClick: (context) => {
-                                console.log('Export to CSV', context);
-                            },
+                            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                                context.utility.showProgressIndicator('Exporting to Excel...');
+                                try {
+                                    const result = yield (0, utils_1.retriveRecords)({
+                                        columnFilters: context.primaryControl.columnFilter,
+                                        dataService: context.dataService,
+                                        gridColumns: context.primaryControl.gridColumns,
+                                        schema: context.primaryControl.schema,
+                                        schemaStore: context.stores.schemaStore,
+                                        view: context.primaryControl.view,
+                                        search: context.primaryControl.searchText,
+                                        extraFilter: context.primaryControl.extraFilter,
+                                        sorting: context.primaryControl.sorting,
+                                        skip: 0,
+                                        limit: 5000,
+                                    });
+                                    yield (0, utils_1.exportRecordsCSV)({
+                                        fileName: context.primaryControl.view.name + '.csv',
+                                        gridColumns: context.primaryControl.gridColumns,
+                                        records: result.records,
+                                        schema: context.primaryControl.schema,
+                                        schemaStore: context.stores.schemaStore,
+                                    });
+                                }
+                                finally {
+                                    context.utility.hideProgressIndicator();
+                                }
+                            }),
                         },
                     ],
                 ],

package/builders/utils.d.ts

@@ -0,0 +1,28 @@
+import { ColumnCondition, SortingState, View } from '@headless-adminapp/core/experience/view';
+import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { Filter, IDataService } from '@headless-adminapp/core/transport';
+import { TransformedViewColumn } from '../datagrid';
+type ExportFn<S extends SchemaAttributes = SchemaAttributes> = (option: {
+    schema: Schema<S>;
+    records: unknown[];
+    gridColumns: TransformedViewColumn<SchemaAttributes>[];
+    schemaStore: ISchemaStore;
+    fileName: string;
+}) => Promise<void>;
+export declare const exportRecordsCSV: ExportFn;
+export declare const exportRecordsXLS: ExportFn;
+export declare function retriveRecords<S extends SchemaAttributes = SchemaAttributes>({ gridColumns, dataService, schema, search, view, extraFilter, columnFilters, schemaStore, sorting, skip, limit, }: {
+    gridColumns: TransformedViewColumn<SchemaAttributes>[];
+    dataService: IDataService;
+    schema: Schema<S>;
+    search?: string;
+    view: View<S>;
+    extraFilter?: Filter;
+    columnFilters?: Partial<Record<string, ColumnCondition>>;
+    schemaStore: ISchemaStore;
+    sorting: SortingState<S>;
+    skip: number;
+    limit: number;
+}): Promise<import("@headless-adminapp/core/transport").RetriveRecordsResult<InferredSchemaType<S>>>;
+export {};

package/builders/utils.js

@@ -0,0 +1,185 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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.exportRecordsXLS = exports.exportRecordsCSV = void 0;
+exports.retriveRecords = retriveRecords;
+const utils_1 = require("../datagrid/DataGridProvider/utils");
+const utils_2 = require("../utils");
+const getHeaders = (schema, gridColumns, schemaStore) => {
+    const headers = gridColumns.map((column) => {
+        var _a, _b, _c;
+        if (column.name.indexOf('.') !== -1) {
+            const [lookup, field] = column.name.split('.');
+            const entity = schema.attributes[lookup].entity;
+            const lookupSchema = schemaStore.getSchema(entity);
+            return `${(_a = lookupSchema.attributes[field]) === null || _a === void 0 ? void 0 : _a.label} (${(_b = schema.attributes[lookup]) === null || _b === void 0 ? void 0 : _b.label})`;
+        }
+        return (_c = schema.attributes[column.name]) === null || _c === void 0 ? void 0 : _c.label;
+    });
+    return headers;
+};
+function getAttribute({ column, schema, schemaStore, }) {
+    let attribute;
+    if (column.expandedKey) {
+        const lookup = column.name;
+        const field = column.expandedKey;
+        const entity = schema.attributes[lookup].entity;
+        const lookupSchema = schemaStore.getSchema(entity);
+        attribute = lookupSchema.attributes[field];
+    }
+    else {
+        attribute = schema.attributes[column.name];
+    }
+    return attribute;
+}
+function extractAttributeData({ column, record, schema, schemaStore, }) {
+    var _a, _b;
+    const attribute = getAttribute({ column, schema, schemaStore });
+    let value;
+    if (column.expandedKey) {
+        const lookup = column.name;
+        const field = column.expandedKey;
+        value = (_b = (_a = record.$expand) === null || _a === void 0 ? void 0 : _a[lookup]) === null || _b === void 0 ? void 0 : _b[field];
+    }
+    else {
+        value = record[column.name];
+    }
+    return {
+        attribute,
+        value,
+    };
+}
+const exportRecordsCSV = (_a) => __awaiter(void 0, [_a], void 0, function* ({ schema, records, gridColumns, schemaStore, fileName, }) {
+    const csvDownload = yield Promise.resolve().then(() => __importStar(require('json-to-csv-export')));
+    const headers = getHeaders(schema, gridColumns, schemaStore);
+    const cellData = records.map((record) => {
+        return gridColumns.map((column) => {
+            var _a, _b;
+            const { attribute, value } = extractAttributeData({
+                column,
+                record,
+                schema,
+                schemaStore,
+            });
+            if (attribute.type === 'money' || attribute.type === 'number') {
+                return (_a = value === null || value === void 0 ? void 0 : value.toString()) !== null && _a !== void 0 ? _a : '';
+            }
+            return (_b = (0, utils_2.getAttributeFormattedValue)(attribute, value)) !== null && _b !== void 0 ? _b : '';
+        });
+    });
+    csvDownload.default({
+        headers,
+        data: cellData,
+        delimiter: ',',
+        filename: fileName,
+    });
+});
+exports.exportRecordsCSV = exportRecordsCSV;
+const exportRecordsXLS = (_a) => __awaiter(void 0, [_a], void 0, function* ({ fileName, gridColumns, records, schema, schemaStore, }) {
+    const ExcelJS = yield Promise.resolve().then(() => __importStar(require('exceljs')));
+    const headers = getHeaders(schema, gridColumns, schemaStore);
+    const cellData = records.map((item) => {
+        return gridColumns.map((column) => {
+            const { attribute, value } = extractAttributeData({
+                column,
+                record: item,
+                schema,
+                schemaStore,
+            });
+            if (!value) {
+                return '';
+            }
+            switch (attribute === null || attribute === void 0 ? void 0 : attribute.type) {
+                case 'money':
+                case 'number':
+                    return value;
+                case 'date':
+                    return value ? new Date(value) : undefined;
+                default:
+                    return (0, utils_2.getAttributeFormattedValue)(attribute, value);
+            }
+        });
+    });
+    const workbook = new ExcelJS.Workbook();
+    const worksheet = workbook.addWorksheet('Sheet1');
+    worksheet.addRow(headers);
+    const headerRow = worksheet.getRow(1);
+    headerRow.font = { bold: true };
+    cellData.forEach((row) => {
+        worksheet.addRow(row);
+    });
+    gridColumns.forEach((column, index) => {
+        const attribute = getAttribute({ column, schema, schemaStore });
+        const sheetColumn = worksheet.getColumn(index + 1);
+        let formatFn = (value) => { var _a; return (_a = (0, utils_2.getAttributeFormattedValue)(attribute, value)) !== null && _a !== void 0 ? _a : ''; };
+        if ((attribute === null || attribute === void 0 ? void 0 : attribute.type) === 'money') {
+            sheetColumn.numFmt = '"₹" #,##0.00';
+        }
+        let maxLength = 0;
+        sheetColumn.eachCell((cell) => {
+            const length = formatFn(cell.value).length;
+            if (length > maxLength) {
+                maxLength = length;
+            }
+        });
+        sheetColumn.width = Math.max(maxLength, 10) * 1.2;
+    });
+    // Generate the Excel file
+    const buffer = yield workbook.xlsx.writeBuffer();
+    var blob = new Blob([buffer], {
+        type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    });
+    var link = document.createElement('a');
+    link.href = window.URL.createObjectURL(blob);
+    link.download = fileName;
+    link.click();
+});
+exports.exportRecordsXLS = exportRecordsXLS;
+function retriveRecords(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ gridColumns, dataService, schema, search, view, extraFilter, columnFilters, schemaStore, sorting, skip, limit, }) {
+        const expand = (0, utils_1.collectExpandedKeys)(gridColumns);
+        const columns = Array.from(new Set([...gridColumns.filter((x) => !x.expandedKey).map((x) => x.name)]));
+        const result = yield dataService.retriveRecords({
+            logicalName: schema.logicalName,
+            search,
+            columns: columns,
+            expand,
+            filter: (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, columnFilters, schemaStore),
+            skip,
+            limit,
+            sort: sorting,
+        });
+        return result;
+    });
+}

package/command/hooks/useBaseCommandHandlerContext.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useUtility = useUtility;
 exports.useBaseCommandHandlerContext = useBaseCommandHandlerContext;
+const navigation_1 = require("@headless-adminapp/app/navigation");
 const react_query_1 = require("@tanstack/react-query");
 const hooks_1 = require("../../dialog/hooks");
 const locale_1 = require("../../locale");
@@ -26,17 +27,25 @@ function useUtility() {
         showNotification: openToastNotification,
     };
 }
+function useNavigation() {
+    const openForm = (0, navigation_1.useOpenForm)();
+    return {
+        openForm,
+    };
+}
 function useBaseCommandHandlerContext() {
     const dataService = (0, transport_1.useDataService)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const stores = (0, hooks_2.useMetadata)();
     const utility = useUtility();
     const locale = (0, locale_1.useLocale)();
+    const navigation = useNavigation();
     return {
         dataService,
         queryClient,
         utility,
         stores,
         locale,
+        navigation,
     };
 }

package/dataform/DataFormProvider/DataResolver.js

@@ -39,7 +39,7 @@ function getColumns(form) {
     return columns;
 }
 function getRecord(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ recordId, dataService, form, schema, columns, getSchema, }) {
+    return __awaiter(this, arguments, void 0, function* ({ recordId, dataService, form, schema, columns, schemaStore, }) {
         var _b;
         let record = null;
         try {
@@ -60,7 +60,7 @@ function getRecord(_a) {
             if (control.type !== 'editablegrid') {
                 continue;
             }
-            const controlSchema = getSchema(control.logicalName);
+            const controlSchema = schemaStore.getSchema(control.logicalName);
             const records = yield dataService.retriveRecords({
                 logicalName: controlSchema.logicalName,
                 filter: {
@@ -97,7 +97,7 @@ function DataResolver() {
     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 { schemaStore } = (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]);
@@ -113,7 +113,7 @@ function DataResolver() {
                 form,
                 recordId,
                 schema,
-                getSchema,
+                schemaStore,
             });
             return record;
         }),

package/dataform/DataFormProvider/index.js

@@ -23,7 +23,7 @@ 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 { schemaStore } = (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
@@ -32,7 +32,7 @@ function DataFormProvider(props) {
         defaultValues: {},
         resolver: (0, utils_1.formValidator)({
             form: props.form,
-            getSchema,
+            schemaStore,
             language,
             schema: props.schema,
             strings: formValidationStrings,
@@ -65,7 +65,7 @@ function DataFormProvider(props) {
         props.schema,
         props.recordId,
         contextValue,
-        getSchema,
+        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] })) }));

package/dataform/hooks/useFormSave.js

@@ -34,7 +34,7 @@ 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 { schemaStore } = (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);
@@ -76,7 +76,7 @@ function useFormSave() {
                     initialValues: initialValues,
                     dataService,
                     schema: schema,
-                    getSchema,
+                    schemaStore,
                 });
                 if (!result.success) {
                     openToastNotification({

package/dataform/utils/index.d.ts

@@ -1,6 +1,7 @@
 import type { Attribute } from '@headless-adminapp/core/attributes';
 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 { IDataService } from '@headless-adminapp/core/transport';
 import { Nullable } from '@headless-adminapp/core/types';
 import { MemoizedFunction } from 'lodash';
@@ -17,14 +18,14 @@ type SaveRecordResult = {
     message: string;
     isError: boolean;
 };
-export declare function saveRecord({ values, form, schema, dataService, initialValues, record, getSchema, }: {
+export declare function saveRecord({ values, form, schema, dataService, initialValues, record, schemaStore, }: {
     values: any;
     form: Form<SchemaAttributes>;
     record: InferredSchemaType<SchemaAttributes> | undefined;
     initialValues: Nullable<InferredSchemaType<SchemaAttributes>>;
     schema: Schema<SchemaAttributes>;
     dataService: IDataService;
-    getSchema: (logicalName: string) => Schema<SchemaAttributes>;
+    schemaStore: ISchemaStore;
 }): Promise<SaveRecordResult>;
 export declare function getInitialValues({ cloneRecord, form, record, recordId, defaultParameters, }: {
     cloneRecord: InferredSchemaType<SchemaAttributes> | undefined;
@@ -41,7 +42,7 @@ interface FormValidatorOptions<A extends SchemaAttributes = SchemaAttributes> {
     formReadOnly?: boolean;
     readonlyAttributes?: string[];
     strings: FormValidationStringSet;
-    getSchema: (logicalName: string) => Schema;
+    schemaStore: ISchemaStore;
 }
 type FormValidator = (<A extends SchemaAttributes = SchemaAttributes>(options: FormValidatorOptions<A>) => (values: Record<string, any>, context: any, options: any) => Promise<ResolverResult<{}>>) & MemoizedFunction;
 export declare const formValidator: FormValidator;

package/dataform/utils/index.js

@@ -57,7 +57,7 @@ function getModifiedValues(initialValues, values, exclude) {
     }, {});
 }
 function saveRecord(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, initialValues, record, getSchema, }) {
+    return __awaiter(this, arguments, void 0, function* ({ values, form, schema, dataService, initialValues, record, schemaStore, }) {
         const controls = (0, DataResolver_1.getControls)(form);
         const editableGridControls = controls.filter((control) => control.type === 'editablegrid');
         const modifiedValues = getModifiedValues(initialValues, values, editableGridControls.map((x) => x.attributeName));
@@ -74,7 +74,7 @@ function saveRecord(_a) {
                 });
             }
             for (const control of editableGridControls) {
-                const gridSchema = getSchema(control.logicalName);
+                const gridSchema = schemaStore.getSchema(control.logicalName);
                 const gridRows = values[control.attributeName];
                 const initialGridRows = initialValues[control.attributeName];
                 const newRows = gridRows.filter((x) => !x[gridSchema.idAttribute]);
@@ -212,7 +212,7 @@ function getInitialValues({ cloneRecord, form, record, recordId, defaultParamete
         return Object.assign(Object.assign({}, acc), { [column]: value });
     }, {});
 }
-exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, schema, readonlyAttributes, formReadOnly, getSchema, language, strings, }) {
+exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, schema, readonlyAttributes, formReadOnly, schemaStore, language, strings, }) {
     return (values, context, options) => __awaiter(this, void 0, void 0, function* () {
         let validator = yup.object().shape({});
         if (!formReadOnly) {
@@ -243,7 +243,7 @@ exports.formValidator = (0, lodash_1.memoize)(function formValidator({ form, sch
                     if (control.type !== 'editablegrid') {
                         throw new Error('Invalid control type');
                     }
-                    const schema = getSchema(control.logicalName);
+                    const schema = schemaStore.getSchema(control.logicalName);
                     return {
                         columns: control.attributes,
                         schema: schema,

package/datagrid/DataGridProvider/DataResolver.js

@@ -21,41 +21,6 @@ const hooks_1 = require("../hooks");
 const utils_1 = require("./utils");
 const ROWS_PER_PAGE = 100;
 const MAX_RECORDS = 10000;
-function mergeConditions(schema, filter, extraFilter, columnFilters, getSchema) {
-    const conditions = [];
-    if (filter) {
-        conditions.push(filter);
-    }
-    if (extraFilter) {
-        conditions.push(extraFilter);
-    }
-    if (columnFilters) {
-        const transformedColumnFilters = (0, utils_1.transformColumnFilter)(columnFilters, schema, getSchema);
-        if (transformedColumnFilters) {
-            conditions.push({
-                type: 'and',
-                conditions: Object.entries(transformedColumnFilters).map(([field, condition]) => {
-                    return {
-                        field,
-                        operator: condition.operator,
-                        value: condition.value,
-                        extendedKey: condition.extendedKey,
-                    };
-                }),
-            });
-        }
-    }
-    if (conditions.length === 0) {
-        return null;
-    }
-    if (conditions.length === 1) {
-        return conditions[0];
-    }
-    return {
-        type: 'and',
-        conditions,
-    };
-}
 function DataResolver() {
     var _a;
     const schema = (0, hooks_1.useDataGridSchema)();
@@ -67,24 +32,14 @@ function DataResolver() {
     const [columnFilters] = (0, hooks_1.useGridColumnFilter)();
     const gridColumns = (0, hooks_1.useGridColumns)();
     const maxRecords = (_a = (0, hooks_1.useMaxRecords)()) !== null && _a !== void 0 ? _a : MAX_RECORDS;
-    const { getSchema } = (0, useMetadata_1.useMetadata)();
+    const { schemaStore } = (0, useMetadata_1.useMetadata)();
     const setState = (0, context_1.useContextSetValue)(context_2.GridContext);
     const [search] = (0, useDebouncedValue_1.useDebouncedValue)(searchText, 500);
     const columns = (0, react_1.useMemo)(() => Array.from(new Set([
         ...gridColumns.filter((x) => !x.expandedKey).map((x) => x.name),
         schema.primaryAttribute,
     ])), [gridColumns, schema.primaryAttribute]);
-    const expand = (0, react_1.useMemo)(() => gridColumns
-        .filter((x) => x.expandedKey)
-        .reduce((acc, x) => {
-        if (!acc[x.name]) {
-            acc[x.name] = [];
-        }
-        if (!acc[x.name].includes(x.expandedKey)) {
-            acc[x.name].push(x.expandedKey);
-        }
-        return acc;
-    }, {}), [gridColumns]);
+    const expand = (0, react_1.useMemo)(() => (0, utils_1.collectExpandedKeys)(gridColumns), [gridColumns]);
     const queryKey = (0, react_1.useMemo)(() => [
         'data',
         'retriveRecords',
@@ -150,7 +105,7 @@ function DataResolver() {
                 search,
                 columns: columns,
                 expand,
-                filter: mergeConditions(schema, view.experience.filter, extraFilter, columnFilters, getSchema),
+                filter: (0, utils_1.mergeConditions)(schema, view.experience.filter, extraFilter, columnFilters, schemaStore),
                 skip,
                 limit,
                 sort: sorting,

package/datagrid/DataGridProvider/utils.d.ts

@@ -1,3 +1,8 @@
 import { ColumnCondition } from '@headless-adminapp/core/experience/view';
-import { Schema } from '@headless-adminapp/core/schema';
-export declare function transformColumnFilter(filter: Partial<Record<string, ColumnCondition>>, schema: Schema, getSchema: (logicalName: string) => Schema): Record<string, ColumnCondition> | null;
+import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+import { ISchemaStore } from '@headless-adminapp/core/store';
+import { Filter } from '@headless-adminapp/core/transport';
+import { TransformedViewColumn } from '../context';
+export declare function transformColumnFilter<S extends SchemaAttributes = SchemaAttributes>(filter: Partial<Record<string, ColumnCondition>>, schema: Schema<S>, schemaStore: ISchemaStore): Record<string, ColumnCondition> | null;
+export declare function mergeConditions<S extends SchemaAttributes = SchemaAttributes>(schema: Schema<S>, filter: Filter | null | undefined, extraFilter: Filter | null | undefined, columnFilters: Partial<Record<string, ColumnCondition>> | undefined, schemaStore: ISchemaStore): Filter | null;
+export declare function collectExpandedKeys(columns: TransformedViewColumn<SchemaAttributes>[]): Record<string, string[]>;

package/datagrid/DataGridProvider/utils.js

@@ -4,8 +4,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformColumnFilter = transformColumnFilter;
+exports.mergeConditions = mergeConditions;
+exports.collectExpandedKeys = collectExpandedKeys;
 const dayjs_1 = __importDefault(require("dayjs"));
-function transformColumnFilter(filter, schema, getSchema) {
+function transformColumnFilter(filter, schema, schemaStore) {
     const transformedResult = Object.entries(filter).reduce((acc, [id, value]) => {
         const [key, extendedKey] = id.split('.');
         let attribute = schema.attributes[key];
@@ -16,7 +18,7 @@ function transformColumnFilter(filter, schema, getSchema) {
             if (attribute.type !== 'lookup') {
                 throw new Error(`Invalid column filter key: ${id}. Key ${key} is not a lookup column.`);
             }
-            const lookupSchema = getSchema(attribute.entity);
+            const lookupSchema = schemaStore.getSchema(attribute.entity);
             attribute = lookupSchema.attributes[extendedKey];
         }
         if (!attribute) {
@@ -72,3 +74,51 @@ function transformColumnFilter(filter, schema, getSchema) {
     }
     return transformedResult;
 }
+function mergeConditions(schema, filter, extraFilter, columnFilters, schemaStore) {
+    const conditions = [];
+    if (filter) {
+        conditions.push(filter);
+    }
+    if (extraFilter) {
+        conditions.push(extraFilter);
+    }
+    if (columnFilters) {
+        const transformedColumnFilters = transformColumnFilter(columnFilters, schema, schemaStore);
+        if (transformedColumnFilters) {
+            conditions.push({
+                type: 'and',
+                conditions: Object.entries(transformedColumnFilters).map(([field, condition]) => {
+                    return {
+                        field,
+                        operator: condition.operator,
+                        value: condition.value,
+                        extendedKey: condition.extendedKey,
+                    };
+                }),
+            });
+        }
+    }
+    if (conditions.length === 0) {
+        return null;
+    }
+    if (conditions.length === 1) {
+        return conditions[0];
+    }
+    return {
+        type: 'and',
+        conditions,
+    };
+}
+function collectExpandedKeys(columns) {
+    return columns
+        .filter((x) => x.expandedKey)
+        .reduce((acc, x) => {
+        if (!acc[x.name]) {
+            acc[x.name] = [];
+        }
+        if (!acc[x.name].includes(x.expandedKey)) {
+            acc[x.name].push(x.expandedKey);
+        }
+        return acc;
+    }, {});
+}

package/datagrid/context.d.ts

@@ -1,12 +1,10 @@
 import { LocalizedDataLookup } from '@headless-adminapp/core/attributes';
 import { CommandItemExperience } from '@headless-adminapp/core/experience/command';
-import { ColumnCondition, EntityMainGridCommandContext, EntitySubGridCommandContext, SortingState, View, ViewColumn } from '@headless-adminapp/core/experience/view';
+import { ColumnCondition, EntityMainGridCommandContext, EntitySubGridCommandContext, SortingState, View } from '@headless-adminapp/core/experience/view';
+import { type TransformedViewColumn } from '@headless-adminapp/core/experience/view/ViewColumn';
 import { InferredSchemaType, Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 import { Filter, RetriveRecordsResult } from '@headless-adminapp/core/transport';
-export interface TransformedViewColumn<S extends SchemaAttributes = SchemaAttributes> extends ViewColumn<S> {
-    id: string;
-    label: string;
-}
+export { type TransformedViewColumn } from '@headless-adminapp/core/experience/view/ViewColumn';
 export interface GridContextState<S extends SchemaAttributes = SchemaAttributes, CommandContext extends EntityMainGridCommandContext | EntitySubGridCommandContext = EntityMainGridCommandContext> {
     schema: Schema<S>;
     view: View<S>;

package/datagrid/hooks/useMainGridCommands.d.ts

@@ -1,19 +1,7 @@
 import { EntityMainGridCommandContext } from '@headless-adminapp/core/experience/view';
 import { CommandItemState, MenuItemCommandState, UtilityContextState } from '../../command/types';
 export declare function useUtility(): UtilityContextState;
-export declare function useGridControlContext(): {
-    data: import("@headless-adminapp/core/transport").RetriveRecordsResult<import("@headless-adminapp/core/schema").InferredSchemaType<import("@headless-adminapp/core/schema").SchemaAttributes>> | null;
-    logicalName: string;
-    schema: import("@headless-adminapp/core/schema").Schema<import("@headless-adminapp/core/schema").SchemaAttributes>;
-    refresh: () => void;
-    searchText: string;
-    selectedIds: string[];
-    selectedRecords: import("@headless-adminapp/core/transport").Data<import("@headless-adminapp/core/schema").InferredSchemaType<import("@headless-adminapp/core/schema").SchemaAttributes>>[];
-    view: import("@headless-adminapp/core/experience/view").View<import("@headless-adminapp/core/schema").SchemaAttributes>;
-    viewId: string;
-    columnFilter: Partial<Record<string, import("@headless-adminapp/core/experience/view").ColumnCondition>>;
-    extraFilter: import("@headless-adminapp/core/transport").Filter | undefined;
-};
+export declare function useGridControlContext(): EntityMainGridCommandContext['primaryControl'];
 export declare function useMainGridCommandHandlerContext(): EntityMainGridCommandContext;
 export declare function useMainGridCommands(): CommandItemState[][];
 export declare function useMainGridContextCommands(): MenuItemCommandState[][];

package/datagrid/hooks/useMainGridCommands.js

@@ -5,22 +5,21 @@ exports.useGridControlContext = useGridControlContext;
 exports.useMainGridCommandHandlerContext = useMainGridCommandHandlerContext;
 exports.useMainGridCommands = useMainGridCommands;
 exports.useMainGridContextCommands = useMainGridContextCommands;
-const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const command_1 = require("../../command");
 const hooks_1 = require("../../dialog/hooks");
-const useLocale_1 = require("../../locale/useLocale");
-const useMetadata_1 = require("../../metadata/hooks/useMetadata");
 const useProgressIndicator_1 = require("../../progress-indicator/hooks/useProgressIndicator");
 const useOpenToastNotification_1 = require("../../toast-notification/hooks/useOpenToastNotification");
-const transport_1 = require("../../transport");
 const useGridColumnFilter_1 = require("./useGridColumnFilter");
+const useGridColumns_1 = require("./useGridColumns");
 const useGridCommands_1 = require("./useGridCommands");
 const useGridData_1 = require("./useGridData");
 const useGridExtraFilter_1 = require("./useGridExtraFilter");
 const useGridRefresh_1 = require("./useGridRefresh");
 const useGridSchema_1 = require("./useGridSchema");
 const useGridSelection_1 = require("./useGridSelection");
+const useGridSorting_1 = require("./useGridSorting");
+const useOpenRecord_1 = require("./useOpenRecord");
 const useSearchText_1 = require("./useSearchText");
 const useSelectedView_1 = require("./useSelectedView");
 function useUtility() {
@@ -49,6 +48,9 @@ function useGridControlContext() {
     const [columnFilter] = (0, useGridColumnFilter_1.useGridColumnFilter)();
     const extraFilter = (0, useGridExtraFilter_1.useGridExtraFilter)();
     const refresh = (0, useGridRefresh_1.useGridRefresh)();
+    const openRecord = (0, useOpenRecord_1.useOpenRecord)();
+    const gridColumns = (0, useGridColumns_1.useGridColumns)();
+    const [sorting] = (0, useGridSorting_1.useGridSorting)();
     const selectedIdsObj = (0, react_1.useMemo)(() => {
         const obj = {};
         selectedIds.forEach((id) => {
@@ -72,27 +74,15 @@ function useGridControlContext() {
         viewId: view.id,
         columnFilter,
         extraFilter,
+        openRecord,
+        gridColumns,
+        sorting,
     };
 }
 function useMainGridCommandHandlerContext() {
-    const dataService = (0, transport_1.useDataService)();
-    const queryClient = (0, react_query_1.useQueryClient)();
-    const { appStore, experienceStore, schemaStore } = (0, useMetadata_1.useMetadata)();
-    const utility = useUtility();
-    const locale = (0, useLocale_1.useLocale)();
+    const baseHandlerContext = (0, command_1.useBaseCommandHandlerContext)();
     const primaryControl = useGridControlContext();
-    return {
-        dataService,
-        queryClient,
-        utility,
-        primaryControl,
-        stores: {
-            appStore,
-            experienceStore,
-            schemaStore,
-        },
-        locale,
-    };
+    return Object.assign(Object.assign({}, baseHandlerContext), { primaryControl });
 }
 function useMainGridCommands() {
     const commands = (0, useGridCommands_1.useGridCommands)();

package/datagrid/hooks/useOpenRecord.d.ts

@@ -0,0 +1 @@
+export declare function useOpenRecord(): (id: string) => void;

package/datagrid/hooks/useOpenRecord.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOpenRecord = useOpenRecord;
+const recordset_1 = require("@headless-adminapp/app/recordset");
+const route_1 = require("@headless-adminapp/app/route");
+const app_1 = require("@headless-adminapp/core/experience/app");
+const react_1 = require("react");
+const useGridData_1 = require("./useGridData");
+const useGridSchema_1 = require("./useGridSchema");
+function useOpenRecord() {
+    const data = (0, useGridData_1.useGridData)();
+    const schema = (0, useGridSchema_1.useDataGridSchema)();
+    const routeResolver = (0, route_1.useRouteResolver)();
+    const router = (0, route_1.useRouter)();
+    const recordSetSetter = (0, recordset_1.useRecordSetSetter)();
+    const dataRef = (0, react_1.useRef)(data);
+    dataRef.current = data;
+    return (0, react_1.useCallback)((id) => {
+        var _a, _b;
+        const path = routeResolver({
+            logicalName: schema.logicalName,
+            type: app_1.PageType.EntityForm,
+            id,
+        });
+        recordSetSetter(schema.logicalName, (_b = (_a = dataRef.current) === null || _a === void 0 ? void 0 : _a.records.map((x) => x[schema.idAttribute])) !== null && _b !== void 0 ? _b : []);
+        router.push(path);
+    }, [
+        recordSetSetter,
+        routeResolver,
+        router,
+        schema.idAttribute,
+        schema.logicalName,
+    ]);
+}

package/datagrid/hooks/useSubGridCommands.js

@@ -3,13 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSubGridCommandHandlerContext = useSubGridCommandHandlerContext;
 exports.useSubGridCommands = useSubGridCommands;
 exports.useSubGridContextCommands = useSubGridContextCommands;
-const react_query_1 = require("@tanstack/react-query");
 const react_1 = require("react");
 const command_1 = require("../../command");
 const useMainFormCommands_1 = require("../../dataform/hooks/useMainFormCommands");
-const useLocale_1 = require("../../locale/useLocale");
-const useMetadata_1 = require("../../metadata/hooks/useMetadata");
-const transport_1 = require("../../transport");
 const useGridColumnFilter_1 = require("./useGridColumnFilter");
 const useGridCommands_1 = require("./useGridCommands");
 const useGridData_1 = require("./useGridData");
@@ -17,13 +13,10 @@ const useGridExtraFilter_1 = require("./useGridExtraFilter");
 const useGridRefresh_1 = require("./useGridRefresh");
 const useGridSchema_1 = require("./useGridSchema");
 const useGridSelection_1 = require("./useGridSelection");
-const useMainGridCommands_1 = require("./useMainGridCommands");
 const useSearchText_1 = require("./useSearchText");
 const useSelectedView_1 = require("./useSelectedView");
 function useSubGridCommandHandlerContext() {
-    const dataService = (0, transport_1.useDataService)();
-    const queryClient = (0, react_query_1.useQueryClient)();
-    const { appStore, experienceStore, schemaStore } = (0, useMetadata_1.useMetadata)();
+    const baseHandlerContext = (0, command_1.useBaseCommandHandlerContext)();
     const data = (0, useGridData_1.useGridData)();
     const schema = (0, useGridSchema_1.useDataGridSchema)();
     const view = (0, useSelectedView_1.useSelectedView)();
@@ -43,15 +36,8 @@ function useSubGridCommandHandlerContext() {
     const [columnFilter] = (0, useGridColumnFilter_1.useGridColumnFilter)();
     const extraFilter = (0, useGridExtraFilter_1.useGridExtraFilter)();
     const refresh = (0, useGridRefresh_1.useGridRefresh)();
-    const utility = (0, useMainGridCommands_1.useUtility)();
-    const locale = (0, useLocale_1.useLocale)();
     const mainFormHandlerContext = (0, useMainFormCommands_1.useMainFormCommandHandlerContext)();
-    return {
-        dataService,
-        queryClient,
-        utility,
-        primaryControl: mainFormHandlerContext.primaryControl,
-        secondaryControl: {
+    return Object.assign(Object.assign({}, baseHandlerContext), { primaryControl: mainFormHandlerContext.primaryControl, secondaryControl: {
             data,
             logicalName: schema.logicalName,
             schema,
@@ -63,14 +49,7 @@ function useSubGridCommandHandlerContext() {
             viewId: view.id,
             columnFilter,
             extraFilter,
-        },
-        stores: {
-            appStore,
-            experienceStore,
-            schemaStore,
-        },
-        locale,
-    };
+        } });
 }
 function useSubGridCommands() {
     const commands = (0, useGridCommands_1.useGridCommands)();

package/locale/LocaleProvider.js

@@ -8,7 +8,7 @@ const context_1 = require("./context");
 const LocaleProvider = ({ children, locale, options, }) => {
     const localeState = (0, react_1.useMemo)(() => {
         return (0, locale_1.getLocale)(locale, options);
-    }, [locale]);
+    }, [locale, options]);
     return ((0, jsx_runtime_1.jsx)(context_1.LocaleContext.Provider, { value: localeState, children: children }));
 };
 exports.LocaleProvider = LocaleProvider;

package/metadata/hooks/useMetadata.d.ts

@@ -2,6 +2,7 @@ import { SchemaAttributes } from '@headless-adminapp/core/schema';
 export declare function useMetadata(): {
     schemas: Record<string, import("@headless-adminapp/core/schema").Schema<SchemaAttributes>>;
     schemaLoading: boolean;
+    /*** @deprecated */
     getSchema: <S extends SchemaAttributes = SchemaAttributes>(logicalName: string) => import("@headless-adminapp/core/schema").Schema<S>;
     schemaStore: import("@headless-adminapp/core/store").ISchemaStore<SchemaAttributes>;
     appStore: import("@headless-adminapp/core/store").IClientAppStore;

package/metadata/hooks/useMetadata.js

@@ -14,12 +14,14 @@ function useMetadata() {
     // );
     const schemaLoading = false;
     const schemas = schemaStore.getAllSchema();
+    /*** @deprecated */
     const getSchema = (0, react_1.useCallback)((logicalName) => {
         return schemaStore.getSchema(logicalName);
     }, [schemaStore]);
     return {
         schemas,
         schemaLoading,
+        /*** @deprecated */
         getSchema,
         schemaStore,
         appStore,

package/metadata/hooks/useSchema.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useSchema = useSchema;
 const useMetadata_1 = require("./useMetadata");
 function useSchema(logicalName) {
-    const { getSchema } = (0, useMetadata_1.useMetadata)();
-    return getSchema(logicalName);
+    const { schemaStore } = (0, useMetadata_1.useMetadata)();
+    return schemaStore.getSchema(logicalName);
 }

package/mutable/context.js

@@ -41,6 +41,6 @@ function useContextValueSetter(context, setter) {
     setterRef.current = setter;
     const setterWrapper = (0, react_1.useCallback)((...args) => {
         return setterRef.current(contextValue.setValue)(...args);
-    }, []);
+    }, [contextValue.setValue]);
     return setterWrapper;
 }

package/navigation/hooks/index.d.ts

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

package/navigation/hooks/index.js

@@ -0,0 +1,17 @@
+"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("./useOpenForm"), exports);

package/navigation/hooks/useOpenForm.d.ts

@@ -1,4 +1,2 @@
-import { PageEntiyForm } from '@headless-adminapp/core/experience/app';
-export declare function useOpenForm(): (formOptions: Omit<PageEntiyForm, "type">, navigationOptions: {
-    replace?: boolean;
-}) => void;
+import { OpenFormOptions } from '@headless-adminapp/core/experience/command';
+export declare function useOpenForm(): (options: OpenFormOptions) => void;

package/navigation/hooks/useOpenForm.js

@@ -8,9 +8,13 @@ const useRouteResolver_1 = require("../../route/hooks/useRouteResolver");
 function useOpenForm() {
     const routeResolver = (0, useRouteResolver_1.useRouteResolver)();
     const router = (0, hooks_1.useRouter)();
-    return (0, react_1.useCallback)((formOptions, navigationOptions) => {
-        const path = routeResolver(Object.assign({ type: app_1.PageType.EntityForm }, formOptions));
-        if (navigationOptions.replace) {
+    return (0, react_1.useCallback)((options) => {
+        const path = routeResolver({
+            logicalName: options.logicalName,
+            type: app_1.PageType.EntityForm,
+            id: options.id,
+        });
+        if (options.replace) {
             router.replace(path);
         }
         else {

package/navigation/index.d.ts

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

package/navigation/index.js

@@ -0,0 +1,17 @@
+"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("./hooks"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@headless-adminapp/app",
-  "version": "0.0.17-alpha.4",
+  "version": "0.0.17-alpha.7",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -27,8 +27,16 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@hookform/resolvers": "^3.9.0",
+    "@tanstack/react-query": "5.51.1",
     "clsx": "2.1.1",
-    "react-custom-scrollbars-2": "^4.5.0"
+    "dayjs": "^1.11.13",
+    "exceljs": "^4.4.0",
+    "json-to-csv-export": "^2.1.1",
+    "lodash": "^4.17.21",
+    "react-custom-scrollbars-2": "^4.5.0",
+    "react-hook-form": "7.52.2",
+    "yup": "^1.4.0"
   },
-  "gitHead": "2166288d663adfdd5f7428474b4f55ebbcad772c"
+  "gitHead": "5b53560e1c0b20e0bb0e74e820a96c7c75e2c43b"
 }

package/recordset/RecordSetProvider.js

@@ -35,6 +35,6 @@ const CardViewSetter = () => {
             });
         })
             .catch(console.error);
-    }, [experienceStore, logicalName]);
+    }, [experienceStore, logicalName, setValue]);
     return null;
 };

package/recordset/hooks/useRecordSetResult.js

@@ -26,7 +26,7 @@ function useRecordSetResult() {
             return null;
         }
         return schemaStore.getSchema(context.logicalName);
-    }, [context.logicalName]);
+    }, [context.logicalName, schemaStore]);
     const cardView = context.cardView;
     const columns = (0, react_1.useMemo)(() => {
         var _a;