barsa-sap-ui 2.2.1 → 2.2.3

package/esm2022/lib/report-view-renderer.directive.mjs

@@ -0,0 +1,392 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { takeUntil } from 'rxjs/operators';
+import { BaseDirective } from 'barsa-novin-ray-core';
+import * as i0 from "@angular/core";
+import * as i1 from "barsa-novin-ray-core";
+export class ReportViewRendererDirective extends BaseDirective {
+    constructor(_portalService, _ulvMainService, _vcr, _injector, _el) {
+        super(_el);
+        this._portalService = _portalService;
+        this._ulvMainService = _ulvMainService;
+        this._vcr = _vcr;
+        this._injector = _injector;
+        this._el = _el;
+        this.editFormPanelCancel = new EventEmitter();
+        this.editFormPanelValueChange = new EventEmitter();
+        this.resetWorkflowState = new EventEmitter();
+        this.ulvCommandClick = new EventEmitter();
+        this.sortAscending = new EventEmitter();
+        this.sortDescending = new EventEmitter();
+        this.filter = new EventEmitter();
+        this.deselectAll = new EventEmitter();
+        this.rowCheck = new EventEmitter();
+        this.rowClick = new EventEmitter();
+        this.executeToolbarButton = new EventEmitter();
+        this.expandClick = new EventEmitter();
+        this.trackBySelectedFn = new EventEmitter();
+        this.cartableFormClosed = new EventEmitter();
+        this.createNewMo = new EventEmitter();
+        this.updateMo = new EventEmitter();
+        this.hasDetailsInRow = new EventEmitter();
+        this.allCheckbox = new EventEmitter();
+        this.mandatory = new EventEmitter();
+        this.editFormPanelSave = new EventEmitter();
+        this.columnResized = new EventEmitter();
+        this.selectNextInlineRecord = new EventEmitter();
+        this.workflowShareButtons = new EventEmitter();
+        this.escapeKey = new EventEmitter();
+        this.resetGridSettings = new EventEmitter();
+        this.sortSettingsChange = new EventEmitter();
+    }
+    ngOnChanges(changes) {
+        const { view } = changes;
+        if (view && !view.firstChange) {
+            this._reportViewRef.destroy();
+            this._vcr.clear();
+            this._insertView(view.currentValue);
+        }
+        else {
+            if (this._reportViewRef) {
+                this._reportViewRef.instance.ngOnChanges(changes);
+            }
+        }
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this._insertView(this.view);
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this._reportViewRef?.destroy();
+    }
+    _insertView(view) {
+        if (!view) {
+            return;
+        }
+        const { Module, ModuleFileName, Name, Selector } = view.UiComponent;
+        this._ulvMainService.setUiViewerClass(Selector);
+        this._portalService
+            .getComponent(Module, ModuleFileName, Name, Selector, this._injector)
+            .pipe(takeUntil(this._onDestroy$))
+            .subscribe((componentRef) => {
+            const instance = componentRef.instance;
+            instance.cartableTemplates = this.cartableTemplates;
+            instance.cartableChildsMo = this.cartableChildsMo;
+            instance.moDataList = this.moDataList;
+            instance.contextSetting = this.contextSetting;
+            instance.groupby = this.groupby;
+            instance.groupSummary = this.groupSummary;
+            instance.simpleInlineEdit = this.simpleInlineEdit;
+            instance.UlvMainCtrlr = this.UlvMainCtrlr;
+            instance.pagingSetting = this.pagingSetting;
+            instance.hideSearchpanel = this.hideSearchpanel;
+            instance.customFieldInfo = this.customFieldInfo;
+            instance.disableResponsive = this.disableResponsive;
+            instance.toolbarButtons = this.toolbarButtons;
+            instance.popin = this.popin;
+            instance.contextView = this.contextView;
+            instance.isCheckList = this.isCheckList;
+            instance.toolbarButtons = this.toolbarButtons;
+            instance.columns = this.columns;
+            instance.listEditViewId = this.listEditViewId;
+            instance.typeViewId = this.typeViewId;
+            instance.gridFreeColumnSizing = this.gridFreeColumnSizing;
+            instance.inDialog = this.inDialog;
+            instance.hasInlineDeleteButton = this.hasInlineDeleteButton;
+            instance.hasInlineEditButton = this.hasInlineEditButton;
+            instance.isMultiSelect = this.isMultiSelect;
+            instance.columnsCount = this.columnsCount;
+            instance.hideToolbar = this.hideToolbar;
+            instance.hideTitle = this.hideTitle;
+            instance.extraRelation = this.extraRelation;
+            instance.secondaryColumns = this.secondaryColumns;
+            instance.contextMenuItems = this.contextMenuItems;
+            instance.conditionalFormats = this.conditionalFormats;
+            instance.disableOverflowContextMenu = this.disableOverflowContextMenu;
+            instance.typeDefId = this.typeDefId;
+            instance.reportId = this.reportId;
+            instance.deviceName = this.deviceName;
+            instance.deviceSize = this.deviceSize;
+            instance.mobileOrTablet = this.mobileOrTablet;
+            instance.containerWidth = this.containerWidth;
+            instance.columnsCount = this.columnsCount;
+            instance.selectedCount = this.selectedCount;
+            instance.hideOpenIcon = this.hideOpenIcon;
+            instance.openOnClick = this.openOnClick;
+            instance.access = this.access;
+            instance.title = this.title;
+            instance.hasSummary = this.hasSummary;
+            instance.contentDensity = this.contentDensity;
+            instance.relationList = this.relationList;
+            instance.allColumns = this.allColumns ?? this.columns;
+            instance.viewSetting = view.UiComponent.Settings;
+            instance.inlineEditMode = this.inlineEditMode;
+            instance.onlyInlineEdit = this.onlyInlineEdit;
+            instance.allowInlineEdit = this.allowInlineEdit;
+            instance.formSetting = this.formSetting;
+            instance.navigationArrow = this.navigationArrow;
+            instance.selectedMo = this.selectedMo;
+            instance.hasSelected = this.hasSelected;
+            instance.rtl = this.rtl;
+            instance.escapeKey?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.escapeKey.emit(mo);
+            });
+            instance.resetWorkflowState?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.resetWorkflowState.emit(mo);
+            });
+            instance.editFormPanelValueChange
+                ?.pipe(takeUntil(this._onDestroy$))
+                .subscribe(({ mo, fieldDbName }) => {
+                this.editFormPanelValueChange.emit({ mo, fieldDbName });
+            });
+            instance.selectNextInlineRecord?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.selectNextInlineRecord.emit(mo);
+            });
+            instance.editFormPanelCancel?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.editFormPanelCancel.emit(mo);
+            });
+            instance.ulvCommandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.ulvCommandClick.emit(e);
+            });
+            instance.sortAscending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.sortAscending.emit(e);
+            });
+            instance.sortDescending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.sortDescending.emit(e);
+            });
+            instance.filter?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.filter.emit(e);
+            });
+            instance.columnResized?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.columnResized.emit(e);
+            });
+            instance.rowCheck?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.rowCheck.emit(e);
+            });
+            instance.deselectAll?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {
+                this.deselectAll.emit();
+            });
+            instance.rowClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.rowClick.emit(e);
+            });
+            instance.expandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.expandClick.emit(e);
+            });
+            instance.allCheckbox?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.allCheckbox.emit(e);
+            });
+            instance.editFormPanelSave?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.editFormPanelSave.emit(mo);
+            });
+            instance.cartableFormClosed?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.cartableFormClosed.emit(e);
+            });
+            instance.createNewMo?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {
+                this.createNewMo.emit();
+            });
+            instance.hasDetailsInRow?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.hasDetailsInRow.emit(mo);
+            });
+            instance.updateMo?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {
+                this.updateMo.emit(mo);
+            });
+            instance.mandatory?.pipe(takeUntil(this._onDestroy$)).subscribe((isValid) => {
+                this.mandatory.emit(isValid);
+            });
+            instance.executeToolbarButton?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.executeToolbarButton.emit(e);
+            });
+            instance.resetGridSettings?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.resetGridSettings.emit();
+            });
+            instance.sortSettingsChange?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {
+                this.sortSettingsChange.emit(e);
+            });
+            instance.workflowShareButtons
+                ?.pipe(takeUntil(this._onDestroy$))
+                .subscribe((e) => {
+                this.workflowShareButtons.emit(e);
+            });
+            this._vcr.insert(componentRef.hostView);
+            this._reportViewRef = componentRef;
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ReportViewRendererDirective, deps: [{ token: i1.PortalService }, { token: i1.UlvMainService }, { token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: ReportViewRendererDirective, selector: "[reportViewRenderer]", inputs: { view: "view", moDataList: "moDataList", allChecked: "allChecked", contextSetting: "contextSetting", groupby: "groupby", isCheckList: "isCheckList", hasInlineDeleteButton: "hasInlineDeleteButton", hasInlineEditButton: "hasInlineEditButton", selectedCount: "selectedCount", hideToolbar: "hideToolbar", toolbarButtons: "toolbarButtons", pagingSetting: "pagingSetting", UlvMainCtrlr: "UlvMainCtrlr", hasSummary: "hasSummary", relationList: "relationList", columns: "columns", columnsCount: "columnsCount", secondaryColumns: "secondaryColumns", contextMenuItems: "contextMenuItems", conditionalFormats: "conditionalFormats", deviceName: "deviceName", deviceSize: "deviceSize", mobileOrTablet: "mobileOrTablet", access: "access", title: "title", customFieldInfo: "customFieldInfo", selectedMo: "selectedMo", allColumns: "allColumns", viewSetting: "viewSetting", inlineEditMode: "inlineEditMode", onlyInlineEdit: "onlyInlineEdit", allowInlineEdit: "allowInlineEdit", popin: "popin", hasSelected: "hasSelected", formSetting: "formSetting", disableOverflowContextMenu: "disableOverflowContextMenu", navigationArrow: "navigationArrow", typeDefId: "typeDefId", reportId: "reportId", listEditViewId: "listEditViewId", typeViewId: "typeViewId", containerWidth: "containerWidth", extraRelation: "extraRelation", contextView: "contextView", contentDensity: "contentDensity", hideOpenIcon: "hideOpenIcon", hideTitle: "hideTitle", groupSummary: "groupSummary", openOnClick: "openOnClick", inDialog: "inDialog", isMultiSelect: "isMultiSelect", rtl: "rtl", disableResponsive: "disableResponsive", simpleInlineEdit: "simpleInlineEdit", hideSearchpanel: "hideSearchpanel", gridFreeColumnSizing: "gridFreeColumnSizing", cartableTemplates: "cartableTemplates", cartableChildsMo: "cartableChildsMo" }, outputs: { editFormPanelCancel: "editFormPanelCancel", editFormPanelValueChange: "editFormPanelValueChange", resetWorkflowState: "resetWorkflowState", ulvCommandClick: "ulvCommandClick", sortAscending: "sortAscending", sortDescending: "sortDescending", filter: "filter", deselectAll: "deselectAll", rowCheck: "rowCheck", rowClick: "rowClick", executeToolbarButton: "executeToolbarButton", expandClick: "expandClick", trackBySelectedFn: "trackBySelectedFn", cartableFormClosed: "cartableFormClosed", createNewMo: "createNewMo", updateMo: "updateMo", hasDetailsInRow: "hasDetailsInRow", allCheckbox: "allCheckbox", mandatory: "mandatory", editFormPanelSave: "editFormPanelSave", columnResized: "columnResized", selectNextInlineRecord: "selectNextInlineRecord", workflowShareButtons: "workflowShareButtons", escapeKey: "escapeKey", resetGridSettings: "resetGridSettings", sortSettingsChange: "sortSettingsChange" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ReportViewRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[reportViewRenderer]',
+                    standalone: false
+                }]
+        }], ctorParameters: () => [{ type: i1.PortalService }, { type: i1.UlvMainService }, { type: i0.ViewContainerRef }, { type: i0.Injector }, { type: i0.ElementRef }], propDecorators: { view: [{
+                type: Input
+            }], moDataList: [{
+                type: Input
+            }], allChecked: [{
+                type: Input
+            }], contextSetting: [{
+                type: Input
+            }], groupby: [{
+                type: Input
+            }], isCheckList: [{
+                type: Input
+            }], hasInlineDeleteButton: [{
+                type: Input
+            }], hasInlineEditButton: [{
+                type: Input
+            }], selectedCount: [{
+                type: Input
+            }], hideToolbar: [{
+                type: Input
+            }], toolbarButtons: [{
+                type: Input
+            }], pagingSetting: [{
+                type: Input
+            }], UlvMainCtrlr: [{
+                type: Input
+            }], hasSummary: [{
+                type: Input
+            }], relationList: [{
+                type: Input
+            }], columns: [{
+                type: Input
+            }], columnsCount: [{
+                type: Input
+            }], secondaryColumns: [{
+                type: Input
+            }], contextMenuItems: [{
+                type: Input
+            }], conditionalFormats: [{
+                type: Input
+            }], deviceName: [{
+                type: Input
+            }], deviceSize: [{
+                type: Input
+            }], mobileOrTablet: [{
+                type: Input
+            }], access: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], customFieldInfo: [{
+                type: Input
+            }], selectedMo: [{
+                type: Input
+            }], allColumns: [{
+                type: Input
+            }], viewSetting: [{
+                type: Input
+            }], inlineEditMode: [{
+                type: Input
+            }], onlyInlineEdit: [{
+                type: Input
+            }], allowInlineEdit: [{
+                type: Input
+            }], popin: [{
+                type: Input
+            }], hasSelected: [{
+                type: Input
+            }], formSetting: [{
+                type: Input
+            }], disableOverflowContextMenu: [{
+                type: Input
+            }], navigationArrow: [{
+                type: Input
+            }], typeDefId: [{
+                type: Input
+            }], reportId: [{
+                type: Input
+            }], listEditViewId: [{
+                type: Input
+            }], typeViewId: [{
+                type: Input
+            }], containerWidth: [{
+                type: Input
+            }], extraRelation: [{
+                type: Input
+            }], contextView: [{
+                type: Input
+            }], contentDensity: [{
+                type: Input
+            }], hideOpenIcon: [{
+                type: Input
+            }], hideTitle: [{
+                type: Input
+            }], groupSummary: [{
+                type: Input
+            }], openOnClick: [{
+                type: Input
+            }], inDialog: [{
+                type: Input
+            }], isMultiSelect: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], disableResponsive: [{
+                type: Input
+            }], simpleInlineEdit: [{
+                type: Input
+            }], hideSearchpanel: [{
+                type: Input
+            }], gridFreeColumnSizing: [{
+                type: Input
+            }], cartableTemplates: [{
+                type: Input
+            }], cartableChildsMo: [{
+                type: Input
+            }], editFormPanelCancel: [{
+                type: Output
+            }], editFormPanelValueChange: [{
+                type: Output
+            }], resetWorkflowState: [{
+                type: Output
+            }], ulvCommandClick: [{
+                type: Output
+            }], sortAscending: [{
+                type: Output
+            }], sortDescending: [{
+                type: Output
+            }], filter: [{
+                type: Output
+            }], deselectAll: [{
+                type: Output
+            }], rowCheck: [{
+                type: Output
+            }], rowClick: [{
+                type: Output
+            }], executeToolbarButton: [{
+                type: Output
+            }], expandClick: [{
+                type: Output
+            }], trackBySelectedFn: [{
+                type: Output
+            }], cartableFormClosed: [{
+                type: Output
+            }], createNewMo: [{
+                type: Output
+            }], updateMo: [{
+                type: Output
+            }], hasDetailsInRow: [{
+                type: Output
+            }], allCheckbox: [{
+                type: Output
+            }], mandatory: [{
+                type: Output
+            }], editFormPanelSave: [{
+                type: Output
+            }], columnResized: [{
+                type: Output
+            }], selectNextInlineRecord: [{
+                type: Output
+            }], workflowShareButtons: [{
+                type: Output
+            }], escapeKey: [{
+                type: Output
+            }], resetGridSettings: [{
+                type: Output
+            }], sortSettingsChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"report-view-renderer.directive.js","sourceRoot":"","sources":["../../../../projects/barsa-sap-ui/src/lib/report-view-renderer.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    ComponentRef,\r\n    Directive,\r\n    ElementRef,\r\n    EventEmitter,\r\n    Injector,\r\n    Input,\r\n    OnChanges,\r\n    OnDestroy,\r\n    OnInit,\r\n    Output,\r\n    SimpleChanges,\r\n    ViewContainerRef\r\n} from '@angular/core';\r\nimport { ContentDensity } from '@fundamental-ngx/core';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport {\r\n    AbbrevationDeviceSize,\r\n    BaseDirective,\r\n    columnsResizedEventArgs,\r\n    DefaultCommandsAccess,\r\n    DeviceSize,\r\n    FormSetting,\r\n    MenuItem,\r\n    MetaobjectDataModel,\r\n    PortalService,\r\n    RelationItemType,\r\n    ReportViewBaseComponent,\r\n    ReportViewColumn,\r\n    SortSetting,\r\n    UiReportViewBase,\r\n    UiReportViewBaseSetting,\r\n    ShareButtonsChoiceDef,\r\n    TypeUlvMainCtrlr,\r\n    PagingSetting,\r\n    UlvMainService\r\n} from 'barsa-novin-ray-core';\r\n\r\n@Directive({\r\n    selector: '[reportViewRenderer]',\r\n    standalone: false\r\n})\r\nexport class ReportViewRendererDirective extends BaseDirective implements OnChanges, OnInit, OnDestroy {\r\n    @Input() view: UiReportViewBase;\r\n    @Input() moDataList: MetaobjectDataModel[];\r\n    @Input() allChecked: boolean;\r\n    @Input() contextSetting: any;\r\n    @Input() groupby: SortSetting[];\r\n    @Input() isCheckList: boolean;\r\n    @Input() hasInlineDeleteButton: boolean;\r\n    @Input() hasInlineEditButton: boolean;\r\n    @Input() selectedCount: number;\r\n    @Input() hideToolbar: boolean;\r\n    @Input() toolbarButtons: MenuItem[];\r\n    @Input() pagingSetting: PagingSetting;\r\n    @Input() UlvMainCtrlr: TypeUlvMainCtrlr;\r\n    @Input() hasSummary: boolean;\r\n    @Input() relationList: Array<RelationItemType>;\r\n    @Input() columns: ReportViewColumn[];\r\n    @Input() columnsCount: number;\r\n    @Input() secondaryColumns: ReportViewColumn[];\r\n    @Input() contextMenuItems: MenuItem[];\r\n    @Input() conditionalFormats: any[];\r\n    @Input() deviceName: DeviceSize;\r\n    @Input() deviceSize: AbbrevationDeviceSize;\r\n    @Input() mobileOrTablet: boolean;\r\n    @Input() access: DefaultCommandsAccess;\r\n    @Input() title: string;\r\n    @Input() customFieldInfo: MetaobjectDataModel | any;\r\n    @Input() selectedMo: MetaobjectDataModel;\r\n    @Input() allColumns: ReportViewColumn[];\r\n    @Input() viewSetting: UiReportViewBaseSetting;\r\n    @Input() inlineEditMode: boolean;\r\n    @Input() onlyInlineEdit: boolean;\r\n    @Input() allowInlineEdit: boolean;\r\n    @Input() popin: boolean;\r\n    @Input() hasSelected: boolean;\r\n    @Input() formSetting: FormSetting;\r\n    @Input() disableOverflowContextMenu: boolean;\r\n    @Input() navigationArrow: string;\r\n    @Input() typeDefId: string;\r\n    @Input() reportId: string;\r\n    @Input() listEditViewId: string;\r\n    @Input() typeViewId: string;\r\n    @Input() containerWidth: number;\r\n    @Input() extraRelation: any;\r\n    @Input() contextView: any;\r\n    @Input() contentDensity: ContentDensity;\r\n    @Input() hideOpenIcon: boolean;\r\n    @Input() hideTitle: boolean;\r\n    @Input() groupSummary: boolean;\r\n    @Input() openOnClick: boolean;\r\n    @Input() inDialog: boolean;\r\n    @Input() isMultiSelect: boolean;\r\n    @Input() rtl: boolean;\r\n    @Input() disableResponsive: boolean;\r\n    @Input() simpleInlineEdit: boolean;\r\n    @Input() hideSearchpanel: boolean;\r\n    @Input() gridFreeColumnSizing: boolean;\r\n    @Input() cartableTemplates: { [key: string]: FormSetting };\r\n    @Input() cartableChildsMo: { [key: string]: MetaobjectDataModel };\r\n\r\n    @Output() editFormPanelCancel = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() editFormPanelValueChange = new EventEmitter<{ mo: MetaobjectDataModel; fieldDbName?: string }>();\r\n\r\n    @Output() resetWorkflowState = new EventEmitter<any>();\r\n    @Output() ulvCommandClick = new EventEmitter<any>();\r\n    @Output() sortAscending = new EventEmitter<any>();\r\n    @Output() sortDescending = new EventEmitter<any>();\r\n    @Output() filter = new EventEmitter<any>();\r\n    @Output() deselectAll = new EventEmitter<void>();\r\n    @Output() rowCheck = new EventEmitter<{ mo; index; cause? }>();\r\n    @Output() rowClick = new EventEmitter<{ mo; index }>();\r\n    @Output() executeToolbarButton = new EventEmitter<{ itemId: string; options?: any }>();\r\n    @Output() expandClick = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() trackBySelectedFn = new EventEmitter<{ index; record }>();\r\n    @Output() cartableFormClosed = new EventEmitter<{ index; mo }>();\r\n    @Output() createNewMo = new EventEmitter<void>();\r\n    @Output() updateMo = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() hasDetailsInRow = new EventEmitter<boolean>();\r\n    @Output() allCheckbox = new EventEmitter<boolean>();\r\n    @Output() mandatory = new EventEmitter<boolean>();\r\n    @Output() editFormPanelSave = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() columnResized = new EventEmitter<columnsResizedEventArgs>();\r\n    @Output() selectNextInlineRecord = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() workflowShareButtons = new EventEmitter<ShareButtonsChoiceDef>();\r\n    @Output() escapeKey = new EventEmitter<MetaobjectDataModel>();\r\n    @Output() resetGridSettings = new EventEmitter<void>();\r\n    @Output() sortSettingsChange = new EventEmitter<SortSetting[]>();\r\n\r\n    _reportViewRef: ComponentRef<ReportViewBaseComponent<UiReportViewBaseSetting>>;\r\n    constructor(\r\n        private _portalService: PortalService,\r\n        private _ulvMainService: UlvMainService,\r\n        private _vcr: ViewContainerRef,\r\n        private _injector: Injector,\r\n        protected _el: ElementRef\r\n    ) {\r\n        super(_el);\r\n    }\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        const { view } = changes;\r\n\r\n        if (view && !view.firstChange) {\r\n            this._reportViewRef.destroy();\r\n            this._vcr.clear();\r\n            this._insertView(view.currentValue);\r\n        } else {\r\n            if (this._reportViewRef) {\r\n                this._reportViewRef.instance.ngOnChanges(changes);\r\n            }\r\n        }\r\n    }\r\n    ngOnInit(): void {\r\n        super.ngOnInit();\r\n        this._insertView(this.view);\r\n    }\r\n    ngOnDestroy(): void {\r\n        super.ngOnDestroy();\r\n        this._reportViewRef?.destroy();\r\n    }\r\n    private _insertView(view): void {\r\n        if (!view) {\r\n            return;\r\n        }\r\n        const { Module, ModuleFileName, Name, Selector } = view.UiComponent;\r\n        this._ulvMainService.setUiViewerClass(Selector);\r\n        this._portalService\r\n            .getComponent(Module, ModuleFileName, Name, Selector, this._injector)\r\n            .pipe(takeUntil(this._onDestroy$))\r\n            .subscribe((componentRef: ComponentRef<ReportViewBaseComponent<UiReportViewBaseSetting>>) => {\r\n                const instance = componentRef.instance;\r\n                instance.cartableTemplates = this.cartableTemplates;\r\n                instance.cartableChildsMo = this.cartableChildsMo;\r\n                instance.moDataList = this.moDataList;\r\n                instance.contextSetting = this.contextSetting;\r\n                instance.groupby = this.groupby;\r\n                instance.groupSummary = this.groupSummary;\r\n                instance.simpleInlineEdit = this.simpleInlineEdit;\r\n                instance.UlvMainCtrlr = this.UlvMainCtrlr;\r\n                instance.pagingSetting = this.pagingSetting;\r\n                instance.hideSearchpanel = this.hideSearchpanel;\r\n                instance.customFieldInfo = this.customFieldInfo;\r\n                instance.disableResponsive = this.disableResponsive;\r\n                instance.toolbarButtons = this.toolbarButtons;\r\n                instance.popin = this.popin;\r\n                instance.contextView = this.contextView;\r\n                instance.isCheckList = this.isCheckList;\r\n                instance.toolbarButtons = this.toolbarButtons;\r\n                instance.columns = this.columns;\r\n                instance.listEditViewId = this.listEditViewId;\r\n                instance.typeViewId = this.typeViewId;\r\n                instance.gridFreeColumnSizing = this.gridFreeColumnSizing;\r\n                instance.inDialog = this.inDialog;\r\n                instance.hasInlineDeleteButton = this.hasInlineDeleteButton;\r\n                instance.hasInlineEditButton = this.hasInlineEditButton;\r\n                instance.isMultiSelect = this.isMultiSelect;\r\n                instance.columnsCount = this.columnsCount;\r\n                instance.hideToolbar = this.hideToolbar;\r\n                instance.hideTitle = this.hideTitle;\r\n                instance.extraRelation = this.extraRelation;\r\n                instance.secondaryColumns = this.secondaryColumns;\r\n                instance.contextMenuItems = this.contextMenuItems;\r\n                instance.conditionalFormats = this.conditionalFormats;\r\n                instance.disableOverflowContextMenu = this.disableOverflowContextMenu;\r\n                instance.typeDefId = this.typeDefId;\r\n                instance.reportId = this.reportId;\r\n                instance.deviceName = this.deviceName;\r\n                instance.deviceSize = this.deviceSize;\r\n                instance.mobileOrTablet = this.mobileOrTablet;\r\n                instance.containerWidth = this.containerWidth;\r\n                instance.columnsCount = this.columnsCount;\r\n                instance.selectedCount = this.selectedCount;\r\n                instance.hideOpenIcon = this.hideOpenIcon;\r\n                instance.openOnClick = this.openOnClick;\r\n                instance.access = this.access;\r\n                instance.title = this.title;\r\n                instance.hasSummary = this.hasSummary;\r\n                instance.contentDensity = this.contentDensity;\r\n                instance.relationList = this.relationList;\r\n                instance.allColumns = this.allColumns ?? this.columns;\r\n                instance.viewSetting = view.UiComponent.Settings;\r\n                instance.inlineEditMode = this.inlineEditMode;\r\n                instance.onlyInlineEdit = this.onlyInlineEdit;\r\n                instance.allowInlineEdit = this.allowInlineEdit;\r\n                instance.formSetting = this.formSetting;\r\n                instance.navigationArrow = this.navigationArrow;\r\n                instance.selectedMo = this.selectedMo;\r\n                instance.hasSelected = this.hasSelected;\r\n                instance.rtl = this.rtl;\r\n                instance.escapeKey?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.escapeKey.emit(mo);\r\n                });\r\n                instance.resetWorkflowState?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.resetWorkflowState.emit(mo);\r\n                });\r\n                instance.editFormPanelValueChange\r\n                    ?.pipe(takeUntil(this._onDestroy$))\r\n                    .subscribe(({ mo, fieldDbName }) => {\r\n                        this.editFormPanelValueChange.emit({ mo, fieldDbName });\r\n                    });\r\n                instance.selectNextInlineRecord?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.selectNextInlineRecord.emit(mo);\r\n                });\r\n                instance.editFormPanelCancel?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.editFormPanelCancel.emit(mo);\r\n                });\r\n                instance.ulvCommandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.ulvCommandClick.emit(e);\r\n                });\r\n                instance.sortAscending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.sortAscending.emit(e);\r\n                });\r\n                instance.sortDescending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.sortDescending.emit(e);\r\n                });\r\n                instance.filter?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.filter.emit(e);\r\n                });\r\n\r\n                instance.columnResized?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.columnResized.emit(e);\r\n                });\r\n\r\n                instance.rowCheck?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index; cause? }) => {\r\n                    this.rowCheck.emit(e);\r\n                });\r\n                instance.deselectAll?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {\r\n                    this.deselectAll.emit();\r\n                });\r\n                instance.rowClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index }) => {\r\n                    this.rowClick.emit(e);\r\n                });\r\n                instance.expandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e: MetaobjectDataModel) => {\r\n                    this.expandClick.emit(e);\r\n                });\r\n                instance.allCheckbox?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.allCheckbox.emit(e);\r\n                });\r\n                instance.editFormPanelSave?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.editFormPanelSave.emit(mo);\r\n                });\r\n                instance.cartableFormClosed?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index }) => {\r\n                    this.cartableFormClosed.emit(e);\r\n                });\r\n                instance.createNewMo?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {\r\n                    this.createNewMo.emit();\r\n                });\r\n                instance.hasDetailsInRow?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.hasDetailsInRow.emit(mo);\r\n                });\r\n                instance.updateMo?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\r\n                    this.updateMo.emit(mo);\r\n                });\r\n                instance.mandatory?.pipe(takeUntil(this._onDestroy$)).subscribe((isValid) => {\r\n                    this.mandatory.emit(isValid);\r\n                });\r\n                instance.executeToolbarButton?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.executeToolbarButton.emit(e);\r\n                });\r\n                instance.resetGridSettings?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.resetGridSettings.emit();\r\n                });\r\n                instance.sortSettingsChange?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\r\n                    this.sortSettingsChange.emit(e);\r\n                });\r\n                instance.workflowShareButtons\r\n                    ?.pipe(takeUntil(this._onDestroy$))\r\n                    .subscribe((e: ShareButtonsChoiceDef) => {\r\n                        this.workflowShareButtons.emit(e);\r\n                    });\r\n                this._vcr.insert(componentRef.hostView);\r\n                this._reportViewRef = componentRef;\r\n            });\r\n    }\r\n}\r\n"]}

package/esm2022/lib/responsive-toolbar/responsive-toolbar.component.mjs

@@ -0,0 +1,50 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChildren } from '@angular/core';
+import { BaseComponent } from 'barsa-novin-ray-core';
+import * as i0 from "@angular/core";
+import * as i1 from "barsa-novin-ray-core";
+import * as i2 from "@fundamental-ngx/core/button";
+import * as i3 from "@fundamental-ngx/core/toolbar";
+import * as i4 from "@angular/common";
+export class ResponsiveToolbarComponent extends BaseComponent {
+    constructor(portalService) {
+        super();
+        this.portalService = portalService;
+        this.btnClick = new EventEmitter();
+        this.dirValue$ = this.portalService.dirValue$;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        this.btns = this.buttons;
+    }
+    calculateWidthOfButtons() {
+        const tempList = [];
+        this.btnListRef.toArray().forEach((btnRef, i) => {
+            let btnTemp = this.buttons[i];
+            if (this.buttons[i] === '-') {
+                btnTemp = { text: '-', width: btnRef.nativeElement.offsetWidth };
+            }
+            else {
+                btnTemp.width = btnRef.nativeElement.offsetWidth + 10;
+            }
+            tempList.push(btnTemp);
+        });
+        this.buttonsCalculated = [...tempList];
+    }
+    onButtonClick(button) {
+        this.btnClick.emit(button);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResponsiveToolbarComponent, deps: [{ token: i1.PortalService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "18.2.13", type: ResponsiveToolbarComponent, selector: "bsu-responsive-toolbar", inputs: { buttons: "buttons" }, outputs: { btnClick: "btnClick" }, viewQueries: [{ propertyName: "btnListRef", predicate: ["btnRef"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<!-- <div style=\"width: 100%; height: 0; visibility: hidden\" #containerRef>\r\n<ng-container\r\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\r\n></ng-container>\r\n</div>\r\n<bsu-responsive-toolbar-renderer\r\n  *ngIf=\"buttonsCalculated\"\r\n  [buttons]=\"buttonsCalculated\"\r\n  (btnClick)=\"onButtonClick($event)\"\r\n  [renderToolbar]=\"renderToolbar\"\r\n></bsu-responsive-toolbar-renderer>\r\n\r\n<ng-template #renderToolbar let-btnList>\r\n  <ng-container *ngFor=\"let btn of btnList\">\r\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\r\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\r\n    </ng-container>\r\n    <ng-template #btnCommand>\r\n      <ui5-button\r\n        #btnRef\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        class=\"toolbar-btn\"\r\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\r\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >{{ btn.text }}\r\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\r\n        /></ui5-button>\r\n      </ng-template>\r\n    </ng-container>\r\n  </ng-template> -->\r\n\r\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\r\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\r\n    <fd-toolbar-separator></fd-toolbar-separator>\r\n    } @else {\r\n    <button\r\n        fd-toolbar-item\r\n        fd-button\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n        [label]=\"btn.text\"\r\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n    >\r\n        @if (!btn.newIcon && !btn.isBuiltin) {\r\n        <img width=\"16\" [src]=\"btn.icon\" />\r\n        }\r\n    </button>\r\n    }\r\n    <ng-template #btnCommand>\r\n        <button\r\n            fd-toolbar-item\r\n            fd-button\r\n            (click)=\"onButtonClick(btn)\"\r\n            [attr.disabled]=\"btn.enable === false ? true : null\"\r\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n            [label]=\"btn.text\"\r\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >\r\n            @if (!btn.newIcon && !btn.isBuiltin) {\r\n            <img width=\"16\" [src]=\"btn.icon\" />\r\n            }\r\n        </button>\r\n    </ng-template>\r\n    }\r\n</fd-toolbar>\r\n", styles: [":host{display:block;width:100%;position:relative}:host ::ng-deep .fd-toolbar--solid{background-color:var(--sapBackgroundColor, #f7f7f7);border:none}\n"], dependencies: [{ kind: "component", type: i2.ButtonComponent, selector: "button[fd-button], a[fd-button], span[fd-button]", inputs: ["class"], exportAs: ["fd-button"] }, { kind: "component", type: i3.ToolbarComponent, selector: "fd-toolbar", inputs: ["titleId", "class", "shouldOverflow", "fdType", "title", "active", "clearBorder", "forceOverflow", "tabindex", "headingLevel", "ariaLabel", "ariaLabelledBy"] }, { kind: "directive", type: i3.ToolbarItemDirective, selector: "[fd-toolbar-item], [fdOverflowGroup], [fdOverflowPriority]", inputs: ["fdOverflowPriority", "fdOverflowGroup"] }, { kind: "component", type: i3.ToolbarSeparatorComponent, selector: "fd-toolbar-separator" }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: ResponsiveToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bsu-responsive-toolbar', changeDetection: ChangeDetectionStrategy.OnPush, standalone: false, template: "<!-- <div style=\"width: 100%; height: 0; visibility: hidden\" #containerRef>\r\n<ng-container\r\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\r\n></ng-container>\r\n</div>\r\n<bsu-responsive-toolbar-renderer\r\n  *ngIf=\"buttonsCalculated\"\r\n  [buttons]=\"buttonsCalculated\"\r\n  (btnClick)=\"onButtonClick($event)\"\r\n  [renderToolbar]=\"renderToolbar\"\r\n></bsu-responsive-toolbar-renderer>\r\n\r\n<ng-template #renderToolbar let-btnList>\r\n  <ng-container *ngFor=\"let btn of btnList\">\r\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\r\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\r\n    </ng-container>\r\n    <ng-template #btnCommand>\r\n      <ui5-button\r\n        #btnRef\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        class=\"toolbar-btn\"\r\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\r\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >{{ btn.text }}\r\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\r\n        /></ui5-button>\r\n      </ng-template>\r\n    </ng-container>\r\n  </ng-template> -->\r\n\r\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\r\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\r\n    <fd-toolbar-separator></fd-toolbar-separator>\r\n    } @else {\r\n    <button\r\n        fd-toolbar-item\r\n        fd-button\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n        [label]=\"btn.text\"\r\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n    >\r\n        @if (!btn.newIcon && !btn.isBuiltin) {\r\n        <img width=\"16\" [src]=\"btn.icon\" />\r\n        }\r\n    </button>\r\n    }\r\n    <ng-template #btnCommand>\r\n        <button\r\n            fd-toolbar-item\r\n            fd-button\r\n            (click)=\"onButtonClick(btn)\"\r\n            [attr.disabled]=\"btn.enable === false ? true : null\"\r\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n            [label]=\"btn.text\"\r\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >\r\n            @if (!btn.newIcon && !btn.isBuiltin) {\r\n            <img width=\"16\" [src]=\"btn.icon\" />\r\n            }\r\n        </button>\r\n    </ng-template>\r\n    }\r\n</fd-toolbar>\r\n", styles: [":host{display:block;width:100%;position:relative}:host ::ng-deep .fd-toolbar--solid{background-color:var(--sapBackgroundColor, #f7f7f7);border:none}\n"] }]
+        }], ctorParameters: () => [{ type: i1.PortalService }], propDecorators: { buttons: [{
+                type: Input
+            }], btnClick: [{
+                type: Output
+            }], btnListRef: [{
+                type: ViewChildren,
+                args: ['btnRef']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive-toolbar.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-sap-ui/src/lib/responsive-toolbar/responsive-toolbar.component.ts","../../../../../projects/barsa-sap-ui/src/lib/responsive-toolbar/responsive-toolbar.component.html"],"names":[],"mappings":"AAAA,OAAO,EACH,uBAAuB,EACvB,SAAS,EAET,YAAY,EACZ,KAAK,EAEL,MAAM,EAEN,YAAY,EACf,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,aAAa,EAAiB,MAAM,sBAAsB,CAAC;;;;;;AAUpE,MAAM,OAAO,0BAA2B,SAAQ,aAAa;IASzD,YAAoB,aAA4B;QAC5C,KAAK,EAAE,CAAC;QADQ,kBAAa,GAAb,aAAa,CAAe;QAPtC,aAAQ,GAAG,IAAI,YAAY,EAAO,CAAC;QASzC,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC;IAClD,CAAC;IACD,QAAQ;QACJ,KAAK,CAAC,QAAQ,EAAE,CAAC;QACjB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC;IAC7B,CAAC;IACD,uBAAuB;QACnB,MAAM,QAAQ,GAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;YAC5C,IAAI,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;YAC9B,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,CAAC;gBAC1B,OAAO,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;YACrE,CAAC;iBAAM,CAAC;gBACJ,OAAO,CAAC,KAAK,GAAG,MAAM,CAAC,aAAa,CAAC,WAAW,GAAG,EAAE,CAAC;YAC1D,CAAC;YACD,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,IAAI,CAAC,iBAAiB,GAAG,CAAC,GAAG,QAAQ,CAAC,CAAC;IAC3C,CAAC;IACD,aAAa,CAAC,MAAM;QAChB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAC/B,CAAC;+GAhCQ,0BAA0B;mGAA1B,0BAA0B,iPCrBvC,muFAsEA;;4FDjDa,0BAA0B;kBAPtC,SAAS;+BACI,wBAAwB,mBAGjB,uBAAuB,CAAC,MAAM,cACnC,KAAK;kFAGR,OAAO;sBAAf,KAAK;gBACI,QAAQ;sBAAjB,MAAM;gBACiB,UAAU;sBAAjC,YAAY;uBAAC,QAAQ","sourcesContent":["import {\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    ElementRef,\r\n    EventEmitter,\r\n    Input,\r\n    OnInit,\r\n    Output,\r\n    QueryList,\r\n    ViewChildren\r\n} from '@angular/core';\r\nimport { BaseComponent, PortalService } from 'barsa-novin-ray-core';\r\nimport { Observable } from 'rxjs';\r\n\r\n@Component({\r\n    selector: 'bsu-responsive-toolbar',\r\n    templateUrl: './responsive-toolbar.component.html',\r\n    styleUrls: ['./responsive-toolbar.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush,\r\n    standalone: false\r\n})\r\nexport class ResponsiveToolbarComponent extends BaseComponent implements OnInit {\r\n    @Input() buttons: any[];\r\n    @Output() btnClick = new EventEmitter<any>();\r\n    @ViewChildren('btnRef') btnListRef: QueryList<ElementRef>;\r\n\r\n    dirValue$: Observable<string>;\r\n    buttonsCalculated: any[];\r\n    btns: any[];\r\n\r\n    constructor(private portalService: PortalService) {\r\n        super();\r\n        this.dirValue$ = this.portalService.dirValue$;\r\n    }\r\n    ngOnInit(): void {\r\n        super.ngOnInit();\r\n        this.btns = this.buttons;\r\n    }\r\n    calculateWidthOfButtons(): void {\r\n        const tempList: any = [];\r\n        this.btnListRef.toArray().forEach((btnRef, i) => {\r\n            let btnTemp = this.buttons[i];\r\n            if (this.buttons[i] === '-') {\r\n                btnTemp = { text: '-', width: btnRef.nativeElement.offsetWidth };\r\n            } else {\r\n                btnTemp.width = btnRef.nativeElement.offsetWidth + 10;\r\n            }\r\n            tempList.push(btnTemp);\r\n        });\r\n        this.buttonsCalculated = [...tempList];\r\n    }\r\n    onButtonClick(button): void {\r\n        this.btnClick.emit(button);\r\n    }\r\n}\r\n","<!-- <div style=\"width: 100%; height: 0; visibility: hidden\" #containerRef>\r\n<ng-container\r\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\r\n></ng-container>\r\n</div>\r\n<bsu-responsive-toolbar-renderer\r\n  *ngIf=\"buttonsCalculated\"\r\n  [buttons]=\"buttonsCalculated\"\r\n  (btnClick)=\"onButtonClick($event)\"\r\n  [renderToolbar]=\"renderToolbar\"\r\n></bsu-responsive-toolbar-renderer>\r\n\r\n<ng-template #renderToolbar let-btnList>\r\n  <ng-container *ngFor=\"let btn of btnList\">\r\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\r\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\r\n    </ng-container>\r\n    <ng-template #btnCommand>\r\n      <ui5-button\r\n        #btnRef\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        class=\"toolbar-btn\"\r\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\r\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >{{ btn.text }}\r\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\r\n        /></ui5-button>\r\n      </ng-template>\r\n    </ng-container>\r\n  </ng-template> -->\r\n\r\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\r\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\r\n    <fd-toolbar-separator></fd-toolbar-separator>\r\n    } @else {\r\n    <button\r\n        fd-toolbar-item\r\n        fd-button\r\n        (click)=\"onButtonClick(btn)\"\r\n        [attr.disabled]=\"btn.enable === false ? true : null\"\r\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n        [label]=\"btn.text\"\r\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n    >\r\n        @if (!btn.newIcon && !btn.isBuiltin) {\r\n        <img width=\"16\" [src]=\"btn.icon\" />\r\n        }\r\n    </button>\r\n    }\r\n    <ng-template #btnCommand>\r\n        <button\r\n            fd-toolbar-item\r\n            fd-button\r\n            (click)=\"onButtonClick(btn)\"\r\n            [attr.disabled]=\"btn.enable === false ? true : null\"\r\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\r\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\r\n            [label]=\"btn.text\"\r\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\r\n        >\r\n            @if (!btn.newIcon && !btn.isBuiltin) {\r\n            <img width=\"16\" [src]=\"btn.icon\" />\r\n            }\r\n        </button>\r\n    </ng-template>\r\n    }\r\n</fd-toolbar>\r\n"]}