@smartbit4all/ng-client 3.3.205 → 4.0.0

package/esm2022/lib/view-context/smart-ui-action/ui-action.descriptor.service.mjs

@@ -0,0 +1,180 @@
+import { Injectable } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import { SmartSubject } from '../../smart-subject/projects';
+import { IconPosition, UiActionButtonType, UiActionFeedbackType, } from '../api';
+import * as i0 from "@angular/core";
+import * as i1 from "../smart-view-context.service";
+export class UiActionDescriptorService {
+    constructor(viewContext) {
+        this.viewContext = viewContext;
+        this._destroy$ = new Subject();
+        this.languageChanged = new SmartSubject(this._destroy$);
+        this.keysToTranslate = ['title', 'text', 'placeholder', 'caption', 'feedbackText'];
+        this.basicActionDescriptors = new Map([
+            [
+                'UNKOWN',
+                {
+                    title: '',
+                    type: UiActionButtonType.NORMAL,
+                    color: 'accent',
+                    icon: 'Question',
+                    iconColor: `text-primary`,
+                    iconPosition: IconPosition.POST,
+                    dialog: {
+                        title: '',
+                        placeholder: 'placeholder',
+                        actionButton: {
+                            caption: '',
+                            color: 'accent',
+                        },
+                        cancelButton: {
+                            caption: 'Mégse',
+                            color: '',
+                        },
+                    },
+                },
+            ],
+        ]);
+        if (this.viewContext.translateService) {
+            this.subscribeToTranslateService();
+        }
+        else {
+            this.viewContext.translateServiceChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+                this.subscribeToTranslateService();
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    subscribeToTranslateService() {
+        this.viewContext
+            .translateService.onLangChange.pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.languageChanged.next();
+        });
+    }
+    async getActionDescriptor(uiAction) {
+        let code = uiAction.code;
+        let isUnkown = false;
+        let server = uiAction.descriptor;
+        let client = null;
+        let actionDescriptorFromDescriptors = this.viewContext.getActionDescriptors()?.get(code);
+        if (actionDescriptorFromDescriptors) {
+            client = JSON.parse(JSON.stringify(actionDescriptorFromDescriptors));
+        }
+        let actionDescriptor;
+        if (!client) {
+            // server only
+            actionDescriptor = server;
+        }
+        else {
+            // client exists
+            if (server) {
+                // server & client -> merge into client what's filled from server
+                this.mergeActionDescriptorIntoClient(server, client);
+            }
+            actionDescriptor = client;
+        }
+        if (!actionDescriptor) {
+            isUnkown = true;
+            let unkownActionDescriptor = this.basicActionDescriptors.get('UNKOWN');
+            actionDescriptor = { ...unkownActionDescriptor };
+            actionDescriptor.title = code;
+        }
+        if (!actionDescriptor.dialog) {
+            actionDescriptor = this.setUpUnkownDialogDescriptor(code, actionDescriptor, 'dialog');
+        }
+        if (!actionDescriptor.feedbackType && uiAction.submit) {
+            actionDescriptor.feedbackType = UiActionFeedbackType.SNACKBAR;
+        }
+        if (this.viewContext.translateService && !isUnkown && !server) {
+            actionDescriptor = await this.translateUiActionDescriptor(actionDescriptor);
+        }
+        return actionDescriptor;
+    }
+    mergeActionDescriptorIntoClient(server, client) {
+        if (server.title) {
+            client.title = server.title;
+        }
+        if (server.icon) {
+            client.icon = server.icon;
+        }
+        if (server.color) {
+            client.color = server.color;
+        }
+        if (server.confirmDialog) {
+            if (!client.confirmDialog) {
+                client.confirmDialog = server.confirmDialog;
+            }
+            this.mergeActionDialogDescriptorIntoClient(server.confirmDialog, client.confirmDialog);
+            client.confirmDialog = server.confirmDialog;
+        }
+        if (server.feedbackType) {
+            client.feedbackType = server.feedbackType;
+        }
+    }
+    // TODO use prop name to handle all dialogs
+    // private mergeActionDescriptorDialog(
+    //   server: UiActionDescriptor,
+    //   client: UiActionDescriptor,
+    //   prop: string
+    // ): void {
+    //   //let serverDialog: UiActionDialogDescriptor = server[prop] as UiActionDialogDescriptor;
+    //   if (server.confirmDialog) {
+    //     if (!client.confirmDialog) {
+    //       client.confirmDialog = server.confirmDialog;
+    //     }
+    //     this.mergeActionDialogDescriptorIntoClient(server.confirmDialog, client.confirmDialog);
+    //     client.confirmDialog = server.confirmDialog;
+    //   }
+    // }
+    mergeActionDialogDescriptorIntoClient(serverDialog, clientDialog) {
+        if (serverDialog.title) {
+            clientDialog.title = serverDialog.title;
+        }
+        if (serverDialog.placeholder) {
+            clientDialog.placeholder = serverDialog.placeholder;
+        }
+        if (serverDialog.text) {
+            clientDialog.text = serverDialog.text;
+        }
+    }
+    async translateUiActionDescriptor(uiActionDescriptor) {
+        uiActionDescriptor = await this.deepTranslate(uiActionDescriptor);
+        return uiActionDescriptor;
+    }
+    async deepTranslate(_model) {
+        let model = { ..._model };
+        await Promise.all(Object.keys(model).map(async (key) => {
+            if (model[key] !== undefined &&
+                typeof model[key] === 'string' &&
+                model[key].length &&
+                this.keysToTranslate.includes(key)) {
+                model[key] = await this.viewContext.translateService.get(model[key]).toPromise();
+            }
+            else if (model[key] !== undefined && typeof model[key] === 'object') {
+                model[key] = await this.deepTranslate(model[key]);
+            }
+            return model;
+        }));
+        return model;
+    }
+    setUpUnkownDialogDescriptor(code, uiActionDescriptor, dialogType) {
+        let unkownDescriptor = this.basicActionDescriptors.get('UNKOWN');
+        uiActionDescriptor[dialogType] = unkownDescriptor.dialog;
+        uiActionDescriptor[dialogType].title = code;
+        uiActionDescriptor[dialogType].actionButton.caption = code;
+        return uiActionDescriptor;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: UiActionDescriptorService, deps: [{ token: i1.SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: UiActionDescriptorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.2.4", ngImport: i0, type: UiActionDescriptorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [{ type: i1.SmartViewContextService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-action.descriptor.service.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/view-context/smart-ui-action/ui-action.descriptor.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\r\nimport { Subject, takeUntil } from 'rxjs';\r\nimport { SmartSubject } from '../../smart-subject/projects';\r\nimport {\r\n  UiAction,\r\n  IconPosition,\r\n  UiActionButtonType,\r\n  UiActionDescriptor,\r\n  UiActionDialogDescriptor,\r\n  UiActionFeedbackType,\r\n} from '../api';\r\nimport { SmartViewContextService } from '../smart-view-context.service';\r\n\r\n@Injectable({\r\n  providedIn: 'root',\r\n})\r\nexport class UiActionDescriptorService implements OnDestroy {\r\n  private _destroy$: Subject<void> = new Subject();\r\n\r\n  languageChanged: Subject<void> = new SmartSubject(this._destroy$);\r\n  keysToTranslate: string[] = ['title', 'text', 'placeholder', 'caption', 'feedbackText'];\r\n\r\n  constructor(private viewContext: SmartViewContextService) {\r\n    if (this.viewContext.translateService) {\r\n      this.subscribeToTranslateService();\r\n    } else {\r\n      this.viewContext.translateServiceChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {\r\n        this.subscribeToTranslateService();\r\n      });\r\n    }\r\n  }\r\n  ngOnDestroy(): void {\r\n    this._destroy$.next();\r\n    this._destroy$.complete();\r\n  }\r\n\r\n  private subscribeToTranslateService(): void {\r\n    this.viewContext\r\n      .translateService!.onLangChange.pipe(takeUntil(this._destroy$))\r\n      .subscribe(() => {\r\n        this.languageChanged.next();\r\n      });\r\n  }\r\n\r\n  public async getActionDescriptor(uiAction: UiAction): Promise<UiActionDescriptor> {\r\n    let code = uiAction.code!;\r\n    let isUnkown = false;\r\n\r\n    let server: UiActionDescriptor | undefined | null = uiAction.descriptor;\r\n    let client: UiActionDescriptor | undefined | null = null;\r\n\r\n    let actionDescriptorFromDescriptors = this.viewContext.getActionDescriptors()?.get(code);\r\n    if (actionDescriptorFromDescriptors) {\r\n      client = JSON.parse(JSON.stringify(actionDescriptorFromDescriptors));\r\n    }\r\n\r\n    let actionDescriptor: UiActionDescriptor | undefined | null;\r\n    if (!client) {\r\n      // server only\r\n      actionDescriptor = server;\r\n    } else {\r\n      // client exists\r\n      if (server) {\r\n        // server & client -> merge into client what's filled from server\r\n        this.mergeActionDescriptorIntoClient(server, client);\r\n      }\r\n      actionDescriptor = client;\r\n    }\r\n\r\n    if (!actionDescriptor) {\r\n      isUnkown = true;\r\n      let unkownActionDescriptor = this.basicActionDescriptors.get('UNKOWN');\r\n      actionDescriptor = { ...unkownActionDescriptor! };\r\n      actionDescriptor!.title = code;\r\n    }\r\n\r\n    if (!actionDescriptor!.dialog) {\r\n      actionDescriptor = this.setUpUnkownDialogDescriptor(code, actionDescriptor!, 'dialog');\r\n    }\r\n\r\n    if (!actionDescriptor!.feedbackType && uiAction.submit) {\r\n      actionDescriptor!.feedbackType = UiActionFeedbackType.SNACKBAR;\r\n    }\r\n\r\n    if (this.viewContext.translateService && !isUnkown && !server) {\r\n      actionDescriptor = await this.translateUiActionDescriptor(actionDescriptor);\r\n    }\r\n\r\n    return actionDescriptor!;\r\n  }\r\n\r\n  public mergeActionDescriptorIntoClient(\r\n    server: UiActionDescriptor,\r\n    client: UiActionDescriptor\r\n  ): void {\r\n    if (server.title) {\r\n      client.title = server.title;\r\n    }\r\n    if (server.icon) {\r\n      client.icon = server.icon;\r\n    }\r\n    if (server.color) {\r\n      client.color = server.color;\r\n    }\r\n    if (server.confirmDialog) {\r\n      if (!client.confirmDialog) {\r\n        client.confirmDialog = server.confirmDialog;\r\n      }\r\n      this.mergeActionDialogDescriptorIntoClient(server.confirmDialog, client.confirmDialog);\r\n      client.confirmDialog = server.confirmDialog;\r\n    }\r\n    if (server.feedbackType) {\r\n      client.feedbackType = server.feedbackType;\r\n    }\r\n  }\r\n\r\n  // TODO use prop name to handle all dialogs\r\n  // private mergeActionDescriptorDialog(\r\n  //   server: UiActionDescriptor,\r\n  //   client: UiActionDescriptor,\r\n  //   prop: string\r\n  // ): void {\r\n  //   //let serverDialog: UiActionDialogDescriptor = server[prop] as UiActionDialogDescriptor;\r\n  //   if (server.confirmDialog) {\r\n  //     if (!client.confirmDialog) {\r\n  //       client.confirmDialog = server.confirmDialog;\r\n  //     }\r\n  //     this.mergeActionDialogDescriptorIntoClient(server.confirmDialog, client.confirmDialog);\r\n  //     client.confirmDialog = server.confirmDialog;\r\n  //   }\r\n  // }\r\n\r\n  private mergeActionDialogDescriptorIntoClient(\r\n    serverDialog: UiActionDialogDescriptor,\r\n    clientDialog: UiActionDialogDescriptor\r\n  ): void {\r\n    if (serverDialog.title) {\r\n      clientDialog.title = serverDialog.title;\r\n    }\r\n    if (serverDialog.placeholder) {\r\n      clientDialog.placeholder = serverDialog.placeholder;\r\n    }\r\n    if (serverDialog.text) {\r\n      clientDialog.text = serverDialog.text;\r\n    }\r\n  }\r\n\r\n  private async translateUiActionDescriptor(\r\n    uiActionDescriptor: UiActionDescriptor\r\n  ): Promise<UiActionDescriptor> {\r\n    uiActionDescriptor = await this.deepTranslate(uiActionDescriptor);\r\n\r\n    return uiActionDescriptor;\r\n  }\r\n\r\n  private async deepTranslate(_model: any): Promise<any> {\r\n    let model = { ..._model };\r\n    await Promise.all(\r\n      Object.keys(model).map(async (key: string) => {\r\n        if (\r\n          model[key] !== undefined &&\r\n          typeof model[key] === 'string' &&\r\n          model[key].length &&\r\n          this.keysToTranslate.includes(key)\r\n        ) {\r\n          model[key] = await this.viewContext.translateService!.get(model[key]).toPromise();\r\n        } else if (model[key] !== undefined && typeof model[key] === 'object') {\r\n          model[key] = await this.deepTranslate(model[key]);\r\n        }\r\n        return model;\r\n      })\r\n    );\r\n\r\n    return model;\r\n  }\r\n\r\n  private setUpUnkownDialogDescriptor(\r\n    code: string,\r\n    uiActionDescriptor: UiActionDescriptor,\r\n    dialogType: 'dialog' | 'confirmDialog' | 'inputDialog' | 'input2Dialog'\r\n  ): UiActionDescriptor {\r\n    let unkownDescriptor = this.basicActionDescriptors.get('UNKOWN');\r\n\r\n    uiActionDescriptor[dialogType] = unkownDescriptor!.dialog;\r\n    uiActionDescriptor[dialogType]!.title = code;\r\n    uiActionDescriptor[dialogType]!.actionButton.caption = code;\r\n\r\n    return uiActionDescriptor;\r\n  }\r\n\r\n  private basicActionDescriptors: Map<string, UiActionDescriptor> = new Map([\r\n    [\r\n      'UNKOWN',\r\n      {\r\n        title: '',\r\n        type: UiActionButtonType.NORMAL,\r\n        color: 'accent',\r\n        icon: 'Question',\r\n        iconColor: `text-primary`,\r\n        iconPosition: IconPosition.POST,\r\n        dialog: {\r\n          title: '',\r\n          placeholder: 'placeholder',\r\n          actionButton: {\r\n            caption: '',\r\n            color: 'accent',\r\n          },\r\n          cancelButton: {\r\n            caption: 'Mégse',\r\n            color: '',\r\n          },\r\n        },\r\n      },\r\n    ],\r\n  ]);\r\n}\r\n"]}

package/{esm2020 → esm2022}/lib/view-context/smart-ui-action/ui-action.model.mjs

@@ -1,7 +1,7 @@
-export var UiActionDialogType;
-(function (UiActionDialogType) {
-    UiActionDialogType["inputDialog"] = "inputDialog";
-    UiActionDialogType["confirmDialog"] = "confirmDialog";
-    UiActionDialogType["dialog"] = "dialog";
-})(UiActionDialogType || (UiActionDialogType = {}));
+export var UiActionDialogType;
+(function (UiActionDialogType) {
+    UiActionDialogType["inputDialog"] = "inputDialog";
+    UiActionDialogType["confirmDialog"] = "confirmDialog";
+    UiActionDialogType["dialog"] = "dialog";
+})(UiActionDialogType || (UiActionDialogType = {}));
 //# sourceMappingURL=data:application/json;base64,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