barsa-novin-ray-core 0.0.2

package/esm2020/lib/directives/render-ulv-paging.directive.mjs

@@ -0,0 +1,58 @@
+import { Directive, Input } from '@angular/core';
+import { delay, takeUntil, tap } from 'rxjs/operators';
+import { BaseDirective } from './base.directive';
+import { getComponentDefined, getUniqueId } from '../constants';
+import { BarsaApi } from '../abstract-classes';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/portal.service";
+export class RenderUlvPaginDirective extends BaseDirective {
+    constructor(_injector, _portalService, _vcr, _cdr) {
+        super();
+        this._injector = _injector;
+        this._portalService = _portalService;
+        this._vcr = _vcr;
+        this._cdr = _cdr;
+    }
+    async ngOnInit() {
+        super.ngOnInit();
+        this._render();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        this.component.destroy();
+    }
+    async _render() {
+        const context = this.context;
+        if (context) {
+            const customUiSetting = BarsaApi.Common.Util.TryGetValue(context.Setting, 'ClassNames.CustomUi', null);
+            const { moduleName, modulePath
+            // componentName,
+            // selector
+             } = getComponentDefined(context, customUiSetting);
+            this._portalService
+                .getComponent(moduleName, modulePath, 'UlvPaging', 'bsu-ulv-paging', this._injector)
+                .pipe(takeUntil(this._onDestroy$), delay(0), tap((component) => {
+                component.instance.id = getUniqueId(4);
+                component.instance.context = context;
+                this.component = component;
+                this._vcr.insert(component.hostView);
+                this._cdr.detectChanges();
+            }))
+                .subscribe();
+        }
+    }
+}
+RenderUlvPaginDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RenderUlvPaginDirective, deps: [{ token: i0.Injector }, { token: i1.PortalService }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+RenderUlvPaginDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: RenderUlvPaginDirective, selector: "[renderUlvPaging]", inputs: { mask: "mask", context: ["renderUlvPaging", "context"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RenderUlvPaginDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[renderUlvPaging]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.PortalService }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { mask: [{
+                type: Input
+            }], context: [{
+                type: Input,
+                args: ['renderUlvPaging']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/render-ulv-viewer.directive.mjs

@@ -0,0 +1,60 @@
+import { Directive, Input } from '@angular/core';
+import { delay, takeUntil, tap } from 'rxjs/operators';
+import { BarsaApi } from '../abstract-classes';
+import { BaseDirective } from './base.directive';
+import { getComponentDefined, getUniqueId } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/portal.service";
+export class RenderUlvViewerDirective extends BaseDirective {
+    constructor(_injector, _portalService, _vcr, _cdr) {
+        super();
+        this._injector = _injector;
+        this._portalService = _portalService;
+        this._vcr = _vcr;
+        this._cdr = _cdr;
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        this._render();
+    }
+    ngOnDestroy() {
+        super.ngOnDestroy();
+        if (this.component) {
+            this.component.destroy();
+        }
+    }
+    _render() {
+        const context = this.viewer;
+        if (context) {
+            const customUiSetting = BarsaApi.Common.Util.TryGetValue(context.Setting, 'ClassNames.CustomUi', null);
+            const { moduleName, modulePath, componentName, selector } = getComponentDefined(context, customUiSetting);
+            this._portalService
+                .getComponent(moduleName, modulePath, componentName, selector, this._injector)
+                .pipe(takeUntil(this._onDestroy$), delay(0), tap((component) => {
+                component.instance.id = getUniqueId(4);
+                component.instance.context = context;
+                // component.instance.moDataList=BarsaApi.Common.Util.TryGetValue(context,'moDataList',[]);
+                context.controlUi = component.instance;
+                // context.viewer = component.instance;
+                this.component = component;
+                this._vcr.insert(component.hostView);
+                this._cdr.detectChanges();
+            }))
+                .subscribe();
+        }
+    }
+}
+RenderUlvViewerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RenderUlvViewerDirective, deps: [{ token: i0.Injector }, { token: i1.PortalService }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+RenderUlvViewerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: RenderUlvViewerDirective, selector: "[renderUlvViewer]", inputs: { mask: "mask", viewer: ["renderUlvViewer", "viewer"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: RenderUlvViewerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[renderUlvViewer]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.PortalService }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { mask: [{
+                type: Input
+            }], viewer: [{
+                type: Input,
+                args: ['renderUlvViewer']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/table-resizer.directive.mjs

@@ -0,0 +1,235 @@
+import { Directive, Input, HostListener, EventEmitter, Output } from '@angular/core';
+import { fromEvent } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+export class TableResizerDirective extends BaseDirective {
+    constructor(el, renderer) {
+        super();
+        this.el = el;
+        this.renderer = renderer;
+        this.columnResized = new EventEmitter();
+        fromEvent(document, 'mouseup')
+            .pipe(takeUntil(this._onDestroy$))
+            .subscribe(() => {
+            this._mouseUp();
+        });
+        fromEvent(document, 'mousemove')
+            .pipe(takeUntil(this._onDestroy$))
+            .subscribe((e) => {
+            this._mouseMove(e);
+        });
+    }
+    get _table() {
+        return this.el.nativeElement;
+    }
+    moseDown(e) {
+        this._mouseDown(e);
+    }
+    moseMove(e) {
+        this._mouseMove(e);
+    }
+    ngAfterViewInit() {
+        if (this.rowResizer) {
+            this._putBodyCellsContentIntoDiv();
+        }
+        if (this.rowResizer) {
+            this._addRowsResizer();
+        }
+        this._setTableMode(this.fitWidth);
+    }
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        const { fitWidth } = changes;
+        if (this.enableResizing && fitWidth && !fitWidth.firstChange) {
+            const newFitWidth = fitWidth.currentValue;
+            this._setTableMode(newFitWidth);
+        }
+    }
+    _initializeTable() {
+        this._initTable();
+        this._setTableMode(this.fitWidth);
+    }
+    _resizeRow(event) {
+        this._currentResizer = "Row" /* Resizer.Row */;
+        const elementFromPoint = document.elementFromPoint(event.pageX, event.pageY);
+        this._currentCell = elementFromPoint?.closest('td');
+        this._startY = event.pageY;
+        this._currentRowHeight = this._currentCell?.clientHeight || 0;
+    }
+    _resizeColumn(event) {
+        if (!this.fitWidth) {
+            this._setTableFreeSize();
+        }
+        this._currentResizer = "Column" /* Resizer.Column */;
+        const elementFromPoint = document.elementFromPoint(event.pageX, event.pageY);
+        this._currentCell = elementFromPoint?.closest('th');
+        this._startX = event.pageX;
+        this._currentColumnWidth = this._currentCell?.clientWidth || 0;
+        this._sideCell = this._getSideCell(this._currentCell);
+        this._sideColumnWidth = this._sideCell?.clientWidth;
+    }
+    _addRowsResizer() {
+        const table = this._table;
+        const rowsLabel = table.querySelectorAll('.vertical-label');
+        rowsLabel.forEach((cell) => {
+            const rowResizer = this.renderer.createElement('div');
+            this.renderer.appendChild(cell, rowResizer);
+            rowResizer.setAttribute('class', 'row-resizer');
+            this.renderer.setStyle(cell, 'height', 'inherit');
+            this.renderer.setStyle(cell, 'position', 'relative');
+            this.renderer.setAttribute(rowResizer, 'style', 'cursor: row-resize; height:8px; position:absolute;bottom:0;left:0;right:0');
+        });
+    }
+    _putBodyCellsContentIntoDiv() {
+        const table = this._table;
+        const bodyCells = table.querySelectorAll('body td:not(.vertical-label)');
+        bodyCells.forEach((cell) => {
+            const contentContainer = this.renderer.createElement('div');
+            cell.children.forEach((child) => {
+                contentContainer.appendChild(child);
+            });
+            this.renderer.setStyle(cell, 'overflow', 'hidden');
+            this.renderer.setStyle(cell, 'height', 'inherit');
+            this.renderer.setStyle(contentContainer, 'height', 'inherit');
+            this.renderer.setStyle(contentContainer, 'display', 'block');
+            cell.appendChild(contentContainer);
+        });
+    }
+    _getSideCell(currentCell) {
+        const currentRow = this._currentCell.parentNode?.children;
+        if (currentRow) {
+            const cellIndexInRow = Array.from(currentRow).indexOf(currentCell);
+            return Array.from(currentRow)[cellIndexInRow + 1];
+        }
+        return null;
+    }
+    _changeWidth(fitWidth, sideCell, currentCell, changedCurrentCellWidth, changedSideCellWidth) {
+        if (fitWidth) {
+            if (sideCell && changedCurrentCellWidth >= this.minWidth && changedSideCellWidth >= this.minWidth) {
+                this.renderer.setStyle(sideCell, 'width', changedSideCellWidth + 'px');
+                this.renderer.setStyle(sideCell, 'min-width', changedSideCellWidth + 'px');
+                this.renderer.setStyle(currentCell, 'width', changedCurrentCellWidth + 'px');
+                this.renderer.setStyle(currentCell, 'min-width', changedCurrentCellWidth + 'px');
+            }
+        }
+        else if (changedCurrentCellWidth >= this.minWidth) {
+            this.renderer.setStyle(currentCell, 'width', changedCurrentCellWidth + 'px');
+            this.renderer.setStyle(currentCell, 'min-width', changedCurrentCellWidth + 'px');
+        }
+    }
+    _changeHeight(currentCell, changedHeight, minHeight) {
+        if (changedHeight > minHeight) {
+            this.renderer.setStyle(currentCell.closest('tr'), 'height', changedHeight + 'px');
+        }
+    }
+    _initTable() {
+        if (this._isInitTable) {
+            return;
+        }
+        this._isInitTable = true;
+        const table = this._table;
+        const parent = table.parentElement;
+        this.renderer.setStyle(parent, 'overflow-x', this.fitWidth ? 'hidden' : 'auto');
+        // this.renderer.setStyle(parent, 'overflow-y', 'auto');
+        this.renderer.setStyle(parent, 'width', '100%');
+    }
+    _setTableMode(isFitWidth) {
+        if (isFitWidth) {
+            this._setTableFitSize();
+        }
+    }
+    _setTableFreeSize() {
+        const table = this._table;
+        this.renderer.setStyle(table, 'width', this.containerWidth + 'px');
+        this.renderer.setStyle(table, 'max-width', 'unset');
+        this.renderer.setStyle(table, 'min-width', this.containerWidth + 'px');
+        const headCells = table.querySelectorAll('th');
+        headCells.forEach((cell) => {
+            const width = cell.offsetWidth;
+            this.renderer.setStyle(cell, 'width', width + 'px');
+            this.renderer.setStyle(cell, 'min-width', width + 'px');
+        });
+    }
+    _setTableFitSize() {
+        const table = this._table;
+        this.renderer.setStyle(table, 'width', '100%');
+        this.renderer.setStyle(table, 'max-width', '100%');
+    }
+    _mouseDown(e) {
+        if (e.srcElement.className === 'row-resizer') {
+            this._resizeRow(e);
+            this.renderer.setStyle(this.el.nativeElement, 'cursor', 'row-resize');
+        }
+        else if (e.srcElement.className === 'column-resizer') {
+            this._resizeColumn(e);
+            this.renderer.setStyle(this.el.nativeElement, 'cursor', 'col-resize');
+        }
+    }
+    _mouseMove(e) {
+        if (e.buttons !== 0) {
+            if (this._currentResizer === "Column" /* Resizer.Column */) {
+                if (!this._isInitTable) {
+                    this._initializeTable();
+                }
+                const endX = e.pageX;
+                const dx = endX - this._startX;
+                const changedCurrentCellWidth = this._currentColumnWidth - dx;
+                const changedSideCellWidth = this._sideColumnWidth + dx;
+                this._changeWidth(this.fitWidth, this._sideCell, this._currentCell, changedCurrentCellWidth, changedSideCellWidth);
+            }
+            else if (this._currentResizer === "Row" /* Resizer.Row */) {
+                const endY = e.pageY;
+                const dy = endY - this._startY;
+                const changedCurrentRowHeight = this._currentRowHeight + dy;
+                this._changeHeight(this._currentCell, changedCurrentRowHeight, this.minHeight);
+            }
+        }
+    }
+    _mouseUp() {
+        if (this._currentResizer) {
+            const table = this.el.nativeElement;
+            const headers = table.querySelectorAll('th');
+            const columnResized = [];
+            for (let i = 0; i < headers.length; i++) {
+                const header = headers[i];
+                const columnName = header.attributes['columnname']?.value;
+                if (typeof columnName !== 'undefined') {
+                    columnResized.push({ name: columnName, width: header.offsetWidth });
+                }
+            }
+            this.columnResized.emit(columnResized);
+        }
+        this._currentResizer = null;
+        this.renderer.setStyle(this.el.nativeElement, 'cursor', 'default');
+    }
+}
+TableResizerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: TableResizerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+TableResizerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: TableResizerDirective, selector: "[tableResizer]", inputs: { fitWidth: "fitWidth", minWidth: "minWidth", minHeight: "minHeight", containerWidth: "containerWidth", rowResizer: "rowResizer", enableResizing: "enableResizing" }, outputs: { columnResized: "columnResized" }, host: { listeners: { "mousedown": "moseDown($event)", "mousemove": "moseMove($event)" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: TableResizerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[tableResizer]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { fitWidth: [{
+                type: Input
+            }], minWidth: [{
+                type: Input
+            }], minHeight: [{
+                type: Input
+            }], containerWidth: [{
+                type: Input
+            }], rowResizer: [{
+                type: Input
+            }], enableResizing: [{
+                type: Input
+            }], columnResized: [{
+                type: Output
+            }], moseDown: [{
+                type: HostListener,
+                args: ['mousedown', ['$event']]
+            }], moseMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"table-resizer.directive.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/directives/table-resizer.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    Directive,\n    ElementRef,\n    Input,\n    Renderer2,\n    HostListener,\n    SimpleChanges,\n    OnInit,\n    OnDestroy,\n    AfterViewInit,\n    OnChanges,\n    EventEmitter,\n    Output\n} from '@angular/core';\nimport { fromEvent } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\nimport { ColumnResizedArgs } from '../abstract-classes';\nimport { BaseDirective } from './base.directive';\nconst enum Resizer {\n    Row = 'Row',\n    Column = 'Column'\n}\n\n@Directive({\n    selector: '[tableResizer]'\n})\nexport class TableResizerDirective extends BaseDirective implements OnInit, OnDestroy, AfterViewInit, OnChanges {\n    @Input() fitWidth: boolean;\n    @Input() minWidth;\n    @Input() minHeight;\n    @Input() containerWidth: number;\n    @Input() rowResizer: boolean;\n    @Input() enableResizing: boolean;\n    @Output() columnResized = new EventEmitter<Array<ColumnResizedArgs>>();\n    private _currentCell: HTMLTableCellElement;\n    private _sideCell;\n    private _startX;\n    private _startY;\n    private _currentColumnWidth;\n    private _sideColumnWidth;\n    private _currentRowHeight;\n    private _currentResizer: Resizer | null;\n    private _isInitTable: boolean;\n    constructor(private el: ElementRef, private renderer: Renderer2) {\n        super();\n        fromEvent(document, 'mouseup')\n            .pipe(takeUntil(this._onDestroy$))\n            .subscribe(() => {\n                this._mouseUp();\n            });\n        fromEvent(document, 'mousemove')\n            .pipe(takeUntil(this._onDestroy$))\n            .subscribe((e) => {\n                this._mouseMove(e);\n            });\n    }\n    private get _table(): HTMLTableElement {\n        return this.el.nativeElement as HTMLTableElement;\n    }\n\n    @HostListener('mousedown', ['$event'])\n    moseDown(e): void {\n        this._mouseDown(e);\n    }\n\n    @HostListener('mousemove', ['$event'])\n    moseMove(e): void {\n        this._mouseMove(e);\n    }\n\n    ngAfterViewInit(): void {\n        if (this.rowResizer) {\n            this._putBodyCellsContentIntoDiv();\n        }\n        if (this.rowResizer) {\n            this._addRowsResizer();\n        }\n        this._setTableMode(this.fitWidth);\n    }\n\n    ngOnChanges(changes: SimpleChanges): void {\n        super.ngOnChanges(changes);\n        const { fitWidth } = changes;\n        if (this.enableResizing && fitWidth && !fitWidth.firstChange) {\n            const newFitWidth = fitWidth.currentValue;\n            this._setTableMode(newFitWidth);\n        }\n    }\n    private _initializeTable(): void {\n        this._initTable();\n        this._setTableMode(this.fitWidth);\n    }\n    private _resizeRow(event): void {\n        this._currentResizer = Resizer.Row;\n        const elementFromPoint = document.elementFromPoint(event.pageX, event.pageY);\n        this._currentCell = elementFromPoint?.closest('td') as HTMLTableCellElement;\n        this._startY = event.pageY;\n        this._currentRowHeight = this._currentCell?.clientHeight || 0;\n    }\n\n    private _resizeColumn(event): void {\n        if (!this.fitWidth) {\n            this._setTableFreeSize();\n        }\n        this._currentResizer = Resizer.Column;\n        const elementFromPoint = document.elementFromPoint(event.pageX, event.pageY);\n        this._currentCell = elementFromPoint?.closest('th') as HTMLTableCellElement;\n        this._startX = event.pageX;\n        this._currentColumnWidth = this._currentCell?.clientWidth || 0;\n        this._sideCell = this._getSideCell(this._currentCell);\n        this._sideColumnWidth = this._sideCell?.clientWidth;\n    }\n\n    private _addRowsResizer(): void {\n        const table = this._table;\n        const rowsLabel = table.querySelectorAll('.vertical-label');\n        rowsLabel.forEach((cell) => {\n            const rowResizer = this.renderer.createElement('div');\n\n            this.renderer.appendChild(cell, rowResizer);\n\n            rowResizer.setAttribute('class', 'row-resizer');\n            this.renderer.setStyle(cell, 'height', 'inherit');\n            this.renderer.setStyle(cell, 'position', 'relative');\n            this.renderer.setAttribute(\n                rowResizer,\n                'style',\n                'cursor: row-resize; height:8px; position:absolute;bottom:0;left:0;right:0'\n            );\n        });\n    }\n\n    private _putBodyCellsContentIntoDiv(): void {\n        const table = this._table as any;\n        const bodyCells = table.querySelectorAll('body td:not(.vertical-label)');\n        bodyCells.forEach((cell) => {\n            const contentContainer = this.renderer.createElement('div');\n            cell.children.forEach((child) => {\n                contentContainer.appendChild(child);\n            });\n            this.renderer.setStyle(cell, 'overflow', 'hidden');\n            this.renderer.setStyle(cell, 'height', 'inherit');\n            this.renderer.setStyle(contentContainer, 'height', 'inherit');\n            this.renderer.setStyle(contentContainer, 'display', 'block');\n\n            cell.appendChild(contentContainer);\n        });\n    }\n\n    private _getSideCell(currentCell): Element | null {\n        const currentRow = this._currentCell.parentNode?.children;\n        if (currentRow) {\n            const cellIndexInRow = Array.from(currentRow).indexOf(currentCell);\n            return Array.from(currentRow)[cellIndexInRow + 1];\n        }\n        return null;\n    }\n\n    private _changeWidth(\n        fitWidth: boolean,\n        sideCell,\n        currentCell,\n        changedCurrentCellWidth,\n        changedSideCellWidth\n    ): void {\n        if (fitWidth) {\n            if (sideCell && changedCurrentCellWidth >= this.minWidth && changedSideCellWidth >= this.minWidth) {\n                this.renderer.setStyle(sideCell, 'width', changedSideCellWidth + 'px');\n                this.renderer.setStyle(sideCell, 'min-width', changedSideCellWidth + 'px');\n                this.renderer.setStyle(currentCell, 'width', changedCurrentCellWidth + 'px');\n                this.renderer.setStyle(currentCell, 'min-width', changedCurrentCellWidth + 'px');\n            }\n        } else if (changedCurrentCellWidth >= this.minWidth) {\n            this.renderer.setStyle(currentCell, 'width', changedCurrentCellWidth + 'px');\n            this.renderer.setStyle(currentCell, 'min-width', changedCurrentCellWidth + 'px');\n        }\n    }\n\n    private _changeHeight(currentCell, changedHeight, minHeight): void {\n        if (changedHeight > minHeight) {\n            this.renderer.setStyle(currentCell.closest('tr'), 'height', changedHeight + 'px');\n        }\n    }\n    private _initTable(): void {\n        if (this._isInitTable) {\n            return;\n        }\n        this._isInitTable = true;\n        const table: HTMLTableElement = this._table;\n        const parent = table.parentElement;\n        this.renderer.setStyle(parent, 'overflow-x', this.fitWidth ? 'hidden' : 'auto');\n        // this.renderer.setStyle(parent, 'overflow-y', 'auto');\n        this.renderer.setStyle(parent, 'width', '100%');\n    }\n\n    private _setTableMode(isFitWidth): void {\n        if (isFitWidth) {\n            this._setTableFitSize();\n        }\n    }\n\n    private _setTableFreeSize(): void {\n        const table = this._table;\n        this.renderer.setStyle(table, 'width', this.containerWidth + 'px');\n        this.renderer.setStyle(table, 'max-width', 'unset');\n        this.renderer.setStyle(table, 'min-width', this.containerWidth + 'px');\n        const headCells = table.querySelectorAll('th');\n        headCells.forEach((cell) => {\n            const width = cell.offsetWidth;\n            this.renderer.setStyle(cell, 'width', width + 'px');\n            this.renderer.setStyle(cell, 'min-width', width + 'px');\n        });\n    }\n\n    private _setTableFitSize(): void {\n        const table = this._table;\n        this.renderer.setStyle(table, 'width', '100%');\n        this.renderer.setStyle(table, 'max-width', '100%');\n    }\n\n    private _mouseDown(e): void {\n        if (e.srcElement.className === 'row-resizer') {\n            this._resizeRow(e);\n            this.renderer.setStyle(this.el.nativeElement, 'cursor', 'row-resize');\n        } else if (e.srcElement.className === 'column-resizer') {\n            this._resizeColumn(e);\n            this.renderer.setStyle(this.el.nativeElement, 'cursor', 'col-resize');\n        }\n    }\n\n    private _mouseMove(e): void {\n        if (e.buttons !== 0) {\n            if (this._currentResizer === Resizer.Column) {\n                if (!this._isInitTable) {\n                    this._initializeTable();\n                }\n                const endX = e.pageX;\n                const dx = endX - this._startX;\n                const changedCurrentCellWidth = this._currentColumnWidth - dx;\n                const changedSideCellWidth = this._sideColumnWidth + dx;\n                this._changeWidth(\n                    this.fitWidth,\n                    this._sideCell,\n                    this._currentCell,\n                    changedCurrentCellWidth,\n                    changedSideCellWidth\n                );\n            } else if (this._currentResizer === Resizer.Row) {\n                const endY = e.pageY;\n                const dy = endY - this._startY;\n                const changedCurrentRowHeight = this._currentRowHeight + dy;\n                this._changeHeight(this._currentCell, changedCurrentRowHeight, this.minHeight);\n            }\n        }\n    }\n\n    private _mouseUp(): void {\n        if (this._currentResizer) {\n            const table = this.el.nativeElement;\n            const headers = table.querySelectorAll('th');\n            const columnResized: ColumnResizedArgs[] = [];\n            for (let i = 0; i < headers.length; i++) {\n                const header = headers[i];\n                const columnName = header.attributes['columnname']?.value;\n                if (typeof columnName !== 'undefined') {\n                    columnResized.push({ name: columnName, width: header.offsetWidth });\n                }\n            }\n            this.columnResized.emit(columnResized);\n        }\n        this._currentResizer = null;\n        this.renderer.setStyle(this.el.nativeElement, 'cursor', 'default');\n    }\n}\n"]}

package/esm2020/lib/directives/ulv-command.directive.mjs

@@ -0,0 +1,41 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+export class UlvCommandDirective extends BaseDirective {
+    constructor() {
+        super();
+        this.commandClick = new EventEmitter();
+    }
+    onClick(event) {
+        const button = this.ulvCommandHandler;
+        event.stopPropagation();
+        event.preventDefault();
+        this.commandClick.emit(button);
+        setTimeout(() => {
+            // add settimeout because we need select row before execute row
+            if (button.Command && button.Command.Handler) {
+                button.Command.Handler(button);
+            }
+            else if (button.handler) {
+                button.handler.bind(button.scope)(button);
+            }
+        });
+        return false;
+    }
+}
+UlvCommandDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UlvCommandDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+UlvCommandDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: UlvCommandDirective, selector: "[ulvCommandHandler]", inputs: { ulvCommandHandler: "ulvCommandHandler" }, outputs: { commandClick: "commandClick" }, host: { listeners: { "click": "onClick($event)" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UlvCommandDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ulvCommandHandler]'
+                }]
+        }], ctorParameters: function () { return []; }, propDecorators: { ulvCommandHandler: [{
+                type: Input
+            }], commandClick: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/until-inview.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive, Input } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { BaseDirective } from './base.directive';
+import { fromIntersectionObserver } from '../from-intersection-observer';
+import * as i0 from "@angular/core";
+export class UntilInViewDirective extends BaseDirective {
+    constructor(_templateRef, _vcr, _cdr) {
+        super();
+        this._templateRef = _templateRef;
+        this._vcr = _vcr;
+        this._cdr = _cdr;
+        this.intersectionDebounce = 100;
+        this.viewed$ = new Subject();
+    }
+    viewed() {
+        this.viewed$.next();
+        this._vcr.createEmbeddedView(this._templateRef);
+        this._cdr.detectChanges();
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        const element = this.untilInView.nativeElement;
+        const config = {
+            root: null,
+            rootMargin: '0px',
+            threshold: 0
+        };
+        fromIntersectionObserver(element, config, this.intersectionDebounce)
+            .pipe(takeUntil(this.viewed$), takeUntil(this._onDestroy$))
+            .subscribe(() => {
+            this.viewed();
+        });
+    }
+    ngOnDestroy() {
+        this._onDestroy$.next();
+    }
+}
+UntilInViewDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UntilInViewDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Directive });
+UntilInViewDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: UntilInViewDirective, selector: "[untilInView]", inputs: { untilInView: "untilInView", intersectionDebounce: "intersectionDebounce" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: UntilInViewDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[untilInView]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { untilInView: [{
+                type: Input
+            }], intersectionDebounce: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/dynamic-component/base-dynamic.component.mjs

@@ -0,0 +1,89 @@
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, ViewContainerRef } from '@angular/core';
+import { takeUntil, tap } from 'rxjs';
+import { BaseComponent } from '../base.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../services";
+export class BaseDynamicComponent extends BaseComponent {
+    constructor(_portalService, _injector) {
+        super();
+        this._portalService = _portalService;
+        this._injector = _injector;
+        this.events = new EventEmitter();
+    }
+    async ngOnInit() {
+        super.ngOnInit();
+        this._renderComponentInstance();
+    }
+    ngOnChanges(changes) {
+        if (!this._component?.instance) {
+            return;
+        }
+        // const changesKey = Object.keys(changes);
+        // changesKey
+        //     .filter((c) => !changes[c].firstChange)
+        //     .forEach((c) => (this._component.instance[c] = changes[c].currentValue));
+        this._component.instance.ngOnChanges(changes);
+    }
+    ngOnDestroy() {
+        this._destroyComponentInstance();
+    }
+    async _renderComponentInstance() {
+        this._destroyComponentInstance();
+        if (!this.component) {
+            return;
+        }
+        const { Module, ModuleFileName, Name, Selector } = this.component;
+        this._portalService
+            .getComponent(Module, ModuleFileName, Name, Selector, this._injector)
+            .pipe(takeUntil(this._onDestroy$))
+            .subscribe((componentRef) => {
+            this._container.insert(componentRef.hostView);
+            this._component = componentRef;
+            if (this.component.Parameters) {
+                this._component.instance.parameters = this.component.Parameters;
+            }
+            if (this.value) {
+                this._component.instance.value = this.value;
+            }
+            this.setComponentInputs();
+            const events = this._component.instance.events;
+            if (events) {
+                events
+                    .pipe(takeUntil(this._onDestroy$), tap((c) => this.events.emit(c)))
+                    .subscribe();
+            }
+        });
+        this.setComponentInputs();
+    }
+    setComponentInputs() {
+        const inputProperties = Object.keys(this).filter((c) => !c.startsWith('_') && c !== 'events');
+        inputProperties.forEach((c) => {
+            this._component.instance[c] = this[c];
+        });
+    }
+    _destroyComponentInstance() {
+        if (this._component) {
+            this._component.destroy();
+        }
+    }
+}
+BaseDynamicComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseDynamicComponent, deps: [{ token: i1.PortalService }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
+BaseDynamicComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.7", type: BaseDynamicComponent, selector: "bnrc-dynamic-component", inputs: { component: "component", value: "value" }, outputs: { events: "events" }, viewQueries: [{ propertyName: "_container", first: true, predicate: ["componentContainer"], descendants: true, read: ViewContainerRef, static: true }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `<ng-container #componentContainer></ng-container>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseDynamicComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'bnrc-dynamic-component',
+                    template: `<ng-container #componentContainer></ng-container>`,
+                    changeDetection: ChangeDetectionStrategy.OnPush
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PortalService }, { type: i0.Injector }]; }, propDecorators: { _container: [{
+                type: ViewChild,
+                args: ['componentContainer', { read: ViewContainerRef, static: true }]
+            }], component: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], events: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-dynamic.component.js","sourceRoot":"","sources":["../../../../../projects/barsa-novin-ray-core/src/lib/dynamic-component/base-dynamic.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ChangeDetectionStrategy,\n    Component,\n    ComponentRef,\n    EventEmitter,\n    Injector,\n    Input,\n    OnChanges,\n    OnDestroy,\n    OnInit,\n    Output,\n    SimpleChanges,\n    ViewChild,\n    ViewContainerRef\n} from '@angular/core';\nimport { takeUntil, tap } from 'rxjs';\nimport { EjrayOlgo } from '../abstract-classes';\nimport { BaseComponent } from '../base.component';\nimport { PortalService } from '../services';\n\n@Component({\n    selector: 'bnrc-dynamic-component',\n    template: `<ng-container #componentContainer></ng-container>`,\n    changeDetection: ChangeDetectionStrategy.OnPush\n})\nexport class BaseDynamicComponent extends BaseComponent implements OnInit, OnDestroy, OnChanges {\n    @ViewChild('componentContainer', { read: ViewContainerRef, static: true })\n    _container: ViewContainerRef;\n    @Input() component: EjrayOlgo;\n    @Input() value: any;\n    @Output() events = new EventEmitter<{ title: string; data?: any }>();\n    public _component: ComponentRef<any>;\n    constructor(protected _portalService: PortalService, protected _injector: Injector) {\n        super();\n    }\n    async ngOnInit(): Promise<void> {\n        super.ngOnInit();\n        this._renderComponentInstance();\n    }\n    ngOnChanges(changes: SimpleChanges): void {\n        if (!this._component?.instance) {\n            return;\n        }\n        // const changesKey = Object.keys(changes);\n        // changesKey\n        //     .filter((c) => !changes[c].firstChange)\n        //     .forEach((c) => (this._component.instance[c] = changes[c].currentValue));\n\n        this._component.instance.ngOnChanges(changes);\n    }\n    ngOnDestroy(): void {\n        this._destroyComponentInstance();\n    }\n\n    protected async _renderComponentInstance(): Promise<void> {\n        this._destroyComponentInstance();\n        if (!this.component) {\n            return;\n        }\n        const { Module, ModuleFileName, Name, Selector } = this.component;\n        this._portalService\n            .getComponent(Module, ModuleFileName, Name, Selector, this._injector)\n            .pipe(takeUntil(this._onDestroy$))\n            .subscribe((componentRef: ComponentRef<any>) => {\n                this._container.insert(componentRef.hostView);\n                this._component = componentRef;\n                if (this.component.Parameters) {\n                    this._component.instance.parameters = this.component.Parameters;\n                }\n                if (this.value) {\n                    this._component.instance.value = this.value;\n                }\n                this.setComponentInputs();\n                const events = this._component.instance.events as EventEmitter<{ title: string; data?: any }>;\n                if (events) {\n                    events\n                        .pipe(\n                            takeUntil(this._onDestroy$),\n                            tap((c) => this.events.emit(c))\n                        )\n                        .subscribe();\n                }\n            });\n        this.setComponentInputs();\n    }\n\n    protected setComponentInputs(): void {\n        const inputProperties = Object.keys(this).filter((c) => !c.startsWith('_') && c !== 'events');\n        inputProperties.forEach((c) => {\n            this._component.instance[c] = this[c];\n        });\n    }\n\n    protected _destroyComponentInstance(): void {\n        if (this._component) {\n            this._component.destroy();\n        }\n    }\n}\n"]}