barsa-novin-ray-core 0.0.2

package/esm2020/lib/directives/anchor-scroll.directive.mjs

@@ -0,0 +1,24 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AnchorScrollDirective {
+    scrollInto() {
+        const element = document.querySelector('#' + this.anchorScroll);
+        if (element != null) {
+            element.scrollIntoView();
+        }
+    }
+}
+AnchorScrollDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AnchorScrollDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+AnchorScrollDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: AnchorScrollDirective, selector: "[anchorScroll]", inputs: { anchorScroll: "anchorScroll" }, host: { listeners: { "click": "scrollInto()" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AnchorScrollDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[anchorScroll]'
+                }]
+        }], propDecorators: { anchorScroll: [{
+                type: Input
+            }], scrollInto: [{
+                type: HostListener,
+                args: ['click']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5jaG9yLXNjcm9sbC5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS1ub3Zpbi1yYXktY29yZS9zcmMvbGliL2RpcmVjdGl2ZXMvYW5jaG9yLXNjcm9sbC5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsS0FBSyxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUsvRCxNQUFNLE9BQU8scUJBQXFCO0lBRzlCLFVBQVU7UUFDTixNQUFNLE9BQU8sR0FBRyxRQUFRLENBQUMsYUFBYSxDQUFDLEdBQUcsR0FBRyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDaEUsSUFBSSxPQUFPLElBQUksSUFBSSxFQUFFO1lBQ2pCLE9BQU8sQ0FBQyxjQUFjLEVBQUUsQ0FBQztTQUM1QjtJQUNMLENBQUM7O2tIQVJRLHFCQUFxQjtzR0FBckIscUJBQXFCOzJGQUFyQixxQkFBcUI7a0JBSGpDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGdCQUFnQjtpQkFDN0I7OEJBRVksWUFBWTtzQkFBcEIsS0FBSztnQkFFTixVQUFVO3NCQURULFlBQVk7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSG9zdExpc3RlbmVyLCBJbnB1dCB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ1thbmNob3JTY3JvbGxdJ1xufSlcbmV4cG9ydCBjbGFzcyBBbmNob3JTY3JvbGxEaXJlY3RpdmUge1xuICAgIEBJbnB1dCgpIGFuY2hvclNjcm9sbDogc3RyaW5nO1xuICAgIEBIb3N0TGlzdGVuZXIoJ2NsaWNrJylcbiAgICBzY3JvbGxJbnRvKCk6IHZvaWQge1xuICAgICAgICBjb25zdCBlbGVtZW50ID0gZG9jdW1lbnQucXVlcnlTZWxlY3RvcignIycgKyB0aGlzLmFuY2hvclNjcm9sbCk7XG4gICAgICAgIGlmIChlbGVtZW50ICE9IG51bGwpIHtcbiAgICAgICAgICAgIGVsZW1lbnQuc2Nyb2xsSW50b1ZpZXcoKTtcbiAgICAgICAgfVxuICAgIH1cbn1cbiJdfQ==

package/esm2020/lib/directives/attr-rtl.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, Input } from '@angular/core';
+import { takeUntil } from 'rxjs/operators';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/portal.service";
+export class AttrRtlDirective extends BaseDirective {
+    constructor(_renderer2, _el, _portalService) {
+        super();
+        this._renderer2 = _renderer2;
+        this._el = _el;
+        const rtl = this.rtl;
+        if (rtl === false) {
+            this._setRtlAttribute(rtl);
+            return;
+        }
+        _portalService.rtl$.pipe(takeUntil(this._onDestroy$)).subscribe((rtlValue) => {
+            this._setRtlAttribute(rtlValue);
+        });
+    }
+    _setRtlAttribute(rtl) {
+        this._renderer2.setAttribute(this._el.nativeElement, 'rtl', `${rtl}`);
+    }
+}
+AttrRtlDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AttrRtlDirective, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i1.PortalService }], target: i0.ɵɵFactoryTarget.Directive });
+AttrRtlDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: AttrRtlDirective, selector: "[attrRtl]", inputs: { rtl: ["attrRtl", "rtl"] }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: AttrRtlDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[attrRtl]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i1.PortalService }]; }, propDecorators: { rtl: [{
+                type: Input,
+                args: ['attrRtl']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/base.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive } from '@angular/core';
+import { Subject } from 'rxjs';
+import { BarsaApi } from '../abstract-classes/barsa-api';
+import * as i0 from "@angular/core";
+export class BaseDirective {
+    constructor() {
+        this._onDestroy$ = new Subject();
+    }
+    ngAfterContentInit() {
+        if (!BarsaApi.Common.Debug?.Data?.CustomUi) {
+            return;
+        }
+        console.log('ngAfterContentInit');
+        console.log(this);
+    }
+    ngOnChanges(changes) {
+        if (!BarsaApi.Common.Debug?.Data?.CustomUi) {
+            return;
+        }
+        console.log(changes);
+    }
+    ngOnInit() {
+        if (!BarsaApi.Common.Debug?.Data?.CustomUi) {
+            return;
+        }
+        console.log('ngOnInit');
+        console.log(this);
+    }
+    ngAfterViewInit() {
+        if (!BarsaApi.Common.Debug?.Data?.CustomUi) {
+            return;
+        }
+        console.log('ngAfterViewInit');
+        console.log(this);
+    }
+    ngOnDestroy() {
+        this._onDestroy$.next();
+        this._onDestroy$.complete();
+        if (!BarsaApi.Common.Debug?.Data?.CustomUi) {
+            return;
+        }
+        console.log('ngOnDestroy');
+        console.log(this);
+    }
+}
+BaseDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+BaseDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: BaseDirective, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: BaseDirective, decorators: [{
+            type: Directive
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,39 @@
+import { Directive, Input } from '@angular/core';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+export class ColumnResizerDirective extends BaseDirective {
+    constructor(el, renderer) {
+        super();
+        this.el = el;
+        this.renderer = renderer;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        if (!this.disableResizer) {
+            this._addColumnsResizer();
+        }
+    }
+    _addColumnsResizer() {
+        const cell = this.el.nativeElement;
+        if (cell.hasAttribute('NoResizable')) {
+            return;
+        }
+        const columnResizer = this.renderer.createElement('div');
+        this.renderer.appendChild(cell, columnResizer);
+        columnResizer.setAttribute('class', 'column-resizer');
+        this.renderer.setAttribute(columnResizer, 'style', 'cursor: col-resize; width: 8px;position: absolute;left:0; top:0; bottom:0');
+        this.renderer.setStyle(cell, 'padding-left', 0);
+        this.renderer.setStyle(cell, 'position', 'relative');
+    }
+}
+ColumnResizerDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ColumnResizerDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+ColumnResizerDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: ColumnResizerDirective, selector: "[columnResizer]", inputs: { disableResizer: "disableResizer" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ColumnResizerDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[columnResizer]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { disableResizer: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29sdW1uLXJlc2l6ZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYmFyc2Etbm92aW4tcmF5LWNvcmUvc3JjL2xpYi9kaXJlY3RpdmVzL2NvbHVtbi1yZXNpemVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFjLEtBQUssRUFBcUIsTUFBTSxlQUFlLENBQUM7QUFDaEYsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDOztBQUtqRCxNQUFNLE9BQU8sc0JBQXVCLFNBQVEsYUFBYTtJQUVyRCxZQUFvQixFQUFjLEVBQVUsUUFBbUI7UUFDM0QsS0FBSyxFQUFFLENBQUM7UUFEUSxPQUFFLEdBQUYsRUFBRSxDQUFZO1FBQVUsYUFBUSxHQUFSLFFBQVEsQ0FBVztJQUUvRCxDQUFDO0lBQ0QsUUFBUTtRQUNKLEtBQUssQ0FBQyxRQUFRLEVBQUUsQ0FBQztRQUNqQixJQUFJLENBQUMsSUFBSSxDQUFDLGNBQWMsRUFBRTtZQUN0QixJQUFJLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztTQUM3QjtJQUNMLENBQUM7SUFFTyxrQkFBa0I7UUFDdEIsTUFBTSxJQUFJLEdBQXlCLElBQUksQ0FBQyxFQUFFLENBQUMsYUFBYSxDQUFDO1FBQ3pELElBQUksSUFBSSxDQUFDLFlBQVksQ0FBQyxhQUFhLENBQUMsRUFBRTtZQUNsQyxPQUFPO1NBQ1Y7UUFDRCxNQUFNLGFBQWEsR0FBRyxJQUFJLENBQUMsUUFBUSxDQUFDLGFBQWEsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUV6RCxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLEVBQUUsYUFBYSxDQUFDLENBQUM7UUFDL0MsYUFBYSxDQUFDLFlBQVksQ0FBQyxPQUFPLEVBQUUsZ0JBQWdCLENBQUMsQ0FBQztRQUN0RCxJQUFJLENBQUMsUUFBUSxDQUFDLFlBQVksQ0FDdEIsYUFBYSxFQUNiLE9BQU8sRUFDUCwyRUFBMkUsQ0FDOUUsQ0FBQztRQUNGLElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksRUFBRSxjQUFjLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDaEQsSUFBSSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsSUFBSSxFQUFFLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztJQUN6RCxDQUFDOzttSEE1QlEsc0JBQXNCO3VHQUF0QixzQkFBc0I7MkZBQXRCLHNCQUFzQjtrQkFIbEMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsaUJBQWlCO2lCQUM5Qjt5SEFFWSxjQUFjO3NCQUF0QixLQUFLIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBJbnB1dCwgT25Jbml0LCBSZW5kZXJlcjIgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQmFzZURpcmVjdGl2ZSB9IGZyb20gJy4vYmFzZS5kaXJlY3RpdmUnO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgICBzZWxlY3RvcjogJ1tjb2x1bW5SZXNpemVyXSdcclxufSlcclxuZXhwb3J0IGNsYXNzIENvbHVtblJlc2l6ZXJEaXJlY3RpdmUgZXh0ZW5kcyBCYXNlRGlyZWN0aXZlIGltcGxlbWVudHMgT25Jbml0IHtcclxuICAgIEBJbnB1dCgpIGRpc2FibGVSZXNpemVyOiBib29sZWFuO1xyXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbDogRWxlbWVudFJlZiwgcHJpdmF0ZSByZW5kZXJlcjogUmVuZGVyZXIyKSB7XHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xyXG4gICAgICAgIHN1cGVyLm5nT25Jbml0KCk7XHJcbiAgICAgICAgaWYgKCF0aGlzLmRpc2FibGVSZXNpemVyKSB7XHJcbiAgICAgICAgICAgIHRoaXMuX2FkZENvbHVtbnNSZXNpemVyKCk7XHJcbiAgICAgICAgfVxyXG4gICAgfVxyXG5cclxuICAgIHByaXZhdGUgX2FkZENvbHVtbnNSZXNpemVyKCk6IHZvaWQge1xyXG4gICAgICAgIGNvbnN0IGNlbGw6IEhUTUxUYWJsZUNlbGxFbGVtZW50ID0gdGhpcy5lbC5uYXRpdmVFbGVtZW50O1xyXG4gICAgICAgIGlmIChjZWxsLmhhc0F0dHJpYnV0ZSgnTm9SZXNpemFibGUnKSkge1xyXG4gICAgICAgICAgICByZXR1cm47XHJcbiAgICAgICAgfVxyXG4gICAgICAgIGNvbnN0IGNvbHVtblJlc2l6ZXIgPSB0aGlzLnJlbmRlcmVyLmNyZWF0ZUVsZW1lbnQoJ2RpdicpO1xyXG5cclxuICAgICAgICB0aGlzLnJlbmRlcmVyLmFwcGVuZENoaWxkKGNlbGwsIGNvbHVtblJlc2l6ZXIpO1xyXG4gICAgICAgIGNvbHVtblJlc2l6ZXIuc2V0QXR0cmlidXRlKCdjbGFzcycsICdjb2x1bW4tcmVzaXplcicpO1xyXG4gICAgICAgIHRoaXMucmVuZGVyZXIuc2V0QXR0cmlidXRlKFxyXG4gICAgICAgICAgICBjb2x1bW5SZXNpemVyLFxyXG4gICAgICAgICAgICAnc3R5bGUnLFxyXG4gICAgICAgICAgICAnY3Vyc29yOiBjb2wtcmVzaXplOyB3aWR0aDogOHB4O3Bvc2l0aW9uOiBhYnNvbHV0ZTtsZWZ0OjA7IHRvcDowOyBib3R0b206MCdcclxuICAgICAgICApO1xyXG4gICAgICAgIHRoaXMucmVuZGVyZXIuc2V0U3R5bGUoY2VsbCwgJ3BhZGRpbmctbGVmdCcsIDApO1xyXG4gICAgICAgIHRoaXMucmVuZGVyZXIuc2V0U3R5bGUoY2VsbCwgJ3Bvc2l0aW9uJywgJ3JlbGF0aXZlJyk7XHJcbiAgICB9XHJcbn1cclxuIl19

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

@@ -0,0 +1,43 @@
+import { Directive, EventEmitter, HostListener, Input, Output } from '@angular/core';
+import { BarsaApi } from '../abstract-classes';
+import * as i0 from "@angular/core";
+export class DynamicCommandDirective {
+    constructor() {
+        this.commandClick = new EventEmitter();
+    }
+    onClick(event) {
+        if (typeof this.enableCommand === typeof undefined) {
+            this.enableCommand = true;
+        }
+        if (!this.enableCommand) {
+            return true;
+        }
+        const command = this.dynCommand;
+        event.stopPropagation();
+        event.preventDefault();
+        const e = { command, DynamicSetting: this.mo };
+        BarsaApi.Common.CustomCodeManager.RunDynamicCommand(command.Id, e);
+        this.commandClick.emit();
+        return false;
+    }
+}
+DynamicCommandDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: DynamicCommandDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+DynamicCommandDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: DynamicCommandDirective, selector: "[dynCommand]", inputs: { dynCommand: "dynCommand", mo: "mo", enableCommand: "enableCommand" }, outputs: { commandClick: "commandClick" }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: DynamicCommandDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[dynCommand]'
+                }]
+        }], propDecorators: { dynCommand: [{
+                type: Input
+            }], mo: [{
+                type: Input
+            }], enableCommand: [{
+                type: Input
+            }], commandClick: [{
+                type: Output
+            }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/ellipsify.directive.mjs

@@ -0,0 +1,72 @@
+import { Directive, HostListener, Input } from '@angular/core';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+export class EllipsifyDirective extends BaseDirective {
+    constructor(el, renderer) {
+        super();
+        this.el = el;
+        this.renderer = renderer;
+    }
+    moseMove(e) {
+        if (e.buttons) {
+            this._heightChange();
+        }
+    }
+    ngAfterViewInit() {
+        super.ngAfterViewInit();
+        setTimeout(() => {
+            this.childes = this.el.nativeElement.querySelectorAll('span, h5, p');
+            this._initStyle();
+            this._handleNoEllipsis();
+            this._heightChange();
+        }, 100);
+    }
+    _heightChange() {
+        this.childes.forEach((child) => {
+            if (child.childElementCount === 0) {
+                const height = child.clientHeight;
+                const lineHeightStr = getComputedStyle(child).lineHeight.replace('px', '');
+                const lineHeight = Number(lineHeightStr);
+                let limitLine = this.limitLine ? this.limitLine : Math.round(height / lineHeight);
+                limitLine = limitLine && limitLine !== 0 ? limitLine : 1;
+                this.renderer.setStyle(child, '-webkit-line-clamp', limitLine.toString());
+            }
+        });
+    }
+    _initStyle() {
+        this.childes.forEach((child) => {
+            if (child.childElementCount === 0) {
+                this.renderer.setStyle(child, 'height', 'inherit');
+                this.renderer.setStyle(child, 'overflow', 'hidden');
+                this.renderer.setStyle(child, '-webkit-box-orient', 'vertical');
+                this.renderer.setStyle(child, 'display', '-webkit-box');
+                this.renderer.setStyle(child, 'width', 'fit-content');
+            }
+        });
+    }
+    _handleNoEllipsis() {
+        const noEllipsisEls = this.el.nativeElement.querySelectorAll('[ellipsis=no-ellipsis]');
+        noEllipsisEls.forEach((el) => {
+            const all = el.querySelectorAll('span, h5, p');
+            all.forEach((el2) => {
+                if (el2.childElementCount === 0) {
+                    this.renderer.setStyle(el2, 'white-space', 'break-spaces');
+                }
+            });
+        });
+    }
+}
+EllipsifyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: EllipsifyDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+EllipsifyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: EllipsifyDirective, selector: "[ellipsify]", inputs: { limitLine: "limitLine" }, host: { listeners: { "mousemove": "moseMove($event)" } }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: EllipsifyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[ellipsify]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { limitLine: [{
+                type: Input
+            }], moseMove: [{
+                type: HostListener,
+                args: ['mousemove', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/field-binding.directive.mjs

@@ -0,0 +1,17 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FieldDirective {
+}
+FieldDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FieldDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+FieldDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: FieldDirective, selector: "[field]", inputs: { field: "field", value: "value" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: FieldDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[field]'
+                }]
+        }], propDecorators: { field: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtYmluZGluZy5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS1ub3Zpbi1yYXktY29yZS9zcmMvbGliL2RpcmVjdGl2ZXMvZmllbGQtYmluZGluZy5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxlQUFlLENBQUM7O0FBS2pELE1BQU0sT0FBTyxjQUFjOzsyR0FBZCxjQUFjOytGQUFkLGNBQWM7MkZBQWQsY0FBYztrQkFIMUIsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsU0FBUztpQkFDdEI7OEJBRVksS0FBSztzQkFBYixLQUFLO2dCQUNHLEtBQUs7c0JBQWIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IERpcmVjdGl2ZSwgSW5wdXQgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdbZmllbGRdJ1xufSlcbmV4cG9ydCBjbGFzcyBGaWVsZERpcmVjdGl2ZSB7XG4gICAgQElucHV0KCkgZmllbGQ6IHN0cmluZztcbiAgICBASW5wdXQoKSB2YWx1ZTogYW55O1xufVxuIl19

package/esm2020/lib/directives/img-lazy.directive.mjs

@@ -0,0 +1,75 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { fromEvent, timer, Subject, merge } from 'rxjs';
+import { debounceTime, filter, takeUntil, tap } from 'rxjs/operators';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/portal.service";
+export class ImageLazyDirective extends BaseDirective {
+    constructor(elementRef, portalService) {
+        super();
+        this.elementRef = elementRef;
+        this.portalService = portalService;
+        this.auto = true;
+        this.threshold = 20;
+        this.imageLoaded = new EventEmitter();
+        this._imageViewed$ = new Subject();
+        this._imgEl = this.elementRef.nativeElement;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        const supports = 'loading' in HTMLImageElement.prototype;
+        if (supports) {
+            this._imgEl.src = this.imgLazy;
+            this._imgEl.setAttribute('loading', 'lazy');
+            return;
+        }
+        const timer1 = timer(1000);
+        if (this.auto) {
+            const isCached = this.portalService.cachedImages[this.imgLazy];
+            if (isCached) {
+                this._imgEl.src = this.imgLazy;
+                return;
+            }
+            merge([timer1, fromEvent(window, 'scroll')])
+                .pipe(takeUntil(this._imageViewed$), takeUntil(this._onDestroy$), debounceTime(20), filter(() => this.isInViewport()), tap(() => this.showImage()))
+                .subscribe();
+        }
+    }
+    showImage() {
+        if (this.imgLazy === this._imgEl.src) {
+            return;
+        }
+        const imgEl = this._imgEl;
+        imgEl.src = this.imgLazy;
+        this.portalService.cachedImages[this.imgLazy] = true;
+        imgEl.addEventListener('load', () => {
+            this.imageLoaded.emit();
+        });
+        this._imageViewed$.next();
+    }
+    isInViewport() {
+        const rect = this._imgEl.getBoundingClientRect();
+        const isInViewport = rect.top >= 0 &&
+            rect.left >= 0 &&
+            rect.bottom - this.threshold <= (window.innerHeight || document.documentElement.clientHeight) &&
+            rect.right <= (window.innerWidth || document.documentElement.clientWidth);
+        return isInViewport;
+    }
+}
+ImageLazyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ImageLazyDirective, deps: [{ token: i0.ElementRef }, { token: i1.PortalService }], target: i0.ɵɵFactoryTarget.Directive });
+ImageLazyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: ImageLazyDirective, selector: "[imgLazy]", inputs: { auto: "auto", threshold: "threshold", imgLazy: "imgLazy" }, outputs: { imageLoaded: "imageLoaded" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ImageLazyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[imgLazy]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.PortalService }]; }, propDecorators: { auto: [{
+                type: Input
+            }], threshold: [{
+                type: Input
+            }], imageLoaded: [{
+                type: Output
+            }], imgLazy: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/index.mjs

@@ -0,0 +1,19 @@
+export * from './anchor-scroll.directive';
+export * from './attr-rtl.directive';
+export * from './base.directive';
+export * from './column-resizer.directive';
+export * from './dynamic-command.directive';
+export * from './ellipsify.directive';
+export * from './field-binding.directive';
+export * from './img-lazy.directive';
+export * from './intersection-observer.directive';
+export * from './items-renderer.directive';
+export * from './numbers-only-input.directive';
+export * from './placeHolder.directive';
+export * from './render-ulv-viewer.directive';
+export * from './render-ulv-paging.directive';
+export * from './render-ulv-viewer.directive';
+export * from './table-resizer.directive';
+export * from './ulv-command.directive';
+export * from './until-inview.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9iYXJzYS1ub3Zpbi1yYXktY29yZS9zcmMvbGliL2RpcmVjdGl2ZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsbUNBQW1DLENBQUM7QUFDbEQsY0FBYyw0QkFBNEIsQ0FBQztBQUMzQyxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYywrQkFBK0IsQ0FBQztBQUM5QyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYywyQkFBMkIsQ0FBQztBQUMxQyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FuY2hvci1zY3JvbGwuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYXR0ci1ydGwuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vYmFzZS5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9jb2x1bW4tcmVzaXplci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9keW5hbWljLWNvbW1hbmQuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vZWxsaXBzaWZ5LmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2ZpZWxkLWJpbmRpbmcuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vaW1nLWxhenkuZGlyZWN0aXZlJztcbmV4cG9ydCAqIGZyb20gJy4vaW50ZXJzZWN0aW9uLW9ic2VydmVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL2l0ZW1zLXJlbmRlcmVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL251bWJlcnMtb25seS1pbnB1dC5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9wbGFjZUhvbGRlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZW5kZXItdWx2LXZpZXdlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZW5kZXItdWx2LXBhZ2luZy5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi9yZW5kZXItdWx2LXZpZXdlci5kaXJlY3RpdmUnO1xuZXhwb3J0ICogZnJvbSAnLi90YWJsZS1yZXNpemVyLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3Vsdi1jb21tYW5kLmRpcmVjdGl2ZSc7XG5leHBvcnQgKiBmcm9tICcuL3VudGlsLWludmlldy5kaXJlY3RpdmUnO1xuIl19

package/esm2020/lib/directives/intersection-observer.directive.mjs

@@ -0,0 +1,49 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { fromIntersectionObserver } from '../from-intersection-observer';
+import * as i0 from "@angular/core";
+export class IntersectionObserverDirective {
+    constructor(element) {
+        this.element = element;
+        this.intersectionDebounce = 0;
+        this.intersectionRootMargin = '0px';
+        this.visibilityChange = new EventEmitter();
+        this.destroy$ = new Subject();
+    }
+    ngOnInit() {
+        const element = this.element.nativeElement;
+        const config = {
+            root: this.intersectionRoot,
+            rootMargin: this.intersectionRootMargin,
+            threshold: this.intersectionThreshold
+        };
+        fromIntersectionObserver(element, config, this.intersectionDebounce)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe((status) => {
+            this.visibilityChange.emit(status);
+        });
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+    }
+}
+IntersectionObserverDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: IntersectionObserverDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+IntersectionObserverDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: IntersectionObserverDirective, selector: "[intersectionObserver]", inputs: { intersectionDebounce: "intersectionDebounce", intersectionRootMargin: "intersectionRootMargin", intersectionRoot: "intersectionRoot", intersectionThreshold: "intersectionThreshold" }, outputs: { visibilityChange: "visibilityChange" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: IntersectionObserverDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[intersectionObserver]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { intersectionDebounce: [{
+                type: Input
+            }], intersectionRootMargin: [{
+                type: Input
+            }], intersectionRoot: [{
+                type: Input
+            }], intersectionThreshold: [{
+                type: Input
+            }], visibilityChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/items-renderer.directive.mjs

@@ -0,0 +1,59 @@
+import { Directive, EventEmitter, Input, Output } from '@angular/core';
+import { BaseDirective } from './base.directive';
+import * as i0 from "@angular/core";
+export class ItemsRendererDirective extends BaseDirective {
+    constructor(el) {
+        super();
+        this.el = el;
+        this.itemClick = new EventEmitter();
+        this.handleClick = false;
+    }
+    ngOnInit() {
+        super.ngOnInit();
+        const context = this.itemsRenderer.context;
+        const { itemSelector } = this.itemsRenderer;
+        const fragmentDoc = document.createDocumentFragment();
+        if (!this.moDataList) {
+            this.moDataList = this.itemsRenderer.moDataList;
+        }
+        this.moDataList.forEach((mo, index) => {
+            const itemComponentElement = document.createElement(itemSelector);
+            itemComponentElement.addEventListener('itemClick', (e) => {
+                if (this.handleClick) {
+                    this.itemClick.emit(e.detail);
+                }
+                else {
+                    mo.$IsChecked = true;
+                    context?.fireEvent('rowdblclick', context, index, mo);
+                }
+            });
+            itemComponentElement.context = context;
+            itemComponentElement.mo = mo;
+            itemComponentElement.index = index;
+            itemComponentElement.classNames = this.itemClass;
+            itemComponentElement.allColumns = this.itemsRenderer.allColumns;
+            fragmentDoc.appendChild(itemComponentElement);
+        });
+        this.el.nativeElement.appendChild(fragmentDoc);
+        this._fragmentDoc = fragmentDoc;
+    }
+}
+ItemsRendererDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ItemsRendererDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+ItemsRendererDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: ItemsRendererDirective, selector: "[itemsRenderer]", inputs: { itemsRenderer: "itemsRenderer", moDataList: "moDataList", itemClass: "itemClass", handleClick: "handleClick" }, outputs: { itemClick: "itemClick" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: ItemsRendererDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[itemsRenderer]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { itemsRenderer: [{
+                type: Input
+            }], moDataList: [{
+                type: Input
+            }], itemClass: [{
+                type: Input
+            }], itemClick: [{
+                type: Output
+            }], handleClick: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/directives/numbers-only-input.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, HostListener } from '@angular/core';
+import * as i0 from "@angular/core";
+export class NumbersOnlyInputDirective {
+    constructor(elRef) {
+        this.elRef = elRef;
+    }
+    onInputChange(event) {
+        const initalValue = this.elRef.nativeElement.value;
+        this.elRef.nativeElement.value = initalValue.replace(/[^0-9]*/g, '');
+        if (initalValue !== this.elRef.nativeElement.value) {
+            event.stopPropagation();
+        }
+    }
+}
+NumbersOnlyInputDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: NumbersOnlyInputDirective, deps: [{ token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+NumbersOnlyInputDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: NumbersOnlyInputDirective, selector: "input[type=number], input[numbersOnly]", host: { listeners: { "input": "onInputChange($event)" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: NumbersOnlyInputDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'input[type=number], input[numbersOnly]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }]; }, propDecorators: { onInputChange: [{
+                type: HostListener,
+                args: ['input', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnVtYmVycy1vbmx5LWlucHV0LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2JhcnNhLW5vdmluLXJheS1jb3JlL3NyYy9saWIvZGlyZWN0aXZlcy9udW1iZXJzLW9ubHktaW5wdXQuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQWMsWUFBWSxFQUFFLE1BQU0sZUFBZSxDQUFDOztBQUtwRSxNQUFNLE9BQU8seUJBQXlCO0lBQ2xDLFlBQW9CLEtBQWlCO1FBQWpCLFVBQUssR0FBTCxLQUFLLENBQVk7SUFBRyxDQUFDO0lBRU4sYUFBYSxDQUFDLEtBQUs7UUFDbEQsTUFBTSxXQUFXLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsS0FBSyxDQUFDO1FBQ25ELElBQUksQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLEtBQUssR0FBRyxXQUFXLENBQUMsT0FBTyxDQUFDLFVBQVUsRUFBRSxFQUFFLENBQUMsQ0FBQztRQUNyRSxJQUFJLFdBQVcsS0FBSyxJQUFJLENBQUMsS0FBSyxDQUFDLGFBQWEsQ0FBQyxLQUFLLEVBQUU7WUFDaEQsS0FBSyxDQUFDLGVBQWUsRUFBRSxDQUFDO1NBQzNCO0lBQ0wsQ0FBQzs7c0hBVFEseUJBQXlCOzBHQUF6Qix5QkFBeUI7MkZBQXpCLHlCQUF5QjtrQkFIckMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsd0NBQXdDO2lCQUNyRDtpR0FJc0MsYUFBYTtzQkFBL0MsWUFBWTt1QkFBQyxPQUFPLEVBQUUsQ0FBQyxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIEVsZW1lbnRSZWYsIEhvc3RMaXN0ZW5lciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgICBzZWxlY3RvcjogJ2lucHV0W3R5cGU9bnVtYmVyXSwgaW5wdXRbbnVtYmVyc09ubHldJ1xufSlcbmV4cG9ydCBjbGFzcyBOdW1iZXJzT25seUlucHV0RGlyZWN0aXZlIHtcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIGVsUmVmOiBFbGVtZW50UmVmKSB7fVxuXG4gICAgQEhvc3RMaXN0ZW5lcignaW5wdXQnLCBbJyRldmVudCddKSBvbklucHV0Q2hhbmdlKGV2ZW50KTogdm9pZCB7XG4gICAgICAgIGNvbnN0IGluaXRhbFZhbHVlID0gdGhpcy5lbFJlZi5uYXRpdmVFbGVtZW50LnZhbHVlO1xuICAgICAgICB0aGlzLmVsUmVmLm5hdGl2ZUVsZW1lbnQudmFsdWUgPSBpbml0YWxWYWx1ZS5yZXBsYWNlKC9bXjAtOV0qL2csICcnKTtcbiAgICAgICAgaWYgKGluaXRhbFZhbHVlICE9PSB0aGlzLmVsUmVmLm5hdGl2ZUVsZW1lbnQudmFsdWUpIHtcbiAgICAgICAgICAgIGV2ZW50LnN0b3BQcm9wYWdhdGlvbigpO1xuICAgICAgICB9XG4gICAgfVxufVxuIl19

package/esm2020/lib/directives/placeHolder.directive.mjs

@@ -0,0 +1,15 @@
+import { Directive, Input } from '@angular/core';
+import * as i0 from "@angular/core";
+export class PlaceHolderDirective {
+}
+PlaceHolderDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: PlaceHolderDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+PlaceHolderDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "14.2.7", type: PlaceHolderDirective, selector: "[placeHolder]", inputs: { placeHolder: "placeHolder" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.7", ngImport: i0, type: PlaceHolderDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[placeHolder]'
+                }]
+        }], propDecorators: { placeHolder: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGxhY2VIb2xkZXIuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYmFyc2Etbm92aW4tcmF5LWNvcmUvc3JjL2xpYi9kaXJlY3RpdmVzL3BsYWNlSG9sZGVyLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsU0FBUyxFQUFFLEtBQUssRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFLakQsTUFBTSxPQUFPLG9CQUFvQjs7aUhBQXBCLG9CQUFvQjtxR0FBcEIsb0JBQW9COzJGQUFwQixvQkFBb0I7a0JBSGhDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLGVBQWU7aUJBQzVCOzhCQUVZLFdBQVc7c0JBQW5CLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0IH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBEaXJlY3RpdmUoe1xuICAgIHNlbGVjdG9yOiAnW3BsYWNlSG9sZGVyXSdcbn0pXG5leHBvcnQgY2xhc3MgUGxhY2VIb2xkZXJEaXJlY3RpdmUge1xuICAgIEBJbnB1dCgpIHBsYWNlSG9sZGVyOiBzdHJpbmc7XG59XG4iXX0=