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

package/builders/CommandBuilder/CommandBuilder.d.ts

@@ -0,0 +1,10 @@
+import { DefaultCommandBuilder } from './DefaultCommandBuilder';
+import { FormCommandBuilder } from './FormCommandBuilder';
+import { SubgridCommandBuilder } from './SubgridCommandBuilder';
+import { ViewCommandBuilder } from './ViewCommandBuilder';
+export declare namespace CommandBuilder {
+    const View: typeof ViewCommandBuilder;
+    const Form: typeof FormCommandBuilder;
+    const Subgrid: typeof SubgridCommandBuilder;
+    const Default: typeof DefaultCommandBuilder;
+}

package/builders/CommandBuilder/CommandBuilder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+const DefaultCommandBuilder_1 = require("./DefaultCommandBuilder");
+const FormCommandBuilder_1 = require("./FormCommandBuilder");
+const SubgridCommandBuilder_1 = require("./SubgridCommandBuilder");
+const ViewCommandBuilder_1 = require("./ViewCommandBuilder");
+var CommandBuilder;
+(function (CommandBuilder) {
+    CommandBuilder.View = ViewCommandBuilder_1.ViewCommandBuilder;
+    CommandBuilder.Form = FormCommandBuilder_1.FormCommandBuilder;
+    CommandBuilder.Subgrid = SubgridCommandBuilder_1.SubgridCommandBuilder;
+    CommandBuilder.Default = DefaultCommandBuilder_1.DefaultCommandBuilder;
+})(CommandBuilder || (exports.CommandBuilder = CommandBuilder = {}));

package/builders/CommandBuilder/DefaultCommandBuilder.d.ts

@@ -0,0 +1,79 @@
+import { Localized } from '@headless-adminapp/core/types';
+import { Icon } from '@headless-adminapp/icons';
+import { ViewCommandBuilder } from './ViewCommandBuilder';
+export declare namespace DefaultCommandBuilder {
+    interface CreateDefaultViewCommandStrings {
+        new: string;
+        edit: string;
+        delete: string;
+        refresh: string;
+        export: string;
+        exportCsv: string;
+        exportExcel: string;
+        deleteRecordCommandStringSet: ViewCommandBuilder.DeleteRecordCommandStringSet;
+    }
+    export const defaultViewCommandStrings: CreateDefaultViewCommandStrings;
+    interface CreateDefaultViewCommandOptions {
+        icons: {
+            New: Icon;
+            Edit: Icon;
+            Delete: Icon;
+            Refresh: Icon;
+            Export: Icon;
+            ExportCsv: Icon;
+            ExportExcel: Icon;
+        };
+        strings?: CreateDefaultViewCommandStrings;
+        localizedSrings?: Localized<CreateDefaultViewCommandStrings>;
+    }
+    export function createDefaultViewCommands({ icons, strings, localizedSrings, }: CreateDefaultViewCommandOptions): import("@headless-adminapp/core/experience/view").EntityMainGridCommandItemExperience[][];
+    interface CreateDefaultFormCommandStrings {
+        save: string;
+        saveAndClose: string;
+        refresh: string;
+    }
+    interface CreateDefaultFormCommandOptions {
+        icons: {
+            Save: Icon;
+            SaveAndClose: Icon;
+            Refresh: Icon;
+        };
+        strings?: CreateDefaultFormCommandStrings;
+        localizedSrings?: Localized<CreateDefaultFormCommandStrings>;
+    }
+    export const defaultFormCommandStrings: CreateDefaultFormCommandStrings;
+    export function createDefaultFormCommands({ icons, strings, localizedSrings, }: CreateDefaultFormCommandOptions): import("@headless-adminapp/core/experience/form").EntityMainFormCommandItemExperience[][];
+    interface CreateDefaultSubgridCommandStrings {
+        new: string;
+        edit: string;
+        refresh: string;
+        export: string;
+        exportCsv: string;
+        exportExcel: string;
+    }
+    interface CreateDefaultSubgridCommandOptions {
+        icons: {
+            New: Icon;
+            Edit: Icon;
+            Refresh: Icon;
+            Export: Icon;
+            ExportCsv: Icon;
+            ExportExcel: Icon;
+        };
+        strings?: CreateDefaultSubgridCommandStrings;
+        localizedSrings?: Localized<CreateDefaultSubgridCommandStrings>;
+    }
+    export function createDefaultSubgridCommands({ icons, strings, localizedSrings, }: CreateDefaultSubgridCommandOptions): (import("@headless-adminapp/core/experience/view").EntityMainGridCommandItemExperience[] | import("@headless-adminapp/core/experience/view").SubGridCommandItemExperience[])[];
+    type CreateDefaultCommandStrings = CreateDefaultViewCommandStrings & CreateDefaultFormCommandStrings & CreateDefaultSubgridCommandStrings;
+    interface CreateDefaultCommandOptions {
+        icons: CreateDefaultViewCommandOptions['icons'] & CreateDefaultFormCommandOptions['icons'] & CreateDefaultSubgridCommandOptions['icons'];
+        strings?: CreateDefaultCommandStrings;
+        localizedSrings?: Localized<CreateDefaultCommandStrings>;
+    }
+    export function createDefaultCommands({ icons, strings, localizedSrings, }: CreateDefaultCommandOptions): {
+        view: import("@headless-adminapp/core/experience/view").EntityMainGridCommandItemExperience[][];
+        form: import("@headless-adminapp/core/experience/form").EntityMainFormCommandItemExperience[][];
+        subgrid: (import("@headless-adminapp/core/experience/view").EntityMainGridCommandItemExperience[] | import("@headless-adminapp/core/experience/view").SubGridCommandItemExperience[])[];
+    };
+    export {};
+}

package/builders/CommandBuilder/DefaultCommandBuilder.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCommandBuilder = void 0;
+const FormCommandBuilder_1 = require("./FormCommandBuilder");
+const SubgridCommandBuilder_1 = require("./SubgridCommandBuilder");
+const ViewCommandBuilder_1 = require("./ViewCommandBuilder");
+var DefaultCommandBuilder;
+(function (DefaultCommandBuilder) {
+    DefaultCommandBuilder.defaultViewCommandStrings = {
+        new: 'New',
+        edit: 'Edit',
+        delete: 'Delete',
+        deleteRecordCommandStringSet: ViewCommandBuilder_1.ViewCommandBuilder.defaultDeleteRecordStringSet,
+        refresh: 'Refresh',
+        export: 'Export',
+        exportCsv: 'CSV',
+        exportExcel: 'Excel',
+    };
+    function extractLocalizedStrings(localizedStrings, selector) {
+        if (!localizedStrings) {
+            return;
+        }
+        return Object.keys(localizedStrings).reduce((p, key) => {
+            p[key] = selector(localizedStrings[key]);
+            return p;
+        }, {});
+    }
+    function createDefaultViewCommands({ icons, strings = DefaultCommandBuilder.defaultViewCommandStrings, localizedSrings, }) {
+        return [
+            [
+                ViewCommandBuilder_1.ViewCommandBuilder.createNewRecordCommand({
+                    Icon: icons.New,
+                    text: strings.new,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.new),
+                }),
+                ViewCommandBuilder_1.ViewCommandBuilder.createEditRecordCommand({
+                    Icon: icons.Edit,
+                    text: strings.edit,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.edit),
+                }),
+                ViewCommandBuilder_1.ViewCommandBuilder.createDeleteRecordCommand({
+                    Icon: icons.Delete,
+                    text: strings.delete,
+                    localizedText: extractLocalizedStrings(localizedSrings, x => x.delete),
+                    stringSet: strings.deleteRecordCommandStringSet,
+                    localizedStringSet: extractLocalizedStrings(localizedSrings, x => x.deleteRecordCommandStringSet),
+                }),
+                ViewCommandBuilder_1.ViewCommandBuilder.createRefreshCommand({
+                    Icon: icons.Refresh,
+                    text: strings.refresh,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.refresh),
+                }),
+            ],
+            [
+                ViewCommandBuilder_1.ViewCommandBuilder.createExportCommand({
+                    button: {
+                        Icon: icons.Export,
+                        text: strings.export,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.export),
+                    },
+                    csv: {
+                        Icon: icons.ExportCsv,
+                        text: strings.exportCsv,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.exportCsv),
+                    },
+                    excel: {
+                        Icon: icons.ExportExcel,
+                        text: strings.exportCsv,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.exportExcel),
+                    },
+                }),
+            ],
+        ];
+    }
+    DefaultCommandBuilder.createDefaultViewCommands = createDefaultViewCommands;
+    DefaultCommandBuilder.defaultFormCommandStrings = {
+        save: 'Save',
+        saveAndClose: 'Save & Close',
+        refresh: 'Refresh',
+    };
+    function createDefaultFormCommands({ icons, strings = DefaultCommandBuilder.defaultFormCommandStrings, localizedSrings, }) {
+        return [
+            [
+                FormCommandBuilder_1.FormCommandBuilder.createSaveCommand({
+                    Icon: icons.Save,
+                    text: strings.save,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.save),
+                }),
+                FormCommandBuilder_1.FormCommandBuilder.createSaveAndCloseCommand({
+                    Icon: icons.SaveAndClose,
+                    text: strings.saveAndClose,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.saveAndClose),
+                }),
+                FormCommandBuilder_1.FormCommandBuilder.createRefreshCommand({
+                    Icon: icons.Refresh,
+                    text: strings.refresh,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.refresh),
+                }),
+            ],
+        ];
+    }
+    DefaultCommandBuilder.createDefaultFormCommands = createDefaultFormCommands;
+    const defaultSubgridCommandStrings = {
+        new: 'New',
+        edit: 'Edit',
+        refresh: 'Refresh',
+        export: 'Export',
+        exportCsv: 'CSV',
+        exportExcel: 'Excel',
+    };
+    function createDefaultSubgridCommands({ icons, strings = defaultSubgridCommandStrings, localizedSrings, }) {
+        return [
+            [
+                SubgridCommandBuilder_1.SubgridCommandBuilder.createNewRecordCommand({
+                    Icon: icons.New,
+                    text: strings.new,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.new),
+                }),
+                SubgridCommandBuilder_1.SubgridCommandBuilder.createEditRecordCommand({
+                    Icon: icons.Edit,
+                    text: strings.edit,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.edit),
+                }),
+                SubgridCommandBuilder_1.SubgridCommandBuilder.createRefreshCommand({
+                    Icon: icons.Refresh,
+                    text: strings.refresh,
+                    localizedTexts: extractLocalizedStrings(localizedSrings, x => x.refresh),
+                }),
+            ],
+            [
+                ViewCommandBuilder_1.ViewCommandBuilder.createExportCommand({
+                    button: {
+                        Icon: icons.Export,
+                        text: strings.export,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.export),
+                    },
+                    csv: {
+                        Icon: icons.ExportCsv,
+                        text: strings.exportCsv,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.exportCsv),
+                    },
+                    excel: {
+                        Icon: icons.ExportExcel,
+                        text: strings.exportExcel,
+                        localizedTexts: extractLocalizedStrings(localizedSrings, x => x.exportExcel),
+                    },
+                }),
+            ],
+        ];
+    }
+    DefaultCommandBuilder.createDefaultSubgridCommands = createDefaultSubgridCommands;
+    const defaultCreateCommandStrings = Object.assign(Object.assign(Object.assign({}, DefaultCommandBuilder.defaultViewCommandStrings), DefaultCommandBuilder.defaultFormCommandStrings), defaultSubgridCommandStrings);
+    function createDefaultCommands({ icons, strings = defaultCreateCommandStrings, localizedSrings, }) {
+        return {
+            view: createDefaultViewCommands({
+                icons,
+                strings,
+                localizedSrings,
+            }),
+            form: createDefaultFormCommands({
+                icons,
+                strings,
+                localizedSrings,
+            }),
+            subgrid: createDefaultSubgridCommands({
+                icons,
+                strings,
+                localizedSrings,
+            }),
+        };
+    }
+    DefaultCommandBuilder.createDefaultCommands = createDefaultCommands;
+})(DefaultCommandBuilder || (exports.DefaultCommandBuilder = DefaultCommandBuilder = {}));

package/builders/CommandBuilder/FormCommandBuilder.d.ts

@@ -0,0 +1,45 @@
+import { EntityFormCommandContext, EntityMainFormCommandItemExperience } from '@headless-adminapp/core/experience/form';
+import { Icon } from '@headless-adminapp/icons';
+export declare namespace FormCommandBuilder {
+    export function createSaveCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainFormCommandItemExperience;
+    export function createSaveAndCloseCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainFormCommandItemExperience;
+    interface DeleteRecordCommandStringSet {
+        confirmation: {
+            title: string;
+            text: string;
+            buttonCancel: string;
+            buttonConfirm: string;
+        };
+        status: {
+            deleting: string;
+        };
+        successNotification: {
+            title: string;
+            text: string;
+        };
+        errorNotification: {
+            title: string;
+        };
+    }
+    export const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+    export function createDeleteCommand({ Icon, text, localizedTexts, stringSet, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+        stringSet: DeleteRecordCommandStringSet | ((context: EntityFormCommandContext) => DeleteRecordCommandStringSet);
+    }): EntityMainFormCommandItemExperience;
+    export function createRefreshCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): EntityMainFormCommandItemExperience;
+    export {};
+}

package/builders/CommandBuilder/FormCommandBuilder.js

@@ -0,0 +1,145 @@
+"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.FormCommandBuilder = void 0;
+var FormCommandBuilder;
+(function (FormCommandBuilder) {
+    function createSaveCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            isQuickAction: true,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.save('save');
+            }),
+            hidden: (context) => {
+                if (context.primaryControl.readonly) {
+                    return true;
+                }
+                return false;
+            },
+        };
+    }
+    FormCommandBuilder.createSaveCommand = createSaveCommand;
+    function createSaveAndCloseCommand({ Icon, text, localizedTexts, }) {
+        return {
+            type: 'button',
+            Icon,
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.save('saveandclose');
+            }),
+            hidden: (context) => {
+                if (context.primaryControl.readonly) {
+                    return true;
+                }
+                return false;
+            },
+        };
+    }
+    FormCommandBuilder.createSaveAndCloseCommand = createSaveAndCloseCommand;
+    FormCommandBuilder.defaultDeleteRecordStringSet = {
+        confirmation: {
+            text: 'Are you sure you want to delete this record?',
+            title: 'Delete record',
+            buttonConfirm: 'Delete',
+            buttonCancel: 'Cancel',
+        },
+        status: {
+            deleting: 'Deleting record',
+        },
+        successNotification: {
+            title: 'Record deleted',
+            text: 'Record deleted successfully',
+        },
+        errorNotification: {
+            title: 'Error',
+        },
+    };
+    function createDeleteCommand({ Icon, text, localizedTexts, stringSet, }) {
+        return {
+            Icon: Icon,
+            type: 'button',
+            text,
+            localizedText: localizedTexts,
+            danger: true,
+            hidden: (context) => {
+                var _a;
+                if (!context.primaryControl.recordId) {
+                    return true;
+                }
+                if ((_a = context.primaryControl.schema.restrictions) === null || _a === void 0 ? void 0 : _a.disableDelete) {
+                    return true;
+                }
+                return false;
+            },
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                const recordId = context.primaryControl.recordId;
+                if (!recordId) {
+                    return;
+                }
+                if (typeof stringSet === 'function') {
+                    stringSet = stringSet(context);
+                }
+                try {
+                    const confirmResult = yield context.utility.openConfirmDialog({
+                        title: stringSet.confirmation.title,
+                        text: stringSet.confirmation.text,
+                        cancelButtonLabel: stringSet.confirmation.buttonCancel,
+                        confirmButtonLabel: stringSet.confirmation.buttonConfirm,
+                    });
+                    if (!(confirmResult === null || confirmResult === void 0 ? void 0 : confirmResult.confirmed)) {
+                        return;
+                    }
+                    context.utility.showProgressIndicator(stringSet.status.deleting + '...');
+                    yield new Promise((resolve) => setTimeout(resolve, 2000));
+                    // await context.dataService.deleteRecord(
+                    //   context.primaryControl.logicalName,
+                    //   recordId
+                    // );
+                    context.utility.showNotification({
+                        title: stringSet.successNotification.title,
+                        text: stringSet.successNotification.text,
+                        type: 'success',
+                    });
+                    // context.primaryControl.close();
+                }
+                catch (error) {
+                    context.utility.showNotification({
+                        title: stringSet.errorNotification.title,
+                        text: error.message,
+                        type: 'error',
+                    });
+                }
+                finally {
+                    context.utility.hideProgressIndicator();
+                }
+            }),
+        };
+    }
+    FormCommandBuilder.createDeleteCommand = createDeleteCommand;
+    function createRefreshCommand({ Icon, text, localizedTexts, }) {
+        return {
+            Icon,
+            type: 'button',
+            text,
+            localizedText: localizedTexts,
+            onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                yield context.primaryControl.refresh();
+            }),
+            hidden: (context) => !context.primaryControl.recordId,
+        };
+    }
+    FormCommandBuilder.createRefreshCommand = createRefreshCommand;
+})(FormCommandBuilder || (exports.FormCommandBuilder = FormCommandBuilder = {}));

package/builders/CommandBuilder/SubgridCommandBuilder.d.ts

@@ -0,0 +1,64 @@
+import { SubGridCommandItemExperience } from '@headless-adminapp/core/experience/view';
+import { Localized } from '@headless-adminapp/core/types';
+import { Icon } from '@headless-adminapp/icons';
+export declare namespace SubgridCommandBuilder {
+    export function createNewRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    export function createEditRecordCommand({ Icon, text, localizedTexts, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    interface DeleteRecordCommandStringSet {
+        confirmation: {
+            title: string | string[];
+            text: string | string[];
+            buttonCancel: string;
+            buttonConfirm: string;
+        };
+        status: {
+            deleting: string | string[];
+        };
+        successNotification: {
+            title: string | string[];
+            text: string | string[];
+        };
+        errorNotification: {
+            title: string;
+        };
+    }
+    export const defaultDeleteRecordStringSet: DeleteRecordCommandStringSet;
+    export function createDeleteRecordCommand({ Icon, localizedText, text, stringSet, localizedStringSet, }: {
+        Icon: Icon;
+        text: string;
+        localizedText?: Record<string, string>;
+        stringSet?: DeleteRecordCommandStringSet;
+        localizedStringSet?: Localized<DeleteRecordCommandStringSet>;
+    }): SubGridCommandItemExperience;
+    export function createRefreshCommand({ Icon, localizedTexts, text, }: {
+        Icon: Icon;
+        text: string;
+        localizedTexts?: Record<string, string>;
+    }): SubGridCommandItemExperience;
+    export function createExportCommand({ button, csv, excel, }: {
+        button: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        excel: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+        csv: {
+            Icon: Icon;
+            text: string;
+            localizedTexts?: Record<string, string>;
+        };
+    }): SubGridCommandItemExperience;
+    export {};
+}