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

package/dist/builders/CommandBuilder.js

@@ -0,0 +1,474 @@
+"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.CommandBuilder = void 0;
+exports.localizedLabel = localizedLabel;
+exports.createLocalizedSelector = createLocalizedSelector;
+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);
+}
+function createLocalizedSelector(stringSet, localizedStringSet, language) {
+    return function selectLocalized(selector) {
+        if (localizedStringSet && localizedStringSet[language]) {
+            return selector(localizedStringSet[language]);
+        }
+        return selector(stringSet);
+    };
+}
+var CommandBuilder;
+(function (CommandBuilder) {
+    let View;
+    (function (View) {
+        function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    console.log('New record', context);
+                },
+                hidden: (context) => {
+                    console.log(context);
+                    // TODO: Implement logic to hide the button
+                    return false;
+                },
+            };
+        }
+        View.createNewRecordCommand = createNewRecordCommand;
+        function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                isContextMenu: true,
+                onClick: (context) => {
+                    console.log('Edit record', context);
+                },
+                hidden: (context) => context.primaryControl.selectedIds.length !== 1, // TODO: check permissions
+            };
+        }
+        View.createEditRecordCommand = createEditRecordCommand;
+        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;
+        }
+        View.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 = View.defaultDeleteRecordStringSet, localizedStringSet, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                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) {
+                        return;
+                    }
+                    const localizeSelector = createLocalizedSelector(stringSet, localizedStringSet, context.locale.language);
+                    try {
+                        const confirmResult = yield context.utility.openConfirmDialog({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                            text: 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(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        context.utility.showNotification({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                            text: 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();
+                    }
+                }),
+            };
+        }
+        View.createDeleteRecordCommand = createDeleteRecordCommand;
+        function createRefreshCommand({ Icon, localizedTexts, text, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    context.primaryControl.refresh();
+                },
+            };
+        }
+        View.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) => {
+                                console.log('Export to Excel', context);
+                            },
+                        },
+                        {
+                            Icon: csv.Icon,
+                            text: csv.text,
+                            localizedTexts: csv.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to CSV', context);
+                            },
+                        },
+                    ],
+                ],
+            };
+        }
+        View.createExportCommand = createExportCommand;
+    })(View = CommandBuilder.View || (CommandBuilder.View = {}));
+    let Form;
+    (function (Form) {
+        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;
+                },
+            };
+        }
+        Form.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;
+                },
+            };
+        }
+        Form.createSaveAndCloseCommand = createSaveAndCloseCommand;
+        Form.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();
+                    }
+                }),
+            };
+        }
+        Form.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,
+            };
+        }
+        Form.createRefreshCommand = createRefreshCommand;
+    })(Form = CommandBuilder.Form || (CommandBuilder.Form = {}));
+    let Subgrid;
+    (function (Subgrid) {
+        function createNewRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    console.log('New record', context);
+                },
+                hidden: (context) => {
+                    console.log(context);
+                    // TODO: Implement logic to hide the button
+                    return false;
+                },
+            };
+        }
+        Subgrid.createNewRecordCommand = createNewRecordCommand;
+        function createEditRecordCommand({ Icon, text, localizedTexts, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                isContextMenu: true,
+                onClick: (context) => {
+                    console.log('Edit record', context);
+                },
+                // hidden: (context) => context.secondaryControl.selectedIds.length !== 1, // TODO: check permissions
+                hidden: (context) => {
+                    console.log('temp.', context);
+                    return context.secondaryControl.selectedIds.length !== 1;
+                },
+            };
+        }
+        Subgrid.createEditRecordCommand = createEditRecordCommand;
+        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;
+        }
+        Subgrid.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 = Subgrid.defaultDeleteRecordStringSet, localizedStringSet, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText,
+                danger: true,
+                isContextMenu: true,
+                hidden: [
+                    (context) => context.secondaryControl.selectedIds.length === 0,
+                ], // TODO: check permissions
+                onClick: (context) => __awaiter(this, void 0, void 0, function* () {
+                    const recordIds = context.secondaryControl.selectedIds;
+                    if (!recordIds.length) {
+                        return;
+                    }
+                    const localizeSelector = createLocalizedSelector(stringSet, localizedStringSet, context.locale.language);
+                    try {
+                        const confirmResult = yield context.utility.openConfirmDialog({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.confirmation.title)),
+                            text: 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(plurialize(recordIds.length, localizeSelector((s) => s.status.deleting)) + '...');
+                        yield new Promise((resolve) => setTimeout(resolve, 2000));
+                        context.utility.showNotification({
+                            title: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.title)),
+                            text: plurialize(recordIds.length, localizeSelector((s) => s.successNotification.text)),
+                            type: 'success',
+                        });
+                        yield context.primaryControl.refresh();
+                    }
+                    catch (error) {
+                        context.utility.showNotification({
+                            title: localizeSelector((s) => s.errorNotification.title),
+                            text: error.message,
+                            type: 'error',
+                        });
+                    }
+                    finally {
+                        context.utility.hideProgressIndicator();
+                    }
+                }),
+            };
+        }
+        Subgrid.createDeleteRecordCommand = createDeleteRecordCommand;
+        function createRefreshCommand({ Icon, localizedTexts, text, }) {
+            return {
+                type: 'button',
+                Icon,
+                text,
+                localizedText: localizedTexts,
+                onClick: (context) => {
+                    context.secondaryControl.refresh();
+                },
+            };
+        }
+        Subgrid.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) => {
+                                console.log('Export to Excel', context);
+                            },
+                        },
+                        {
+                            Icon: csv.Icon,
+                            text: csv.text,
+                            localizedTexts: csv.localizedTexts,
+                            onClick: (context) => {
+                                console.log('Export to CSV', context);
+                            },
+                        },
+                    ],
+                ],
+            };
+        }
+        Subgrid.createExportCommand = createExportCommand;
+    })(Subgrid = CommandBuilder.Subgrid || (CommandBuilder.Subgrid = {}));
+})(CommandBuilder || (exports.CommandBuilder = CommandBuilder = {}));

package/dist/builders/SchemaExperienceBuilder.d.ts

@@ -0,0 +1,69 @@
+import { AsyncForm, AsyncQuickCreateForm, EntityMainFormCommandItemExperience, 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 { Schema, SchemaAttributes } from '@headless-adminapp/core/schema';
+declare abstract class BaseSchemaExperienceBuilder<S extends SchemaAttributes> {
+    protected readonly logicalName: string;
+    protected views: View<S>[];
+    protected forms: Form<S>[];
+    protected lookups: View<S>[];
+    protected quickCreateForms: QuickCreateForm<S>[];
+    protected defaultViewId: string | null;
+    protected defaultFormId: string | null;
+    protected defaultLookupId: string | null;
+    protected defaultQuickCreateFormId: string | null;
+    protected locked: boolean;
+    constructor(logicalName: string);
+    reset(): this;
+    protected baseBuild(): {
+        logicalName: string;
+        defaultFormId: string;
+        defaultViewId: string;
+        views: View<S>[];
+        forms: Form<S>[];
+        defaultLookupId: string;
+        lookups: View<S>[];
+        defaultQuickCreateFormId: string | null;
+        quickCreateForms: QuickCreateForm<S>[];
+    };
+    defineFormExperience(formExperience: FormExperience<S>): FormExperience<S>;
+}
+export interface SchemaExperienceBuilderDefaults {
+    formCommands?: EntityMainFormCommandItemExperience[][];
+    viewCommands?: EntityMainGridCommandItemExperience[][];
+    subgridCommands?: SubGridCommandItemExperience[][];
+    localizedViewNames?: Record<string, string>;
+}
+interface SchemaExperienceBuilderOptions {
+}
+export declare class SchemaExperienceBuilder<S extends SchemaAttributes = SchemaAttributes> extends BaseSchemaExperienceBuilder<S> {
+    private schema;
+    private defaults?;
+    private options?;
+    constructor(schema: Schema<S>, defaults?: SchemaExperienceBuilderDefaults | undefined, options?: SchemaExperienceBuilderOptions | undefined);
+    defineViewExperience(viewExperience: Pick<ViewExperience<S>, 'filter' | 'defaultSorting'> & {
+        card?: ViewExperience<S>['card'];
+        grid?: ViewExperience<S>['grid'];
+    }): ViewExperience<S>;
+    defineDefaultViewGrid(): ViewExperience<S>['grid'];
+    defineDefaultViewCard(): ViewExperience<S>['card'];
+    defineDefaultViewExperience(): ViewExperience<S>;
+    defineDefaultFormExperience(): FormExperience<S>;
+    private getLocalizedViewNames;
+    private resolveDefaultId;
+    defineExperience(experience: Omit<SchemaExperience<S>, 'logicalName' | 'forms' | 'views' | 'lookups' | 'defaultViewId' | 'defaultFormId' | 'defaultLookupId' | 'defaultAssociatedViewId' | 'quickCreateForms' | 'viewCommands' | 'subgridCommands' | 'formCommands' | 'associatedViews'> & {
+        forms?: Omit<AsyncForm<S>, 'logicalName'>[];
+        views?: Omit<AsyncView<S>, 'logicalName'>[];
+        lookups?: Omit<AsyncView<S>, 'logicalName'>[];
+        associatedViews?: Omit<AsyncView<S>, 'logicalName'>[];
+        quickCreateForms?: Omit<AsyncQuickCreateForm<S>, 'logicalName'>[];
+        defaultViewId?: string;
+        defaultFormId?: string;
+        defaultLookupId?: string;
+        defaultAssociatedViewId?: string;
+        viewCommands?: SchemaExperience<S>['viewCommands'];
+        subgridCommands?: SchemaExperience<S>['subgridCommands'];
+        formCommands?: SchemaExperience<S>['formCommands'];
+    }): SchemaExperience<S>;
+}
+export {};