barsa-sap-ui 1.0.456 → 2.0.2

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

@@ -0,0 +1,366 @@
+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, _vcr, _injector, _el) {
+        super(_el);
+        this._portalService = _portalService;
+        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();
+    }
+    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._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.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.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) => {
+                this.editFormPanelValueChange.emit(mo);
+            });
+            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.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: "17.3.5", ngImport: i0, type: ReportViewRendererDirective, deps: [{ token: i1.PortalService }, { token: i0.ViewContainerRef }, { token: i0.Injector }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.5", 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", openOnClick: "openOnClick", inDialog: "inDialog", isMultiSelect: "isMultiSelect", rtl: "rtl", disableResponsive: "disableResponsive", 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" }, usesInheritance: true, usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: ReportViewRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[reportViewRenderer]'
+                }]
+        }], ctorParameters: () => [{ type: i1.PortalService }, { 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
+            }], openOnClick: [{
+                type: Input
+            }], inDialog: [{
+                type: Input
+            }], isMultiSelect: [{
+                type: Input
+            }], rtl: [{
+                type: Input
+            }], disableResponsive: [{
+                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
+            }] } });
+//# 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 {\n    ComponentRef,\n    Directive,\n    ElementRef,\n    EventEmitter,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    SimpleChanges,\n    ViewContainerRef\n} from '@angular/core';\nimport { ContentDensity } from '@fundamental-ngx/core';\nimport { takeUntil } from 'rxjs/operators';\nimport {\n    AbbrevationDeviceSize,\n    BaseDirective,\n    columnsResizedEventArgs,\n    DefaultCommandsAccess,\n    DeviceSize,\n    FormSetting,\n    MenuItem,\n    MetaobjectDataModel,\n    PortalService,\n    RelationItemType,\n    ReportViewBaseComponent,\n    ReportViewColumn,\n    SortSetting,\n    UiReportViewBase,\n    UiReportViewBaseSetting,\n    ShareButtonsChoiceDef,\n    TypeUlvMainCtrlr,\n    PagingSetting\n} from 'barsa-novin-ray-core';\n\n@Directive({\n    selector: '[reportViewRenderer]'\n})\nexport class ReportViewRendererDirective extends BaseDirective implements OnChanges, OnInit, OnDestroy {\n    @Input() view: UiReportViewBase;\n    @Input() moDataList: MetaobjectDataModel[];\n    @Input() allChecked: boolean;\n    @Input() contextSetting: any;\n    @Input() groupby: SortSetting[];\n    @Input() isCheckList: boolean;\n    @Input() hasInlineDeleteButton: boolean;\n    @Input() hasInlineEditButton: boolean;\n    @Input() selectedCount: number;\n    @Input() hideToolbar: boolean;\n    @Input() toolbarButtons: MenuItem[];\n    @Input() pagingSetting: PagingSetting;\n    @Input() UlvMainCtrlr: TypeUlvMainCtrlr;\n    @Input() hasSummary: boolean;\n    @Input() relationList: Array<RelationItemType>;\n    @Input() columns: ReportViewColumn[];\n    @Input() columnsCount: number;\n    @Input() secondaryColumns: ReportViewColumn[];\n    @Input() contextMenuItems: MenuItem[];\n    @Input() conditionalFormats: any[];\n    @Input() deviceName: DeviceSize;\n    @Input() deviceSize: AbbrevationDeviceSize;\n    @Input() mobileOrTablet: boolean;\n    @Input() access: DefaultCommandsAccess;\n    @Input() title: string;\n    @Input() customFieldInfo: MetaobjectDataModel | any;\n    @Input() selectedMo: MetaobjectDataModel;\n    @Input() allColumns: ReportViewColumn[];\n    @Input() viewSetting: UiReportViewBaseSetting;\n    @Input() inlineEditMode: boolean;\n    @Input() onlyInlineEdit: boolean;\n    @Input() allowInlineEdit: boolean;\n    @Input() popin: boolean;\n    @Input() hasSelected: boolean;\n    @Input() formSetting: FormSetting;\n    @Input() disableOverflowContextMenu: boolean;\n    @Input() navigationArrow: string;\n    @Input() typeDefId: string;\n    @Input() reportId: string;\n    @Input() listEditViewId: string;\n    @Input() typeViewId: string;\n    @Input() containerWidth: number;\n    @Input() extraRelation: any;\n    @Input() contextView: any;\n    @Input() contentDensity: ContentDensity;\n    @Input() hideOpenIcon: boolean;\n    @Input() openOnClick: boolean;\n    @Input() inDialog: boolean;\n    @Input() isMultiSelect: boolean;\n    @Input() rtl: boolean;\n    @Input() disableResponsive: boolean;\n    @Input() hideSearchpanel: boolean;\n    @Input() gridFreeColumnSizing: boolean;\n    @Input() cartableTemplates: { [key: string]: FormSetting };\n    @Input() cartableChildsMo: { [key: string]: MetaobjectDataModel };\n\n    @Output() editFormPanelCancel = new EventEmitter<MetaobjectDataModel>();\n    @Output() editFormPanelValueChange = new EventEmitter<MetaobjectDataModel>();\n\n    @Output() resetWorkflowState = new EventEmitter<any>();\n    @Output() ulvCommandClick = new EventEmitter<any>();\n    @Output() sortAscending = new EventEmitter<any>();\n    @Output() sortDescending = new EventEmitter<any>();\n    @Output() filter = new EventEmitter<any>();\n    @Output() deselectAll = new EventEmitter<void>();\n    @Output() rowCheck = new EventEmitter<{ mo; index; cause? }>();\n    @Output() rowClick = new EventEmitter<{ mo; index }>();\n    @Output() executeToolbarButton = new EventEmitter<{ itemId: string; options?: any }>();\n    @Output() expandClick = new EventEmitter<MetaobjectDataModel>();\n    @Output() trackBySelectedFn = new EventEmitter<{ index; record }>();\n    @Output() cartableFormClosed = new EventEmitter<{ index; mo }>();\n    @Output() createNewMo = new EventEmitter<void>();\n    @Output() updateMo = new EventEmitter<MetaobjectDataModel>();\n    @Output() hasDetailsInRow = new EventEmitter<boolean>();\n    @Output() allCheckbox = new EventEmitter<boolean>();\n    @Output() mandatory = new EventEmitter<boolean>();\n    @Output() editFormPanelSave = new EventEmitter<MetaobjectDataModel>();\n    @Output() columnResized = new EventEmitter<columnsResizedEventArgs>();\n    @Output() selectNextInlineRecord = new EventEmitter<MetaobjectDataModel>();\n    @Output() workflowShareButtons = new EventEmitter<ShareButtonsChoiceDef>();\n    @Output() escapeKey = new EventEmitter<MetaobjectDataModel>();\n\n    _reportViewRef: ComponentRef<ReportViewBaseComponent<UiReportViewBaseSetting>>;\n    constructor(\n        private _portalService: PortalService,\n        private _vcr: ViewContainerRef,\n        private _injector: Injector,\n        protected _el: ElementRef\n    ) {\n        super(_el);\n    }\n    ngOnChanges(changes: SimpleChanges): void {\n        const { view } = changes;\n\n        if (view && !view.firstChange) {\n            this._reportViewRef.destroy();\n            this._vcr.clear();\n            this._insertView(view.currentValue);\n        } else {\n            if (this._reportViewRef) {\n                this._reportViewRef.instance.ngOnChanges(changes);\n            }\n        }\n    }\n    ngOnInit(): void {\n        super.ngOnInit();\n        this._insertView(this.view);\n    }\n    ngOnDestroy(): void {\n        super.ngOnDestroy();\n        this._reportViewRef?.destroy();\n    }\n    private _insertView(view): void {\n        if (!view) {\n            return;\n        }\n        const { Module, ModuleFileName, Name, Selector } = view.UiComponent;\n        this._portalService\n            .getComponent(Module, ModuleFileName, Name, Selector, this._injector)\n            .pipe(takeUntil(this._onDestroy$))\n            .subscribe((componentRef: ComponentRef<ReportViewBaseComponent<UiReportViewBaseSetting>>) => {\n                const instance = componentRef.instance;\n                instance.cartableTemplates = this.cartableTemplates;\n                instance.cartableChildsMo = this.cartableChildsMo;\n                instance.moDataList = this.moDataList;\n                instance.contextSetting = this.contextSetting;\n                instance.groupby = this.groupby;\n                instance.UlvMainCtrlr = this.UlvMainCtrlr;\n                instance.pagingSetting = this.pagingSetting;\n                instance.hideSearchpanel = this.hideSearchpanel;\n                instance.customFieldInfo = this.customFieldInfo;\n                instance.disableResponsive = this.disableResponsive;\n                instance.toolbarButtons = this.toolbarButtons;\n                instance.popin = this.popin;\n                instance.contextView = this.contextView;\n                instance.isCheckList = this.isCheckList;\n                instance.toolbarButtons = this.toolbarButtons;\n                instance.columns = this.columns;\n                instance.listEditViewId = this.listEditViewId;\n                instance.typeViewId = this.typeViewId;\n                instance.gridFreeColumnSizing = this.gridFreeColumnSizing;\n                instance.inDialog = this.inDialog;\n                instance.hasInlineDeleteButton = this.hasInlineDeleteButton;\n                instance.hasInlineEditButton = this.hasInlineEditButton;\n                instance.isMultiSelect = this.isMultiSelect;\n                instance.columnsCount = this.columnsCount;\n                instance.hideToolbar = this.hideToolbar;\n                instance.extraRelation = this.extraRelation;\n                instance.secondaryColumns = this.secondaryColumns;\n                instance.contextMenuItems = this.contextMenuItems;\n                instance.conditionalFormats = this.conditionalFormats;\n                instance.disableOverflowContextMenu = this.disableOverflowContextMenu;\n                instance.typeDefId = this.typeDefId;\n                instance.reportId = this.reportId;\n                instance.deviceName = this.deviceName;\n                instance.deviceSize = this.deviceSize;\n                instance.mobileOrTablet = this.mobileOrTablet;\n                instance.containerWidth = this.containerWidth;\n                instance.columnsCount = this.columnsCount;\n                instance.selectedCount = this.selectedCount;\n                instance.hideOpenIcon = this.hideOpenIcon;\n                instance.openOnClick = this.openOnClick;\n                instance.access = this.access;\n                instance.title = this.title;\n                instance.hasSummary = this.hasSummary;\n                instance.contentDensity = this.contentDensity;\n                instance.relationList = this.relationList;\n                instance.allColumns = this.allColumns ?? this.columns;\n                instance.viewSetting = view.UiComponent.Settings;\n                instance.inlineEditMode = this.inlineEditMode;\n                instance.onlyInlineEdit = this.onlyInlineEdit;\n                instance.allowInlineEdit = this.allowInlineEdit;\n                instance.formSetting = this.formSetting;\n                instance.navigationArrow = this.navigationArrow;\n                instance.selectedMo = this.selectedMo;\n                instance.hasSelected = this.hasSelected;\n                instance.rtl = this.rtl;\n                instance.escapeKey?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.escapeKey.emit(mo);\n                });\n                instance.resetWorkflowState?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.resetWorkflowState.emit(mo);\n                });\n                instance.editFormPanelValueChange?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.editFormPanelValueChange.emit(mo);\n                });\n                instance.selectNextInlineRecord?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.selectNextInlineRecord.emit(mo);\n                });\n                instance.editFormPanelCancel?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.editFormPanelCancel.emit(mo);\n                });\n                instance.ulvCommandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.ulvCommandClick.emit(e);\n                });\n                instance.sortAscending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.sortAscending.emit(e);\n                });\n                instance.sortDescending?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.sortDescending.emit(e);\n                });\n                instance.filter?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.filter.emit(e);\n                });\n\n                instance.columnResized?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.columnResized.emit(e);\n                });\n\n                instance.rowCheck?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index; cause? }) => {\n                    this.rowCheck.emit(e);\n                });\n                instance.deselectAll?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {\n                    this.deselectAll.emit();\n                });\n                instance.rowClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index }) => {\n                    this.rowClick.emit(e);\n                });\n                instance.expandClick?.pipe(takeUntil(this._onDestroy$)).subscribe((e: MetaobjectDataModel) => {\n                    this.expandClick.emit(e);\n                });\n                instance.allCheckbox?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.allCheckbox.emit(e);\n                });\n                instance.editFormPanelSave?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.editFormPanelSave.emit(mo);\n                });\n                instance.cartableFormClosed?.pipe(takeUntil(this._onDestroy$)).subscribe((e: { mo; index }) => {\n                    this.cartableFormClosed.emit(e);\n                });\n                instance.createNewMo?.pipe(takeUntil(this._onDestroy$)).subscribe(() => {\n                    this.createNewMo.emit();\n                });\n                instance.hasDetailsInRow?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.hasDetailsInRow.emit(mo);\n                });\n                instance.updateMo?.pipe(takeUntil(this._onDestroy$)).subscribe((mo) => {\n                    this.updateMo.emit(mo);\n                });\n                instance.mandatory?.pipe(takeUntil(this._onDestroy$)).subscribe((isValid) => {\n                    this.mandatory.emit(isValid);\n                });\n                instance.executeToolbarButton?.pipe(takeUntil(this._onDestroy$)).subscribe((e) => {\n                    this.executeToolbarButton.emit(e);\n                });\n                instance.workflowShareButtons\n                    ?.pipe(takeUntil(this._onDestroy$))\n                    .subscribe((e: ShareButtonsChoiceDef) => {\n                        this.workflowShareButtons.emit(e);\n                    });\n                this._vcr.insert(componentRef.hostView);\n                this._reportViewRef = componentRef;\n            });\n    }\n}\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: "17.3.5", ngImport: i0, type: ResponsiveToolbarComponent, deps: [{ token: i1.PortalService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.5", 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>\n<ng-container\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\n></ng-container>\n</div>\n<bsu-responsive-toolbar-renderer\n  *ngIf=\"buttonsCalculated\"\n  [buttons]=\"buttonsCalculated\"\n  (btnClick)=\"onButtonClick($event)\"\n  [renderToolbar]=\"renderToolbar\"\n></bsu-responsive-toolbar-renderer>\n\n<ng-template #renderToolbar let-btnList>\n  <ng-container *ngFor=\"let btn of btnList\">\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\n    </ng-container>\n    <ng-template #btnCommand>\n      <ui5-button\n        #btnRef\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        class=\"toolbar-btn\"\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\n        >{{ btn.text }}\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\n        /></ui5-button>\n      </ng-template>\n    </ng-container>\n  </ng-template> -->\n\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\n    <fd-toolbar-separator></fd-toolbar-separator>\n    } @else {\n    <button\n        fd-toolbar-item\n        fd-button\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n        [label]=\"btn.text\"\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n    >\n        @if (!btn.newIcon && !btn.isBuiltin) {\n        <img width=\"16\" [src]=\"btn.icon\" />\n        }\n    </button>\n    }\n    <ng-template #btnCommand>\n        <button\n            fd-toolbar-item\n            fd-button\n            (click)=\"onButtonClick(btn)\"\n            [attr.disabled]=\"btn.enable === false ? true : null\"\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n            [label]=\"btn.text\"\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n        >\n            @if (!btn.newIcon && !btn.isBuiltin) {\n            <img width=\"16\" [src]=\"btn.icon\" />\n            }\n        </button>\n    </ng-template>\n    }\n</fd-toolbar>\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]", inputs: ["class"], exportAs: ["fd-button"] }, { kind: "component", type: i3.ToolbarComponent, selector: "fd-toolbar", inputs: ["titleId", "class", "shouldOverflow", "fdType", "title", "active", "clearBorder", "forceOverflow", "tabindex", "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: "17.3.5", ngImport: i0, type: ResponsiveToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bsu-responsive-toolbar', changeDetection: ChangeDetectionStrategy.OnPush, template: "<!-- <div style=\"width: 100%; height: 0; visibility: hidden\" #containerRef>\n<ng-container\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\n></ng-container>\n</div>\n<bsu-responsive-toolbar-renderer\n  *ngIf=\"buttonsCalculated\"\n  [buttons]=\"buttonsCalculated\"\n  (btnClick)=\"onButtonClick($event)\"\n  [renderToolbar]=\"renderToolbar\"\n></bsu-responsive-toolbar-renderer>\n\n<ng-template #renderToolbar let-btnList>\n  <ng-container *ngFor=\"let btn of btnList\">\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\n    </ng-container>\n    <ng-template #btnCommand>\n      <ui5-button\n        #btnRef\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        class=\"toolbar-btn\"\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\n        >{{ btn.text }}\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\n        /></ui5-button>\n      </ng-template>\n    </ng-container>\n  </ng-template> -->\n\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\n    <fd-toolbar-separator></fd-toolbar-separator>\n    } @else {\n    <button\n        fd-toolbar-item\n        fd-button\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n        [label]=\"btn.text\"\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n    >\n        @if (!btn.newIcon && !btn.isBuiltin) {\n        <img width=\"16\" [src]=\"btn.icon\" />\n        }\n    </button>\n    }\n    <ng-template #btnCommand>\n        <button\n            fd-toolbar-item\n            fd-button\n            (click)=\"onButtonClick(btn)\"\n            [attr.disabled]=\"btn.enable === false ? true : null\"\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n            [label]=\"btn.text\"\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n        >\n            @if (!btn.newIcon && !btn.isBuiltin) {\n            <img width=\"16\" [src]=\"btn.icon\" />\n            }\n        </button>\n    </ng-template>\n    }\n</fd-toolbar>\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;;;;;;AASpE,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;8GAhCQ,0BAA0B;kGAA1B,0BAA0B,iPCpBvC,ulFAsEA;;2FDlDa,0BAA0B;kBANtC,SAAS;+BACI,wBAAwB,mBAGjB,uBAAuB,CAAC,MAAM;kFAGtC,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})\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>\n<ng-container\n  *ngTemplateOutlet=\"renderToolbar; context: { $implicit: buttons }\"\n></ng-container>\n</div>\n<bsu-responsive-toolbar-renderer\n  *ngIf=\"buttonsCalculated\"\n  [buttons]=\"buttonsCalculated\"\n  (btnClick)=\"onButtonClick($event)\"\n  [renderToolbar]=\"renderToolbar\"\n></bsu-responsive-toolbar-renderer>\n\n<ng-template #renderToolbar let-btnList>\n  <ng-container *ngFor=\"let btn of btnList\">\n    <ng-container *ngIf=\"btn === '-' || btn.text === '-'; else btnCommand\">\n      <span #btnRef class=\"toolbar-btn toolbar-vseperator\"></span>\n    </ng-container>\n    <ng-template #btnCommand>\n      <ui5-button\n        #btnRef\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        class=\"toolbar-btn\"\n        [attr.design]=\"btn.emphasized ? 'Emphasized' : 'Transparent'\"\n        [attr.icon]=\"btn.newIcon ? btn.newIcon : null\"\n        >{{ btn.text }}\n        <img *ngIf=\"!btn.newIcon && !btn.isBuiltin\" width=\"16\" [src]=\"btn.icon\"\n        /></ui5-button>\n      </ng-template>\n    </ng-container>\n  </ng-template> -->\n\n<fd-toolbar [shouldOverflow]=\"true\" [style.direction]=\"dirValue$ | async\">\n    @for (btn of btns; track btn) { @if (btn === '-' || btn.text === '-') {\n    <fd-toolbar-separator></fd-toolbar-separator>\n    } @else {\n    <button\n        fd-toolbar-item\n        fd-button\n        (click)=\"onButtonClick(btn)\"\n        [attr.disabled]=\"btn.enable === false ? true : null\"\n        [attr.disabled]=\"btn.readonly === true ? true : null\"\n        [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n        [label]=\"btn.text\"\n        [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n    >\n        @if (!btn.newIcon && !btn.isBuiltin) {\n        <img width=\"16\" [src]=\"btn.icon\" />\n        }\n    </button>\n    }\n    <ng-template #btnCommand>\n        <button\n            fd-toolbar-item\n            fd-button\n            (click)=\"onButtonClick(btn)\"\n            [attr.disabled]=\"btn.enable === false ? true : null\"\n            [attr.disabled]=\"btn.readonly === true ? true : null\"\n            [fdType]=\"btn.emphasized ? 'emphasized' : 'transparent'\"\n            [label]=\"btn.text\"\n            [glyph]=\"btn.newIcon ? btn.newIcon : null\"\n        >\n            @if (!btn.newIcon && !btn.isBuiltin) {\n            <img width=\"16\" [src]=\"btn.icon\" />\n            }\n        </button>\n    </ng-template>\n    }\n</fd-toolbar>\n"]}

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

@@ -0,0 +1,84 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { debounceTime, tap } from 'rxjs/operators';
+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 "@angular/common";
+export class ResponsiveToolbarRendererComponent extends BaseComponent {
+    constructor(uiService, el) {
+        super();
+        this.uiService = uiService;
+        this.el = el;
+        this.btnClick = new EventEmitter();
+    }
+    get inToolbarBtn() {
+        return this.buttons.filter((c) => !c.inPopup);
+    }
+    get inPopoverBtn() {
+        return this.buttons.filter((c) => c.inPopup);
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this.resizeToolbar();
+        this.resizeSubscription$ = fromEvent(window, 'resize')
+            .pipe(debounceTime(100), tap(() => this.resizeToolbar()))
+            .subscribe();
+        this.uiService.tabSelected$.subscribe((tab) => {
+            const el = this.el.nativeElement;
+            if (tab.contains(el)) {
+                this.resizeToolbar();
+            }
+            else {
+            }
+        });
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.resizeSubscription$) {
+            this.resizeSubscription$.unsubscribe();
+        }
+    }
+    resizeToolbar() {
+        const width = this.el.nativeElement.offsetWidth;
+        let btnListWidth = 0;
+        this.showPopupButton = false;
+        this.buttons.forEach((btn) => {
+            if (typeof btn !== 'string') {
+                btn.inPopup = false;
+            }
+        });
+        const containerWidth = width - 42;
+        this.buttons.forEach((btn, i) => {
+            btnListWidth += btn.width;
+            if (btnListWidth > containerWidth) {
+                this.showPopupButton = true;
+            }
+            if (this.showPopupButton && typeof this.buttons[i] !== 'string') {
+                this.buttons[i].inPopup = true;
+            }
+        });
+    }
+    onShowPopover(el) {
+        this.dialogRef.nativeElement.openBy(el);
+    }
+    onButtonClick(btn) {
+        this.btnClick.emit(btn);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: ResponsiveToolbarRendererComponent, deps: [{ token: i1.UiService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "17.3.5", type: ResponsiveToolbarRendererComponent, selector: "bsu-responsive-toolbar-renderer", inputs: { buttons: "buttons", renderToolbar: "renderToolbar" }, outputs: { btnClick: "btnClick" }, viewQueries: [{ propertyName: "dialogRef", first: true, predicate: ["dialogRef"], descendants: true }], usesInheritance: true, ngImport: i0, template: "<div class=\"toolbar-container\">\n    <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inToolbarBtn }\"></ng-container>\n    @if (showPopupButton) {\n    <ui5-button\n        #showPopoverRef\n        class=\"toolbar-btn overflow-btn\"\n        icon=\"overflow\"\n        (click)=\"onShowPopover(showPopoverRef)\"\n    ></ui5-button>\n    }\n</div>\n<ui5-popover #dialogRef horizontal-align=\"Center\" placement-type=\"Bottom\" vertical-align=\"Center\">\n    <div class=\"toolbar-container modal-toolbar\">\n        <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inPopoverBtn }\"></ng-container>\n    </div>\n</ui5-popover>\n", styles: [":host{position:absolute;width:100%;display:block}\n"], dependencies: [{ kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.5", ngImport: i0, type: ResponsiveToolbarRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'bsu-responsive-toolbar-renderer', changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"toolbar-container\">\n    <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inToolbarBtn }\"></ng-container>\n    @if (showPopupButton) {\n    <ui5-button\n        #showPopoverRef\n        class=\"toolbar-btn overflow-btn\"\n        icon=\"overflow\"\n        (click)=\"onShowPopover(showPopoverRef)\"\n    ></ui5-button>\n    }\n</div>\n<ui5-popover #dialogRef horizontal-align=\"Center\" placement-type=\"Bottom\" vertical-align=\"Center\">\n    <div class=\"toolbar-container modal-toolbar\">\n        <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inPopoverBtn }\"></ng-container>\n    </div>\n</ui5-popover>\n", styles: [":host{position:absolute;width:100%;display:block}\n"] }]
+        }], ctorParameters: () => [{ type: i1.UiService }, { type: i0.ElementRef }], propDecorators: { buttons: [{
+                type: Input
+            }], renderToolbar: [{
+                type: Input
+            }], btnClick: [{
+                type: Output
+            }], dialogRef: [{
+                type: ViewChild,
+                args: ['dialogRef']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"responsive-toolbar-renderer.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-sap-ui/src/lib/responsive-toolbar-renderer/responsive-toolbar-renderer.component.ts","../../../../../projects/barsa-sap-ui/src/lib/responsive-toolbar-renderer/responsive-toolbar-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    AfterViewInit,\r\n    ChangeDetectionStrategy,\r\n    Component,\r\n    ElementRef,\r\n    EventEmitter,\r\n    Input,\r\n    OnDestroy,\r\n    Output,\r\n    TemplateRef,\r\n    ViewChild\r\n} from '@angular/core';\r\nimport { fromEvent, Subscription } from 'rxjs';\r\nimport { debounceTime, tap } from 'rxjs/operators';\r\n\r\nimport { BaseComponent, UiService } from 'barsa-novin-ray-core';\r\n\r\n@Component({\r\n    selector: 'bsu-responsive-toolbar-renderer',\r\n    templateUrl: './responsive-toolbar-renderer.component.html',\r\n    styleUrls: ['./responsive-toolbar-renderer.component.scss'],\r\n    changeDetection: ChangeDetectionStrategy.OnPush\r\n})\r\nexport class ResponsiveToolbarRendererComponent extends BaseComponent implements AfterViewInit, OnDestroy {\r\n    @Input() buttons: any[];\r\n    @Input() renderToolbar: TemplateRef<any>;\r\n    @Output() btnClick = new EventEmitter<any>();\r\n    @ViewChild('dialogRef') dialogRef: ElementRef;\r\n\r\n    showPopupButton: boolean;\r\n    resizeSubscription$: Subscription;\r\n\r\n    constructor(private uiService: UiService, private el: ElementRef) {\r\n        super();\r\n    }\r\n    get inToolbarBtn(): any {\r\n        return this.buttons.filter((c) => !c.inPopup);\r\n    }\r\n    get inPopoverBtn(): any {\r\n        return this.buttons.filter((c) => c.inPopup);\r\n    }\r\n    ngAfterViewInit(): void {\r\n        super.ngAfterViewInit();\r\n\r\n        this.resizeToolbar();\r\n        this.resizeSubscription$ = fromEvent(window, 'resize')\r\n            .pipe(\r\n                debounceTime(100),\r\n                tap(() => this.resizeToolbar())\r\n            )\r\n            .subscribe();\r\n        this.uiService.tabSelected$.subscribe((tab: HTMLElement) => {\r\n            const el = this.el.nativeElement as HTMLElement;\r\n            if (tab.contains(el)) {\r\n                this.resizeToolbar();\r\n            } else {\r\n            }\r\n        });\r\n    }\r\n    ngOnDestroy(): void {\r\n        super.ngOnDestroy();\r\n        if (this.resizeSubscription$) {\r\n            this.resizeSubscription$.unsubscribe();\r\n        }\r\n    }\r\n    resizeToolbar(): void {\r\n        const width = this.el.nativeElement.offsetWidth;\r\n        let btnListWidth = 0;\r\n        this.showPopupButton = false;\r\n        this.buttons.forEach((btn) => {\r\n            if (typeof btn !== 'string') {\r\n                btn.inPopup = false;\r\n            }\r\n        });\r\n        const containerWidth = width - 42;\r\n        this.buttons.forEach((btn, i) => {\r\n            btnListWidth += btn.width;\r\n            if (btnListWidth > containerWidth) {\r\n                this.showPopupButton = true;\r\n            }\r\n            if (this.showPopupButton && typeof this.buttons[i] !== 'string') {\r\n                this.buttons[i].inPopup = true;\r\n            }\r\n        });\r\n    }\r\n\r\n    onShowPopover(el): void {\r\n        this.dialogRef.nativeElement.openBy(el);\r\n    }\r\n    onButtonClick(btn): void {\r\n        this.btnClick.emit(btn);\r\n    }\r\n}\r\n","<div class=\"toolbar-container\">\n    <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inToolbarBtn }\"></ng-container>\n    @if (showPopupButton) {\n    <ui5-button\n        #showPopoverRef\n        class=\"toolbar-btn overflow-btn\"\n        icon=\"overflow\"\n        (click)=\"onShowPopover(showPopoverRef)\"\n    ></ui5-button>\n    }\n</div>\n<ui5-popover #dialogRef horizontal-align=\"Center\" placement-type=\"Bottom\" vertical-align=\"Center\">\n    <div class=\"toolbar-container modal-toolbar\">\n        <ng-container *ngTemplateOutlet=\"renderToolbar; context: { $implicit: inPopoverBtn }\"></ng-container>\n    </div>\n</ui5-popover>\n"]}