@smartbit4all/ng-client 5.0.21 → 6.0.1

package/esm2022/lib/view-context/smart-ui-action/ui-action-toolbar.component.mjs

@@ -0,0 +1,319 @@
+import { Component, HostListener, Inject, Input, ViewChild, } from '@angular/core';
+import { interval, Subject, takeUntil } from 'rxjs';
+import { IconPosition, } from '../api';
+import { UiActionButtonType } from '../api/model/uiActionButtonType';
+import { UiActionDescriptorService } from './ui-action.descriptor.service';
+import { COMPONENT_LIBRARY, ComponentLibrary } from '../utility/componentLibrary';
+import { ToolbarDirection } from '../../smart-component-layout/api';
+import * as i0 from "@angular/core";
+import * as i1 from "./ui-action.service";
+import * as i2 from "@angular/common";
+import * as i3 from "./ui-action-button/ui-action-button.component";
+import * as i4 from "./components/menu/menu.component";
+import * as i5 from "../utility/componentLibrary";
+export class UiActionToolbarComponent {
+    constructor(service, inject, changeDetector, compLib) {
+        this.service = service;
+        this.inject = inject;
+        this.changeDetector = changeDetector;
+        this.compLib = compLib;
+        this._destroy$ = new Subject();
+        this.componentLibrary = ComponentLibrary; // Expose the enum to the template
+        this.pressedButtonActive = true;
+        this.scrollOnWrap = false;
+        this.isScrollable = false;
+        this.scrollSpeed = 5;
+        this.scrollDelay = 16;
+        this.scrollHoldDelay = 100;
+        this.schedules = new Map();
+        this.buttonLeft = {
+            title: '',
+            color: 'primary',
+            type: UiActionButtonType.RAISED,
+            icon: this.compLib === ComponentLibrary.PRIMENG ? 'chevron-left' : 'arrow_back',
+            iconPosition: IconPosition.PRE,
+        };
+        this.buttonRight = {
+            title: '',
+            color: 'primary',
+            type: UiActionButtonType.RAISED,
+            icon: this.compLib === ComponentLibrary.PRIMENG ? 'chevron-right' : 'arrow_forward',
+            iconPosition: IconPosition.PRE,
+        };
+        // Injects the basic UiActionDescriptorService provided by the AppModule
+        this.manager = inject.get(UiActionDescriptorService);
+        this.subscribeToLanguageChange();
+    }
+    ngOnInit() {
+        // Overrides the basic UiActionDescriptorService with a custom one if there is one
+        if (this.uiActionDescriptorService) {
+            this.manager = this.uiActionDescriptorService;
+            this.subscribeToLanguageChange();
+        }
+        if (this.toolbarPropertes) {
+            this.scrollOnWrap = this.toolbarPropertes.scrollable ?? false;
+        }
+        this.setUp();
+    }
+    ngAfterViewInit() {
+        if (this.scrollOnWrap) {
+            setTimeout(() => {
+                this.checkScrollable();
+            });
+        }
+    }
+    onResize() {
+        if (this.scrollOnWrap) {
+            this.checkScrollable();
+        }
+    }
+    ngOnChanges(changes) {
+        if (changes['uiActionModels']) {
+            let uiActionModels = changes['uiActionModels'].currentValue;
+            if (uiActionModels) {
+                this.uiActionModels = uiActionModels;
+                this.setUp();
+            }
+        }
+    }
+    ngOnDestroy() {
+        this.clearSchedule();
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    subscribeToLanguageChange() {
+        this.languageChangedSubscription?.unsubscribe();
+        this.languageChangedSubscription = this.manager.languageChanged
+            .pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.setUp();
+        });
+    }
+    async setUp() {
+        if (this.uiActionModels) {
+            let uiActionModelsWithDescriptions = [];
+            for (const uiActionModel of this.uiActionModels) {
+                const uiAction = uiActionModel.uiAction;
+                // using equality is a must here, undefined and null should be equal
+                if (this.id == uiAction.toolbar) {
+                    uiActionModel.descriptor = await this.manager.getActionDescriptor(uiActionModel.uiAction);
+                    uiActionModelsWithDescriptions.push(uiActionModel);
+                }
+            }
+            this.scheduleActions(this.uiActionModels);
+            this.uiActionModelsWithDescriptions = uiActionModelsWithDescriptions;
+            this.changeDetector.markForCheck();
+            this.changeDetector.detectChanges();
+            setTimeout(() => this.checkScrollable());
+        }
+    }
+    clearSchedule() {
+        this.schedules.forEach((sub) => sub.unsubscribe());
+        this.schedules.clear();
+    }
+    scheduleActions(uiActionModels) {
+        this.clearSchedule();
+        uiActionModels.forEach((uiActionModel) => {
+            let uiAction = uiActionModel.uiAction;
+            if (!uiAction.code ||
+                uiAction.disabled ||
+                !uiAction.schedule?.intervalSeconds ||
+                this.schedules.has(uiAction.code) ||
+                uiAction.subActions?.length) {
+                return;
+            }
+            let intervalInMs = uiAction.schedule.intervalSeconds * 1000;
+            let sub = interval(intervalInMs)
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(() => {
+                uiActionModel.uiAction.params = {
+                    ...uiActionModel.uiAction.params,
+                    scheduled: true,
+                };
+                this.fireAction(uiActionModel);
+            });
+            this.schedules.set(uiAction.code, sub);
+        });
+    }
+    trackByFn(idx, m) {
+        return m.uiAction.code ?? idx;
+    }
+    async fireAction(uiActionModel) {
+        if (uiActionModel.uiAction.disabled) {
+            return;
+        }
+        let options = {
+            nodeId: uiActionModel.nodeId,
+            widgetId: uiActionModel.widgetId,
+        };
+        await this.service.execute(uiActionModel.uiAction, uiActionModel, options);
+    }
+    async onActionClicked(event, uiActionModel) {
+        // event.stopPropagation();
+        if (uiActionModel.uiAction.disabled) {
+            return;
+        }
+        if (this.pressedButtonActive) {
+            this.pressedButtonActive = false;
+            // ui-tiered-menu emits a full UiAction (no 'event' property),
+            // ui-action-button emits { event: MouseEvent, code, descriptor }.
+            // Use the emitted UiAction only for tiered-menu sub-actions.
+            let actionToExecute = {
+                ...uiActionModel,
+                uiAction: !event.event && event.code ? event : uiActionModel.uiAction,
+            };
+            await this.fireAction(actionToExecute);
+            this.pressedButtonActive = true;
+        }
+    }
+    onActionDoubleClicked(event, uiActionModel) {
+        // event.stopPropagation();
+        // We do not handle double clicks
+    }
+    getbtnClass(uiActionModel) {
+        if (uiActionModel.descriptor?.color) {
+            return 'p-button-' + uiActionModel.descriptor?.color;
+        }
+        return '';
+    }
+    getType(uiActionModel) {
+        if (!uiActionModel.descriptor?.type) {
+            // console.log(`Action button type unset: ${uiActionModel?.uiAction?.code}`);
+        }
+        if (this.compLib === ComponentLibrary.PRIMENG) {
+            // return '';
+            // 'p-button-text': true,
+            /*   'p-button-raised': true,
+              'p-button-rounded': true,
+              'p-button-outlined': true,
+        */
+            switch (uiActionModel.descriptor?.type) {
+                case UiActionButtonType.NORMAL:
+                    return {
+                        'p-button-text': true,
+                        'p-button-rounded': true,
+                    };
+                case UiActionButtonType.FLAT:
+                    return { 'p-button-raised': true, 'p-button-rounded': true };
+                case UiActionButtonType.RAISED:
+                    return { 'p-button-raised': true, 'p-button-rounded': true };
+                case UiActionButtonType.STROKED:
+                    return { 'p-button-outlined': true, 'p-button-rounded': true };
+                case UiActionButtonType.MINI_FAB:
+                    return { 'p-button-rounded': true, 'p-button-text': true, 'p-button-raised': true };
+                default:
+                    return {
+                        'p-button-text': true,
+                        'p-button-raised': true,
+                        'p-button-rounded': true,
+                        'p-button-outlined': true,
+                    };
+            }
+        }
+        else {
+            switch (uiActionModel.descriptor?.type) {
+                case UiActionButtonType.NORMAL:
+                    return 'mat-mdc-button';
+                case UiActionButtonType.FLAT:
+                    return 'mat-mdc-flat-button';
+                case UiActionButtonType.RAISED:
+                    return 'mat-mdc-raised-button';
+                case UiActionButtonType.STROKED:
+                    return 'mat-mdc-stroked-button';
+                case UiActionButtonType.ICON:
+                    return 'mat-mdc-icon-button';
+                case UiActionButtonType.MINI_FAB:
+                    return 'mat-mdc-mini-fab';
+                case UiActionButtonType.FAB:
+                    return 'mat-mdc-fab';
+                default:
+                    // console.log(`Unhandled action button type case: ${uiActionModel.descriptor?.type}`);
+                    return `mat-button`;
+            }
+        }
+    }
+    iconPosition() {
+        return IconPosition;
+    }
+    isOnlyIcon(uiActionModel) {
+        return (uiActionModel.descriptor?.type === UiActionButtonType.ICON ||
+            uiActionModel.descriptor?.type === UiActionButtonType.MINI_FAB ||
+            uiActionModel.descriptor?.type === UiActionButtonType.FAB);
+    }
+    getTooltipPos(pos) {
+        if (pos) {
+            return pos.toLowerCase();
+        }
+        else {
+            return 'before';
+        }
+    }
+    getTooltipDelay(delay) {
+        return delay ? delay : 1000;
+    }
+    getTooltipHideDelay(delay) {
+        return delay ? delay : 2000;
+    }
+    checkScrollable() {
+        if (!this.scrollOnWrap) {
+            return;
+        }
+        const scrollable = this.containerRef?.nativeElement;
+        if (scrollable) {
+            this.isScrollable = scrollable.scrollWidth > scrollable.clientWidth;
+        }
+    }
+    scrollLeft() {
+        this.containerRef.nativeElement.scrollLeft -= 100;
+    }
+    scrollRight() {
+        this.containerRef.nativeElement.scrollLeft += 100;
+    }
+    scrollStart(direction) {
+        this.scrollTimeout = setTimeout(() => {
+            const delta = direction === 'left' ? -this.scrollSpeed : this.scrollSpeed;
+            this.scrollInterval = setInterval(() => {
+                this.containerRef.nativeElement.scrollLeft += delta;
+            }, this.scrollDelay);
+        }, this.scrollHoldDelay);
+    }
+    stopScroll() {
+        if (this.scrollTimeout) {
+            clearTimeout(this.scrollTimeout);
+            this.scrollTimeout = null;
+        }
+        if (this.scrollInterval) {
+            clearInterval(this.scrollInterval);
+            this.scrollInterval = null;
+        }
+    }
+    get isVertical() {
+        return this.toolbarPropertes?.direction === ToolbarDirection.VERTICAL;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: UiActionToolbarComponent, deps: [{ token: i1.UiActionService }, { token: i0.Injector }, { token: i0.ChangeDetectorRef }, { token: COMPONENT_LIBRARY }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.11", type: UiActionToolbarComponent, selector: "smart-ui-action-toolbar", inputs: { uiActionModels: "uiActionModels", uiActionDescriptorService: "uiActionDescriptorService", id: "id", scrollOnWrap: "scrollOnWrap", toolbarPropertes: "toolbarPropertes" }, host: { listeners: { "window:resize": "onResize()" } }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["container"], descendants: true }], usesOnChanges: true, ngImport: i0, template: "@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonLeft\"\n    (actionClick)=\"scrollLeft()\"\n    (mousedown)=\"scrollStart('left')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('left')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n\n<div\n  #container\n  class=\"uiActionButtonsContainer\"\n  [ngClass]=\"{\n    scrollableContent: scrollOnWrap,\n    verticalToolbar: isVertical,\n  }\"\n>\n  <ng-container *ngFor=\"let uiActionModel of uiActionModelsWithDescriptions; trackBy: trackByFn\">\n    @if (uiActionModel.uiAction.subActions && uiActionModel.uiAction.subActions.length > 0) {\n      <ui-tiered-menu\n        #menu\n        [triggerAction]=\"uiActionModel.uiAction\"\n        [subActions]=\"uiActionModel.uiAction.subActions!\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n      ></ui-tiered-menu>\n    } @else {\n      <ui-action-button\n        [descriptor]=\"uiActionModel.descriptor!\"\n        [code]=\"uiActionModel.uiAction.code\"\n        [disabled]=\"!!uiActionModel.uiAction.disabled\"\n        [addedCssClass]=\"uiActionModel.cssClass\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n        (actionDoubleClick)=\"onActionDoubleClicked($event, uiActionModel)\"\n      >\n      </ui-action-button>\n    }\n  </ng-container>\n</div>\n\n@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonRight\"\n    (actionClick)=\"scrollRight()\"\n    (mousedown)=\"scrollStart('right')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('right')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n", styles: [":host:has(.uiActionButtonsContainer.scrollableContent){display:flex;flex-direction:row;justify-content:space-between;gap:.5rem;width:100%;align-items:center}.uiActionButtonsContainer{display:flex;flex-direction:row;gap:1rem;flex-wrap:wrap}.uiActionButtonsContainer ::ng-deep button{display:flex;gap:1rem;align-items:center;justify-content:center}.uiActionButtonsContainer ::ng-deep .buttonWrapper{position:relative;width:fit-content;height:fit-content}.scrollableContent{flex:1;flex-wrap:nowrap;overflow-x:auto;overflow-y:visible;display:flex;scrollbar-width:none;padding:.5rem 0;align-items:center}.scrollableContent::-webkit-scrollbar{display:none!important}.verticalToolbar{display:flex;flex-direction:column}.verticalToolbar ::ng-deep ui-action-button,.verticalToolbar ::ng-deep button{width:100%;justify-content:flex-start}\n"], dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "component", type: i3.UiActionButtonComponent, selector: "ui-action-button", inputs: ["disabled", "descriptor", "code", "addedCssClass", "addBasicClasses"], outputs: ["actionClick", "actionDoubleClick"] }, { kind: "component", type: i4.MenuComponent, selector: "ui-tiered-menu", inputs: ["triggerAction", "isSubmenu"], outputs: ["actionClick", "submenuOpened"] }] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.11", ngImport: i0, type: UiActionToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-ui-action-toolbar', template: "@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonLeft\"\n    (actionClick)=\"scrollLeft()\"\n    (mousedown)=\"scrollStart('left')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('left')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n\n<div\n  #container\n  class=\"uiActionButtonsContainer\"\n  [ngClass]=\"{\n    scrollableContent: scrollOnWrap,\n    verticalToolbar: isVertical,\n  }\"\n>\n  <ng-container *ngFor=\"let uiActionModel of uiActionModelsWithDescriptions; trackBy: trackByFn\">\n    @if (uiActionModel.uiAction.subActions && uiActionModel.uiAction.subActions.length > 0) {\n      <ui-tiered-menu\n        #menu\n        [triggerAction]=\"uiActionModel.uiAction\"\n        [subActions]=\"uiActionModel.uiAction.subActions!\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n      ></ui-tiered-menu>\n    } @else {\n      <ui-action-button\n        [descriptor]=\"uiActionModel.descriptor!\"\n        [code]=\"uiActionModel.uiAction.code\"\n        [disabled]=\"!!uiActionModel.uiAction.disabled\"\n        [addedCssClass]=\"uiActionModel.cssClass\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n        (actionDoubleClick)=\"onActionDoubleClicked($event, uiActionModel)\"\n      >\n      </ui-action-button>\n    }\n  </ng-container>\n</div>\n\n@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonRight\"\n    (actionClick)=\"scrollRight()\"\n    (mousedown)=\"scrollStart('right')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('right')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n", styles: [":host:has(.uiActionButtonsContainer.scrollableContent){display:flex;flex-direction:row;justify-content:space-between;gap:.5rem;width:100%;align-items:center}.uiActionButtonsContainer{display:flex;flex-direction:row;gap:1rem;flex-wrap:wrap}.uiActionButtonsContainer ::ng-deep button{display:flex;gap:1rem;align-items:center;justify-content:center}.uiActionButtonsContainer ::ng-deep .buttonWrapper{position:relative;width:fit-content;height:fit-content}.scrollableContent{flex:1;flex-wrap:nowrap;overflow-x:auto;overflow-y:visible;display:flex;scrollbar-width:none;padding:.5rem 0;align-items:center}.scrollableContent::-webkit-scrollbar{display:none!important}.verticalToolbar{display:flex;flex-direction:column}.verticalToolbar ::ng-deep ui-action-button,.verticalToolbar ::ng-deep button{width:100%;justify-content:flex-start}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UiActionService }, { type: i0.Injector }, { type: i0.ChangeDetectorRef }, { type: i5.ComponentLibrary, decorators: [{
+                    type: Inject,
+                    args: [COMPONENT_LIBRARY]
+                }] }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['container', { static: false }]
+            }], uiActionModels: [{
+                type: Input
+            }], uiActionDescriptorService: [{
+                type: Input
+            }], id: [{
+                type: Input
+            }], scrollOnWrap: [{
+                type: Input
+            }], toolbarPropertes: [{
+                type: Input
+            }], onResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ui-action-toolbar.component.js","sourceRoot":"","sources":["../../../../../../projects/smart-ng-client/src/lib/view-context/smart-ui-action/ui-action-toolbar.component.ts","../../../../../../projects/smart-ng-client/src/lib/view-context/smart-ui-action/ui-action-toolbar.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChangeDetectorRef,\n  Component,\n  ElementRef,\n  HostListener,\n  Inject,\n  Injector,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  SimpleChanges,\n  ViewChild,\n} from '@angular/core';\nimport { TooltipPosition } from '@angular/material/tooltip';\nimport { interval, Subject, Subscription, takeUntil } from 'rxjs';\nimport {\n  IconPosition,\n  UiAction,\n  UiActionDescriptor,\n  UiActionTooltipTooltipPositionEnum,\n} from '../api';\nimport { UiActionButtonType } from '../api/model/uiActionButtonType';\nimport { UiActionDescriptorService } from './ui-action.descriptor.service';\nimport { UiActionModel } from './ui-action.model';\nimport { UiActionService } from './ui-action.service';\nimport { COMPONENT_LIBRARY, ComponentLibrary } from '../utility/componentLibrary';\nimport { ToolbarDirection, ToolbarProperties } from '../../smart-component-layout/api';\n\n@Component({\n  selector: 'smart-ui-action-toolbar',\n  templateUrl: './ui-action-toolbar.component.html',\n  styleUrls: ['./ui-action-toolbar.component.css'],\n})\nexport class UiActionToolbarComponent implements OnInit, OnChanges, OnDestroy {\n  @ViewChild('container', { static: false }) containerRef!: ElementRef;\n\n  private _destroy$: Subject<void> = new Subject();\n\n  componentLibrary = ComponentLibrary; // Expose the enum to the template\n\n  pressedButtonActive: boolean = true;\n\n  @Input() uiActionModels?: UiActionModel[];\n  @Input() uiActionDescriptorService?: UiActionDescriptorService;\n  @Input() id?: string;\n  @Input() scrollOnWrap: boolean = false;\n  @Input() toolbarPropertes?: ToolbarProperties;\n\n  uiActionModelsWithDescriptions?: UiActionModel[];\n\n  private manager!: UiActionDescriptorService;\n  private languageChangedSubscription?: Subscription;\n\n  isScrollable: boolean = false;\n\n  private scrollInterval: any;\n  private scrollTimeout: any;\n  private scrollSpeed: number = 5;\n  private scrollDelay: number = 16;\n  private scrollHoldDelay: number = 100;\n\n  private schedules = new Map<string, Subscription>();\n\n  constructor(\n    private service: UiActionService,\n    private inject: Injector,\n    public changeDetector: ChangeDetectorRef,\n    @Inject(COMPONENT_LIBRARY) public compLib: ComponentLibrary\n  ) {\n    // Injects the basic UiActionDescriptorService provided by the AppModule\n    this.manager = inject.get(UiActionDescriptorService);\n\n    this.subscribeToLanguageChange();\n  }\n\n  ngOnInit(): void {\n    // Overrides the basic UiActionDescriptorService with a custom one if there is one\n    if (this.uiActionDescriptorService) {\n      this.manager = this.uiActionDescriptorService;\n      this.subscribeToLanguageChange();\n    }\n    if (this.toolbarPropertes) {\n      this.scrollOnWrap = this.toolbarPropertes.scrollable ?? false;\n    }\n\n    this.setUp();\n  }\n\n  ngAfterViewInit() {\n    if (this.scrollOnWrap) {\n      setTimeout(() => {\n        this.checkScrollable();\n      });\n    }\n  }\n\n  @HostListener('window:resize') onResize() {\n    if (this.scrollOnWrap) {\n      this.checkScrollable();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes['uiActionModels']) {\n      let uiActionModels = changes['uiActionModels'].currentValue;\n      if (uiActionModels) {\n        this.uiActionModels = uiActionModels;\n\n        this.setUp();\n      }\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.clearSchedule();\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  private subscribeToLanguageChange(): void {\n    this.languageChangedSubscription?.unsubscribe();\n\n    this.languageChangedSubscription = this.manager.languageChanged\n      .pipe(takeUntil(this._destroy$))\n      .subscribe(() => {\n        this.setUp();\n      });\n  }\n\n  async setUp(): Promise<void> {\n    if (this.uiActionModels) {\n      let uiActionModelsWithDescriptions = [];\n      for (const uiActionModel of this.uiActionModels) {\n        const uiAction = uiActionModel.uiAction;\n\n        // using equality is a must here, undefined and null should be equal\n        if (this.id == uiAction.toolbar) {\n          uiActionModel.descriptor = await this.manager.getActionDescriptor(uiActionModel.uiAction);\n          uiActionModelsWithDescriptions.push(uiActionModel);\n        }\n      }\n      this.scheduleActions(this.uiActionModels);\n      this.uiActionModelsWithDescriptions = uiActionModelsWithDescriptions;\n\n      this.changeDetector.markForCheck();\n      this.changeDetector.detectChanges();\n\n      setTimeout(() => this.checkScrollable());\n    }\n  }\n\n  clearSchedule(): void {\n    this.schedules.forEach((sub) => sub.unsubscribe());\n    this.schedules.clear();\n  }\n\n  scheduleActions(uiActionModels: UiActionModel[]) {\n    this.clearSchedule();\n\n    uiActionModels.forEach((uiActionModel: UiActionModel) => {\n      let uiAction = uiActionModel.uiAction;\n\n      if (\n        !uiAction.code ||\n        uiAction.disabled ||\n        !uiAction.schedule?.intervalSeconds ||\n        this.schedules.has(uiAction.code) ||\n        uiAction.subActions?.length\n      ) {\n        return;\n      }\n\n      let intervalInMs = uiAction.schedule.intervalSeconds * 1000;\n      let sub = interval(intervalInMs)\n        .pipe(takeUntil(this._destroy$))\n        .subscribe(() => {\n          uiActionModel.uiAction!.params = {\n            ...uiActionModel.uiAction!.params,\n            scheduled: true,\n          };\n\n          this.fireAction(uiActionModel);\n        });\n\n      this.schedules.set(uiAction.code, sub);\n    });\n  }\n\n  trackByFn(idx: number, m: UiActionModel): string | number {\n    return m.uiAction.code ?? idx;\n  }\n\n  async fireAction(uiActionModel: UiActionModel): Promise<void> {\n    if (uiActionModel.uiAction.disabled) {\n      return;\n    }\n\n    let options = {\n      nodeId: uiActionModel.nodeId,\n      widgetId: uiActionModel.widgetId,\n    };\n\n    await this.service.execute(uiActionModel.uiAction, uiActionModel, options);\n  }\n\n  async onActionClicked(event: any, uiActionModel: UiActionModel): Promise<void> {\n    // event.stopPropagation();\n\n    if (uiActionModel.uiAction.disabled) {\n      return;\n    }\n\n    if (this.pressedButtonActive) {\n      this.pressedButtonActive = false;\n\n      // ui-tiered-menu emits a full UiAction (no 'event' property),\n      // ui-action-button emits { event: MouseEvent, code, descriptor }.\n      // Use the emitted UiAction only for tiered-menu sub-actions.\n      let actionToExecute: UiActionModel = {\n        ...uiActionModel,\n        uiAction: !event.event && event.code ? event : uiActionModel.uiAction,\n      };\n\n      await this.fireAction(actionToExecute);\n\n      this.pressedButtonActive = true;\n    }\n  }\n\n  onActionDoubleClicked(event: any, uiActionModel: UiActionModel): void {\n    // event.stopPropagation();\n    // We do not handle double clicks\n  }\n  getbtnClass(uiActionModel: UiActionModel): string {\n    if (uiActionModel.descriptor?.color) {\n      return 'p-button-' + uiActionModel.descriptor?.color;\n    }\n    return '';\n  }\n  getType(uiActionModel: UiActionModel): any {\n    if (!uiActionModel.descriptor?.type) {\n      // console.log(`Action button type unset: ${uiActionModel?.uiAction?.code}`);\n    }\n    if (this.compLib === ComponentLibrary.PRIMENG) {\n      // return '';\n\n      // 'p-button-text': true,\n      /*   'p-button-raised': true,\n        'p-button-rounded': true,\n        'p-button-outlined': true,\n  */\n      switch (uiActionModel.descriptor?.type) {\n        case UiActionButtonType.NORMAL:\n          return {\n            'p-button-text': true,\n            'p-button-rounded': true,\n          };\n        case UiActionButtonType.FLAT:\n          return { 'p-button-raised': true, 'p-button-rounded': true };\n        case UiActionButtonType.RAISED:\n          return { 'p-button-raised': true, 'p-button-rounded': true };\n        case UiActionButtonType.STROKED:\n          return { 'p-button-outlined': true, 'p-button-rounded': true };\n        case UiActionButtonType.MINI_FAB:\n          return { 'p-button-rounded': true, 'p-button-text': true, 'p-button-raised': true };\n        default:\n          return {\n            'p-button-text': true,\n            'p-button-raised': true,\n            'p-button-rounded': true,\n            'p-button-outlined': true,\n          };\n      }\n    } else {\n      switch (uiActionModel.descriptor?.type) {\n        case UiActionButtonType.NORMAL:\n          return 'mat-mdc-button';\n        case UiActionButtonType.FLAT:\n          return 'mat-mdc-flat-button';\n        case UiActionButtonType.RAISED:\n          return 'mat-mdc-raised-button';\n        case UiActionButtonType.STROKED:\n          return 'mat-mdc-stroked-button';\n        case UiActionButtonType.ICON:\n          return 'mat-mdc-icon-button';\n        case UiActionButtonType.MINI_FAB:\n          return 'mat-mdc-mini-fab';\n        case UiActionButtonType.FAB:\n          return 'mat-mdc-fab';\n        default:\n          // console.log(`Unhandled action button type case: ${uiActionModel.descriptor?.type}`);\n          return `mat-button`;\n      }\n    }\n  }\n\n  iconPosition(): typeof IconPosition {\n    return IconPosition;\n  }\n\n  isOnlyIcon(uiActionModel: UiActionModel): boolean {\n    return (\n      uiActionModel.descriptor?.type === UiActionButtonType.ICON ||\n      uiActionModel.descriptor?.type === UiActionButtonType.MINI_FAB ||\n      uiActionModel.descriptor?.type === UiActionButtonType.FAB\n    );\n  }\n\n  getTooltipPos(pos?: UiActionTooltipTooltipPositionEnum): TooltipPosition {\n    if (pos) {\n      return pos.toLowerCase() as TooltipPosition;\n    } else {\n      return 'before';\n    }\n  }\n\n  getTooltipDelay(delay?: number): number {\n    return delay ? delay : 1000;\n  }\n\n  getTooltipHideDelay(delay?: number): number {\n    return delay ? delay : 2000;\n  }\n\n  checkScrollable() {\n    if (!this.scrollOnWrap) {\n      return;\n    }\n\n    const scrollable = this.containerRef?.nativeElement;\n    if (scrollable) {\n      this.isScrollable = scrollable.scrollWidth > scrollable.clientWidth;\n    }\n  }\n  scrollLeft(): void {\n    this.containerRef.nativeElement.scrollLeft -= 100;\n  }\n\n  scrollRight(): void {\n    this.containerRef.nativeElement.scrollLeft += 100;\n  }\n\n  scrollStart(direction: 'left' | 'right'): void {\n    this.scrollTimeout = setTimeout(() => {\n      const delta = direction === 'left' ? -this.scrollSpeed : this.scrollSpeed;\n\n      this.scrollInterval = setInterval(() => {\n        this.containerRef.nativeElement.scrollLeft += delta;\n      }, this.scrollDelay);\n    }, this.scrollHoldDelay);\n  }\n\n  stopScroll(): void {\n    if (this.scrollTimeout) {\n      clearTimeout(this.scrollTimeout);\n      this.scrollTimeout = null;\n    }\n    if (this.scrollInterval) {\n      clearInterval(this.scrollInterval);\n      this.scrollInterval = null;\n    }\n  }\n\n  buttonLeft: UiActionDescriptor = {\n    title: '',\n    color: 'primary',\n    type: UiActionButtonType.RAISED,\n    icon: this.compLib === ComponentLibrary.PRIMENG ? 'chevron-left' : 'arrow_back',\n    iconPosition: IconPosition.PRE,\n  };\n\n  buttonRight: UiActionDescriptor = {\n    title: '',\n    color: 'primary',\n    type: UiActionButtonType.RAISED,\n    icon: this.compLib === ComponentLibrary.PRIMENG ? 'chevron-right' : 'arrow_forward',\n    iconPosition: IconPosition.PRE,\n  };\n\n  get isVertical(): boolean {\n    return this.toolbarPropertes?.direction === ToolbarDirection.VERTICAL;\n  }\n}\n","@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonLeft\"\n    (actionClick)=\"scrollLeft()\"\n    (mousedown)=\"scrollStart('left')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('left')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n\n<div\n  #container\n  class=\"uiActionButtonsContainer\"\n  [ngClass]=\"{\n    scrollableContent: scrollOnWrap,\n    verticalToolbar: isVertical,\n  }\"\n>\n  <ng-container *ngFor=\"let uiActionModel of uiActionModelsWithDescriptions; trackBy: trackByFn\">\n    @if (uiActionModel.uiAction.subActions && uiActionModel.uiAction.subActions.length > 0) {\n      <ui-tiered-menu\n        #menu\n        [triggerAction]=\"uiActionModel.uiAction\"\n        [subActions]=\"uiActionModel.uiAction.subActions!\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n      ></ui-tiered-menu>\n    } @else {\n      <ui-action-button\n        [descriptor]=\"uiActionModel.descriptor!\"\n        [code]=\"uiActionModel.uiAction.code\"\n        [disabled]=\"!!uiActionModel.uiAction.disabled\"\n        [addedCssClass]=\"uiActionModel.cssClass\"\n        (actionClick)=\"onActionClicked($event, uiActionModel)\"\n        (actionDoubleClick)=\"onActionDoubleClicked($event, uiActionModel)\"\n      >\n      </ui-action-button>\n    }\n  </ng-container>\n</div>\n\n@if (isScrollable && scrollOnWrap) {\n  <ui-action-button\n    [disabled]=\"!isScrollable\"\n    [descriptor]=\"buttonRight\"\n    (actionClick)=\"scrollRight()\"\n    (mousedown)=\"scrollStart('right')\"\n    (mouseup)=\"stopScroll()\"\n    (mouseleave)=\"stopScroll()\"\n    (touchstart)=\"scrollStart('right')\"\n    (touchend)=\"stopScroll()\"\n  />\n}\n"]}

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

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

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

@@ -0,0 +1,7 @@
+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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