@headless-adminapp/app 0.0.17-alpha.3 → 0.0.17-alpha.34

package/builders/CommandBuilder/ViewCommandBuilder.js

@@ -0,0 +1,242 @@
+"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.ViewCommandBuilder = void 0;
+const utils_1 = require("../utils");
+const utils_2 = require("./utils");
+var 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 = {}));
+var ViewCommandBuilder;
+(function (ViewCommandBuilder) {
+    function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => {
+                context.navigation.openForm({
+                    logicalName: context.primaryControl.schema.logicalName,
+                });
+            },
+            hidden: (context) => {
+                if (!EnabledRules.HasCreatePermisssion(context)) {
+                    return true;
+                }
+                return false;
+            },
+        };
+    }
+    ViewCommandBuilder.createNewRecordCommand = createNewRecordCommand;
+    function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            isContextMenu: true,
+            onClick: (context) => {
+                context.primaryControl.openRecord(context.primaryControl.selectedIds[0]);
+            },
+            hidden: [(context) => !EnabledRules.HasSingleRecordSelected(context)],
+        };
+    }
+    ViewCommandBuilder.createEditRecordCommand = createEditRecordCommand;
+    ViewCommandBuilder.defaultDeleteRecordStringSet = {
+        confirmation: {
+            text: [
+                'Are you sure you want to delete this record?',
+                'Are you sure you want to delete selected records?',
+            ],
+            title: ['Delete record', 'Delete records'],
+            buttonConfirm: 'Delete',
+            buttonCancel: 'Cancel',
+        },
+        status: {
+            deleting: ['Deleting record', 'Deleting records'],
+        },
+        successNotification: {
+            title: ['Record deleted', 'Records deleted'],
+            text: ['Record deleted successfully', 'Records deleted successfully'],
+        },
+        errorNotification: {
+            title: 'Error',
+        },
+    };
+    function createDeleteRecordCommand({ Icon, localizedText, text, stringSet = ViewCommandBuilder.defaultDeleteRecordStringSet, localizedStringSet, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText,
+            danger: true,
+            isContextMenu: true,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                const recordIds = context.primaryControl.selectedIds;
+                if (!recordIds.length) {
+                    return;
+                }
+                const localizeSelector = (0, utils_2.createLocalizedSelector)(stringSet, localizedStringSet, context.locale.language);
+                try {
+                    const confirmResult = yield context.utility.openConfirmDialog({
+                        title: (0, utils_2.plurialize)(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                        text: (0, utils_2.plurialize)(recordIds.length, localizeSelector((s) => s.confirmation.text)),
+                        cancelButtonLabel: localizeSelector((s) => s.confirmation.buttonCancel),
+                        confirmButtonLabel: localizeSelector((s) => s.confirmation.buttonConfirm),
+                    });
+                    if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                        return;
+                    }
+                    context.utility.showProgressIndicator((0, utils_2.plurialize)(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                    for (const recordId of recordIds) {
+                        yield context.dataService.deleteRecord(context.primaryControl.logicalName, recordId);
+                    }
+                    context.utility.showNotification({
+                        title: (0, utils_2.plurialize)(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                        text: (0, utils_2.plurialize)(recordIds.length, localizeSelector((s) => s.successNotification.text)),
+                        type: 'success',
+                    });
+                    context.primaryControl.refresh();
+                }
+                catch (error) {
+                    context.utility.showNotification({
+                        title: localizeSelector((s) => s.errorNotification.title),
+                        text: error.message,
+                        type: 'error',
+                    });
+                }
+                finally {
+                    context.utility.hideProgressIndicator();
+                }
+            }),
+            hidden: [
+                (context) => !EnabledRules.HasAtLeastOneRecordSelected(context),
+                (context) => !EnabledRules.HasDeletePermission(context),
+            ],
+        };
+    }
+    ViewCommandBuilder.createDeleteRecordCommand = createDeleteRecordCommand;
+    function createRefreshCommand({ Icon, localizedTexts, text, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => {
+                context.primaryControl.refresh();
+            },
+        };
+    }
+    ViewCommandBuilder.createRefreshCommand = createRefreshCommand;
+    function createExportCommand({ button, csv, excel, }) {
+        return {
+            type: 'menu',
+            Icon: button.Icon,
+            text: button.text,
+            localizedTexts: button.localizedTexts,
+            items: [
+                [
+                    {
+                        Icon: excel.Icon,
+                        text: excel.text,
+                        localizedTexts: excel.localizedTexts,
+                        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) => __awaiter(this, void 0, void 0, function* () {
+                            context.utility.showProgressIndicator('Exporting to CSV...');
+                            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();
+                            }
+                        }),
+                    },
+                ],
+            ],
+        };
+    }
+    ViewCommandBuilder.createExportCommand = createExportCommand;
+})(ViewCommandBuilder || (exports.ViewCommandBuilder = ViewCommandBuilder = {}));

package/builders/CommandBuilder/index.d.ts

@@ -0,0 +1 @@
+export { CommandBuilder } from './CommandBuilder';

package/builders/CommandBuilder/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+var CommandBuilder_1 = require("./CommandBuilder");
+Object.defineProperty(exports, "CommandBuilder", { enumerable: true, get: function () { return CommandBuilder_1.CommandBuilder; } });

package/builders/CommandBuilder/utils.d.ts

@@ -0,0 +1,3 @@
+import { Localized } from '@headless-adminapp/core/types';
+export declare function createLocalizedSelector<T>(stringSet: T, localizedStringSet: Localized<T> | undefined, language: string): <U>(selector: (stringSet: T) => U) => U;
+export declare function plurialize(count: number, singular: string | [string, string], plural?: string): string;

package/builders/CommandBuilder/utils.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocalizedSelector = createLocalizedSelector;
+exports.plurialize = plurialize;
+function createLocalizedSelector(stringSet, localizedStringSet, language) {
+    return function selectLocalized(selector) {
+        if (localizedStringSet && localizedStringSet[language]) {
+            return selector(localizedStringSet[language]);
+        }
+        return selector(stringSet);
+    };
+}
+function plurialize(count, singular, plural) {
+    if (Array.isArray(singular)) {
+        plural = singular[1];
+        singular = singular[0];
+    }
+    let msg = count === 1 ? singular : plural !== null && plural !== void 0 ? plural : singular;
+    msg = msg.replace('{count}', count.toString());
+    return msg;
+}

package/builders/SchemaExperienceBuilder.d.ts

@@ -1,6 +1,6 @@
-import { AsyncForm, AsyncQuickCreateForm, EntityMainFormCommandItemExperience, Form, FormExperience, QuickCreateForm } from '@headless-adminapp/core/experience/form';
+import { AsyncForm, AsyncQuickCreateForm, Form, FormExperience, QuickCreateForm } from '@headless-adminapp/core/experience/form';
 import { SchemaExperience } from '@headless-adminapp/core/experience/schema';
-import { AsyncView, EntityMainGridCommandItemExperience, SubGridCommandItemExperience, View, ViewExperience } from '@headless-adminapp/core/experience/view';
+import { AsyncView, View, ViewExperience } from '@headless-adminapp/core/experience/view';
 import { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
 declare abstract class BaseSchemaExperienceBuilder<S extends SchemaAttributes> {
     protected readonly logicalName: string;
@@ -29,9 +29,6 @@ declare abstract class BaseSchemaExperienceBuilder<S extends SchemaAttributes> {
     defineFormExperience(formExperience: FormExperience<S>): FormExperience<S>;
 }
 export interface SchemaExperienceBuilderDefaults {
-    formCommands?: EntityMainFormCommandItemExperience[][];
-    viewCommands?: EntityMainGridCommandItemExperience[][];
-    subgridCommands?: SubGridCommandItemExperience[][];
     localizedViewNames?: Record<string, string>;
 }
 interface SchemaExperienceBuilderOptions {

package/builders/SchemaExperienceBuilder.js

@@ -36,17 +36,17 @@ class BaseSchemaExperienceBuilder {
         if (!this.defaultLookupId) {
             throw new Error('Default lookup is required');
         }
-        if (!this.views.find((v) => v.id === this.defaultViewId)) {
+        if (!this.views.find(v => v.id === this.defaultViewId)) {
             throw new Error('Default view not found');
         }
-        if (!this.forms.find((f) => f.id === this.defaultFormId)) {
+        if (!this.forms.find(f => f.id === this.defaultFormId)) {
             throw new Error('Default form not found');
         }
-        if (!this.lookups.find((l) => l.id === this.defaultLookupId)) {
+        if (!this.lookups.find(l => l.id === this.defaultLookupId)) {
             throw new Error('Default lookup not found');
         }
         if (this.defaultQuickCreateFormId &&
-            !this.quickCreateForms.find((f) => f.id === this.defaultQuickCreateFormId)) {
+            !this.quickCreateForms.find(f => f.id === this.defaultQuickCreateFormId)) {
             throw new Error('Default quick create form not found');
         }
         return {
@@ -158,9 +158,9 @@ class SchemaExperienceBuilder extends BaseSchemaExperienceBuilder {
         var _a;
         const langugesSet = new Set();
         this.schema.localizedPluralLabels &&
-            Object.keys(this.schema.localizedPluralLabels).forEach((key) => langugesSet.add(key));
+            Object.keys(this.schema.localizedPluralLabels).forEach(key => langugesSet.add(key));
         ((_a = this.defaults) === null || _a === void 0 ? void 0 : _a.localizedViewNames) &&
-            Object.keys(this.defaults.localizedViewNames).forEach((key) => langugesSet.add(key));
+            Object.keys(this.defaults.localizedViewNames).forEach(key => langugesSet.add(key));
         const localizedLabels = Array.from(langugesSet).reduce((acc, key) => {
             var _a, _b, _c, _d, _e, _f;
             const localizedPluralName = (_c = (_b = (_a = this.schema.localizedPluralLabels) === null || _a === void 0 ? void 0 : _a[key]) === null || _b === void 0 ? void 0 : _b.toLowerCase()) !== null && _c !== void 0 ? _c : this.schema.pluralLabel.toLowerCase();
@@ -178,13 +178,13 @@ class SchemaExperienceBuilder extends BaseSchemaExperienceBuilder {
         if (!defaultId) {
             return data[0].id;
         }
-        if (!data.find((x) => x.id === defaultId)) {
+        if (!data.find(x => x.id === defaultId)) {
             return data[0].id;
         }
         return defaultId;
     }
     defineExperience(experience) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _a, _b, _c, _d, _e, _f, _g, _h;
         let lookups = experience.lookups;
         let views = experience.views;
         let forms = experience.forms;
@@ -243,14 +243,14 @@ class SchemaExperienceBuilder extends BaseSchemaExperienceBuilder {
             defaultViewId,
             defaultLookupId,
             defaultAssociatedViewId,
-            quickCreateForms: (_d = (_c = experience.quickCreateForms) === null || _c === void 0 ? void 0 : _c.map((x) => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _d !== void 0 ? _d : [],
-            views: (_e = views.map((x) => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _e !== void 0 ? _e : [],
-            forms: (_f = forms.map((x) => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _f !== void 0 ? _f : [],
-            lookups: (_g = lookups.map((x) => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _g !== void 0 ? _g : [],
-            associatedViews: (_h = associatedViews.map((x) => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _h !== void 0 ? _h : [],
-            formCommands: (_l = (_j = experience.formCommands) !== null && _j !== void 0 ? _j : (_k = this.defaults) === null || _k === void 0 ? void 0 : _k.formCommands) !== null && _l !== void 0 ? _l : [],
-            subgridCommands: (_p = (_m = experience.subgridCommands) !== null && _m !== void 0 ? _m : (_o = this.defaults) === null || _o === void 0 ? void 0 : _o.subgridCommands) !== null && _p !== void 0 ? _p : [],
-            viewCommands: (_s = (_q = experience.viewCommands) !== null && _q !== void 0 ? _q : (_r = this.defaults) === null || _r === void 0 ? void 0 : _r.viewCommands) !== null && _s !== void 0 ? _s : [],
+            quickCreateForms: (_d = (_c = experience.quickCreateForms) === null || _c === void 0 ? void 0 : _c.map(x => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _d !== void 0 ? _d : [],
+            views: (_e = views.map(x => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _e !== void 0 ? _e : [],
+            forms: (_f = forms.map(x => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _f !== void 0 ? _f : [],
+            lookups: (_g = lookups.map(x => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _g !== void 0 ? _g : [],
+            associatedViews: (_h = associatedViews.map(x => (Object.assign(Object.assign({}, x), { logicalName: this.logicalName })))) !== null && _h !== void 0 ? _h : [],
+            formCommands: experience.formCommands,
+            subgridCommands: experience.subgridCommands,
+            viewCommands: experience.viewCommands,
         };
     }
 }

package/builders/index.d.ts

@@ -1,2 +1,2 @@
 export { SchemaExperienceBuilder, type SchemaExperienceBuilderDefaults, } from './SchemaExperienceBuilder';
-export { CommandBuilder, localizedLabel } from './CommandBuilder';
+export { CommandBuilder } from './CommandBuilder';

package/builders/index.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.localizedLabel = exports.CommandBuilder = exports.SchemaExperienceBuilder = void 0;
+exports.CommandBuilder = exports.SchemaExperienceBuilder = void 0;
 var SchemaExperienceBuilder_1 = require("./SchemaExperienceBuilder");
 Object.defineProperty(exports, "SchemaExperienceBuilder", { enumerable: true, get: function () { return SchemaExperienceBuilder_1.SchemaExperienceBuilder; } });
 var CommandBuilder_1 = require("./CommandBuilder");
 Object.defineProperty(exports, "CommandBuilder", { enumerable: true, get: function () { return CommandBuilder_1.CommandBuilder; } });
-Object.defineProperty(exports, "localizedLabel", { enumerable: true, get: function () { return CommandBuilder_1.localizedLabel; } });

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,7 +2,9 @@
 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 react_1 = require("react");
 const hooks_1 = require("../../dialog/hooks");
 const locale_1 = require("../../locale");
 const hooks_2 = require("../../metadata/hooks");
@@ -16,7 +18,7 @@ function useUtility() {
     const openErrorDialog = (0, hooks_1.useOpenErrorDialog)();
     const openPromptDialog = (0, hooks_1.useOpenPromptDialog)();
     const openToastNotification = (0, useOpenToastNotification_1.useOpenToastNotification)();
-    return {
+    return (0, react_1.useMemo)(() => ({
         hideProgressIndicator,
         showProgressIndicator,
         openAlertDialog,
@@ -24,7 +26,21 @@ function useUtility() {
         openErrorDialog,
         openPromptDialog,
         showNotification: openToastNotification,
-    };
+    }), [
+        hideProgressIndicator,
+        openAlertDialog,
+        openConfirmDialog,
+        openErrorDialog,
+        openPromptDialog,
+        openToastNotification,
+        showProgressIndicator,
+    ]);
+}
+function useNavigation() {
+    const openForm = (0, navigation_1.useOpenForm)();
+    return (0, react_1.useMemo)(() => ({
+        openForm,
+    }), [openForm]);
 }
 function useBaseCommandHandlerContext() {
     const dataService = (0, transport_1.useDataService)();
@@ -32,11 +48,13 @@ function useBaseCommandHandlerContext() {
     const stores = (0, hooks_2.useMetadata)();
     const utility = useUtility();
     const locale = (0, locale_1.useLocale)();
-    return {
+    const navigation = useNavigation();
+    return (0, react_1.useMemo)(() => ({
         dataService,
         queryClient,
         utility,
         stores,
         locale,
-    };
+        navigation,
+    }), [dataService, queryClient, stores, utility, locale, navigation]);
 }