@stemy/ngx-utils 12.1.3 → 12.1.6

package/esm2020/ngx-utils/directives/background.directive.mjs

@@ -0,0 +1,51 @@
+import { Directive, ElementRef, Input, Renderer2 } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { FileUtils } from "../utils/file.utils";
+import { UniversalService } from "../services/universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/universal.service";
+const defaultClass = "default-image";
+const loadingClass = "loading-image";
+export class BackgroundDirective {
+    constructor(http, element, renderer, universal) {
+        this.http = http;
+        this.element = element;
+        this.renderer = renderer;
+        this.universal = universal;
+    }
+    ngOnChanges(changes) {
+        if (this.universal.isServer) {
+            this.setBackground(this.background);
+            return;
+        }
+        this.renderer.removeClass(this.element.nativeElement, defaultClass);
+        this.renderer.addClass(this.element.nativeElement, loadingClass);
+        FileUtils.readDataFromUrl(this.http, this.background).then(url => {
+            this.setBackground(url);
+        }, () => {
+            this.renderer.removeClass(this.element.nativeElement, loadingClass);
+            this.renderer.addClass(this.element.nativeElement, defaultClass);
+        });
+    }
+    setBackground(url) {
+        this.renderer.removeClass(this.element.nativeElement, loadingClass);
+        this.renderer.setStyle(this.element.nativeElement, "background-image", `url('${url}')`);
+        if (!this.backgroundSize)
+            return;
+        this.renderer.setStyle(this.element.nativeElement, "background-size", this.backgroundSize);
+    }
+}
+BackgroundDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BackgroundDirective, deps: [{ token: i1.HttpClient }, { token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i2.UniversalService }], target: i0.ɵɵFactoryTarget.Directive });
+BackgroundDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: BackgroundDirective, selector: "[background]", inputs: { background: "background", backgroundSize: "backgroundSize" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: BackgroundDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[background]"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i2.UniversalService }]; }, propDecorators: { background: [{
+                type: Input
+            }], backgroundSize: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/directives/dynamic-table-template.directive.mjs

@@ -0,0 +1,20 @@
+import { Directive, Input, TemplateRef } from "@angular/core";
+import * as i0 from "@angular/core";
+export class DynamicTableTemplateDirective {
+    constructor(ref) {
+        this.ref = ref;
+    }
+}
+DynamicTableTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicTableTemplateDirective, deps: [{ token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+DynamicTableTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: DynamicTableTemplateDirective, selector: "ng-template[column]", inputs: { column: "column", pure: "pure" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: DynamicTableTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "ng-template[column]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }]; }, propDecorators: { column: [{
+                type: Input
+            }], pure: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy10YWJsZS10ZW1wbGF0ZS5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbmd4LXV0aWxzL2RpcmVjdGl2ZXMvZHluYW1pYy10YWJsZS10ZW1wbGF0ZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFDLFNBQVMsRUFBRSxLQUFLLEVBQUUsV0FBVyxFQUFDLE1BQU0sZUFBZSxDQUFDOztBQU81RCxNQUFNLE9BQU8sNkJBQTZCO0lBS3RDLFlBQW1CLEdBQXFCO1FBQXJCLFFBQUcsR0FBSCxHQUFHLENBQWtCO0lBQ3hDLENBQUM7OzBIQU5RLDZCQUE2Qjs4R0FBN0IsNkJBQTZCOzJGQUE3Qiw2QkFBNkI7a0JBSnpDLFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHFCQUFxQjtpQkFDbEM7a0dBSVksTUFBTTtzQkFBZCxLQUFLO2dCQUNHLElBQUk7c0JBQVosS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBJbnB1dCwgVGVtcGxhdGVSZWZ9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7SVRhYmxlVGVtcGxhdGV9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6IFwibmctdGVtcGxhdGVbY29sdW1uXVwiXHJcbn0pXHJcblxyXG5leHBvcnQgY2xhc3MgRHluYW1pY1RhYmxlVGVtcGxhdGVEaXJlY3RpdmUgaW1wbGVtZW50cyBJVGFibGVUZW1wbGF0ZSB7XHJcblxyXG4gICAgQElucHV0KCkgY29sdW1uOiBzdHJpbmcgfCBzdHJpbmdbXTtcclxuICAgIEBJbnB1dCgpIHB1cmU6IGJvb2xlYW47XHJcblxyXG4gICAgY29uc3RydWN0b3IocHVibGljIHJlZjogVGVtcGxhdGVSZWY8YW55Pikge1xyXG4gICAgfVxyXG59XHJcbiJdfQ==

package/esm2020/ngx-utils/directives/global-template.directive.mjs

@@ -0,0 +1,30 @@
+import { Directive, Inject, Input, TemplateRef } from "@angular/core";
+import { GLOBAL_TEMPLATES } from "../common-types";
+import * as i0 from "@angular/core";
+export class GlobalTemplateDirective {
+    constructor(globalTemplates, template) {
+        this.globalTemplates = globalTemplates;
+        this.template = template;
+    }
+    ngOnInit() {
+        this.globalTemplates.add(this.id, this.template);
+    }
+    ngOnDestroy() {
+        this.globalTemplates.remove(this.id);
+    }
+}
+GlobalTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: GlobalTemplateDirective, deps: [{ token: GLOBAL_TEMPLATES }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+GlobalTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: GlobalTemplateDirective, selector: "[globalTemplate]", inputs: { id: ["globalTemplate", "id"] }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: GlobalTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[globalTemplate]"
+                }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [GLOBAL_TEMPLATES]
+                }] }, { type: i0.TemplateRef }]; }, propDecorators: { id: [{
+                type: Input,
+                args: ["globalTemplate"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2xvYmFsLXRlbXBsYXRlLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9uZ3gtdXRpbHMvZGlyZWN0aXZlcy9nbG9iYWwtdGVtcGxhdGUuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQUUsTUFBTSxFQUFFLEtBQUssRUFBcUIsV0FBVyxFQUFDLE1BQU0sZUFBZSxDQUFDO0FBQ3ZGLE9BQU8sRUFBQyxnQkFBZ0IsRUFBbUIsTUFBTSxpQkFBaUIsQ0FBQzs7QUFLbkUsTUFBTSxPQUFPLHVCQUF1QjtJQUloQyxZQUErQyxlQUFpQyxFQUMzRCxRQUEwQjtRQURBLG9CQUFlLEdBQWYsZUFBZSxDQUFrQjtRQUMzRCxhQUFRLEdBQVIsUUFBUSxDQUFrQjtJQUUvQyxDQUFDO0lBRUQsUUFBUTtRQUNKLElBQUksQ0FBQyxlQUFlLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxFQUFFLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ3JELENBQUM7SUFFRCxXQUFXO1FBQ1AsSUFBSSxDQUFDLGVBQWUsQ0FBQyxNQUFNLENBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDO0lBQ3pDLENBQUM7O29IQWZRLHVCQUF1QixrQkFJWixnQkFBZ0I7d0dBSjNCLHVCQUF1QjsyRkFBdkIsdUJBQXVCO2tCQUhuQyxTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxrQkFBa0I7aUJBQy9COzswQkFLZ0IsTUFBTTsyQkFBQyxnQkFBZ0I7c0VBRlgsRUFBRTtzQkFBMUIsS0FBSzt1QkFBQyxnQkFBZ0IiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0RpcmVjdGl2ZSwgSW5qZWN0LCBJbnB1dCwgT25EZXN0cm95LCBPbkluaXQsIFRlbXBsYXRlUmVmfSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge0dMT0JBTF9URU1QTEFURVMsIElHbG9iYWxUZW1wbGF0ZXN9IGZyb20gXCIuLi9jb21tb24tdHlwZXNcIjtcclxuXHJcbkBEaXJlY3RpdmUoe1xyXG4gICAgc2VsZWN0b3I6IFwiW2dsb2JhbFRlbXBsYXRlXVwiXHJcbn0pXHJcbmV4cG9ydCBjbGFzcyBHbG9iYWxUZW1wbGF0ZURpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcclxuXHJcbiAgICBASW5wdXQoXCJnbG9iYWxUZW1wbGF0ZVwiKSBpZDogc3RyaW5nO1xyXG5cclxuICAgIGNvbnN0cnVjdG9yKEBJbmplY3QoR0xPQkFMX1RFTVBMQVRFUykgcmVhZG9ubHkgZ2xvYmFsVGVtcGxhdGVzOiBJR2xvYmFsVGVtcGxhdGVzLFxyXG4gICAgICAgICAgICAgICAgcmVhZG9ubHkgdGVtcGxhdGU6IFRlbXBsYXRlUmVmPGFueT4pIHtcclxuXHJcbiAgICB9XHJcblxyXG4gICAgbmdPbkluaXQoKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5nbG9iYWxUZW1wbGF0ZXMuYWRkKHRoaXMuaWQsIHRoaXMudGVtcGxhdGUpO1xyXG4gICAgfVxyXG5cclxuICAgIG5nT25EZXN0cm95KCk6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuZ2xvYmFsVGVtcGxhdGVzLnJlbW92ZSh0aGlzLmlkKTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/directives/icon.directive.mjs

@@ -0,0 +1,67 @@
+import { Directive, ElementRef, EventEmitter, HostBinding, HostListener, Inject, Input, Output, Renderer2 } from "@angular/core";
+import { ICON_SERVICE } from "../common-types";
+import * as i0 from "@angular/core";
+export class IconDirective {
+    constructor(element, renderer, icons) {
+        this.element = element;
+        this.renderer = renderer;
+        this.icons = icons;
+        this.renderer.addClass(this.element.nativeElement, "svg-icon");
+        this.activeChange = new EventEmitter();
+    }
+    get isActive() {
+        return this.active;
+    }
+    ngOnInit() {
+        this.iconsLoaded = this.icons.iconsLoaded.subscribe(() => this.changeIcon());
+    }
+    ngOnDestroy() {
+        if (this.iconsLoaded)
+            this.iconsLoaded.unsubscribe();
+    }
+    ngOnChanges(changes) {
+        if (changes.icon) {
+            this.renderer.removeClass(this.element.nativeElement, `svg-icon-${changes.icon.previousValue}`);
+            this.renderer.addClass(this.element.nativeElement, `svg-icon-${changes.icon.currentValue}`);
+        }
+        this.changeIcon();
+    }
+    click() {
+        this.active = !this.active;
+        this.activeChange.emit(this.active);
+        this.changeIcon();
+    }
+    changeIcon() {
+        this.icons.getIcon(this.icon, this.activeIcon || `${this.icon}-active`, this.active).then(icon => {
+            if (this.icons.isDisabled)
+                return;
+            this.element.nativeElement.innerHTML = icon;
+        });
+    }
+}
+IconDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: IconDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: ICON_SERVICE }], target: i0.ɵɵFactoryTarget.Directive });
+IconDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: IconDirective, selector: "[icon]", inputs: { icon: "icon", activeIcon: "activeIcon", active: "active" }, outputs: { activeChange: "activeChange" }, host: { listeners: { "click": "click()" }, properties: { "class.active": "this.isActive" } }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: IconDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[icon]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [ICON_SERVICE]
+                }] }]; }, propDecorators: { icon: [{
+                type: Input
+            }], activeIcon: [{
+                type: Input
+            }], active: [{
+                type: Input
+            }], activeChange: [{
+                type: Output
+            }], isActive: [{
+                type: HostBinding,
+                args: ["class.active"]
+            }], click: [{
+                type: HostListener,
+                args: ["click"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaWNvbi5kaXJlY3RpdmUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvbmd4LXV0aWxzL2RpcmVjdGl2ZXMvaWNvbi5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNILFNBQVMsRUFDVCxVQUFVLEVBQ1YsWUFBWSxFQUNaLFdBQVcsRUFDWCxZQUFZLEVBQ1osTUFBTSxFQUNOLEtBQUssRUFJTCxNQUFNLEVBQ04sU0FBUyxFQUVaLE1BQU0sZUFBZSxDQUFDO0FBRXZCLE9BQU8sRUFBQyxZQUFZLEVBQWUsTUFBTSxpQkFBaUIsQ0FBQzs7QUFLM0QsTUFBTSxPQUFPLGFBQWE7SUFjdEIsWUFBb0IsT0FBbUIsRUFBVSxRQUFtQixFQUFnQyxLQUFtQjtRQUFuRyxZQUFPLEdBQVAsT0FBTyxDQUFZO1FBQVUsYUFBUSxHQUFSLFFBQVEsQ0FBVztRQUFnQyxVQUFLLEdBQUwsS0FBSyxDQUFjO1FBQ25ILElBQUksQ0FBQyxRQUFRLENBQUMsUUFBUSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQy9ELElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxZQUFZLEVBQVcsQ0FBQztJQUNwRCxDQUFDO0lBVkQsSUFDSSxRQUFRO1FBQ1IsT0FBTyxJQUFJLENBQUMsTUFBTSxDQUFDO0lBQ3ZCLENBQUM7SUFTRCxRQUFRO1FBQ0osSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLFdBQVcsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDakYsQ0FBQztJQUVELFdBQVc7UUFDUCxJQUFJLElBQUksQ0FBQyxXQUFXO1lBQ2hCLElBQUksQ0FBQyxXQUFXLENBQUMsV0FBVyxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVELFdBQVcsQ0FBQyxPQUFzQjtRQUM5QixJQUFJLE9BQU8sQ0FBQyxJQUFJLEVBQUU7WUFDZCxJQUFJLENBQUMsUUFBUSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxZQUFZLE9BQU8sQ0FBQyxJQUFJLENBQUMsYUFBYSxFQUFFLENBQUMsQ0FBQztZQUNoRyxJQUFJLENBQUMsUUFBUSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLGFBQWEsRUFBRSxZQUFZLE9BQU8sQ0FBQyxJQUFJLENBQUMsWUFBWSxFQUFFLENBQUMsQ0FBQztTQUMvRjtRQUNELElBQUksQ0FBQyxVQUFVLEVBQUUsQ0FBQztJQUN0QixDQUFDO0lBR0QsS0FBSztRQUNELElBQUksQ0FBQyxNQUFNLEdBQUcsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO1FBQzNCLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNwQyxJQUFJLENBQUMsVUFBVSxFQUFFLENBQUM7SUFDdEIsQ0FBQztJQUVPLFVBQVU7UUFDZCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxVQUFVLElBQUksR0FBRyxJQUFJLENBQUMsSUFBSSxTQUFTLEVBQUUsSUFBSSxDQUFDLE1BQU0sQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsRUFBRTtZQUM3RixJQUFJLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVTtnQkFBRSxPQUFPO1lBQ2xDLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDaEQsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDOzswR0FoRFEsYUFBYSxxRUFjd0QsWUFBWTs4RkFkakYsYUFBYTsyRkFBYixhQUFhO2tCQUh6QixTQUFTO21CQUFDO29CQUNQLFFBQVEsRUFBRSxRQUFRO2lCQUNyQjs7MEJBZTBFLE1BQU07MkJBQUMsWUFBWTs0Q0FaakYsSUFBSTtzQkFBWixLQUFLO2dCQUNHLFVBQVU7c0JBQWxCLEtBQUs7Z0JBQ0csTUFBTTtzQkFBZCxLQUFLO2dCQUNJLFlBQVk7c0JBQXJCLE1BQU07Z0JBR0gsUUFBUTtzQkFEWCxXQUFXO3VCQUFDLGNBQWM7Z0JBOEIzQixLQUFLO3NCQURKLFlBQVk7dUJBQUMsT0FBTyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XHJcbiAgICBEaXJlY3RpdmUsXHJcbiAgICBFbGVtZW50UmVmLFxyXG4gICAgRXZlbnRFbWl0dGVyLFxyXG4gICAgSG9zdEJpbmRpbmcsXHJcbiAgICBIb3N0TGlzdGVuZXIsXHJcbiAgICBJbmplY3QsXHJcbiAgICBJbnB1dCxcclxuICAgIE9uQ2hhbmdlcyxcclxuICAgIE9uRGVzdHJveSxcclxuICAgIE9uSW5pdCxcclxuICAgIE91dHB1dCxcclxuICAgIFJlbmRlcmVyMixcclxuICAgIFNpbXBsZUNoYW5nZXNcclxufSBmcm9tIFwiQGFuZ3VsYXIvY29yZVwiO1xyXG5pbXBvcnQge1N1YnNjcmlwdGlvbn0gZnJvbSBcInJ4anNcIjtcclxuaW1wb3J0IHtJQ09OX1NFUlZJQ0UsIElJY29uU2VydmljZX0gZnJvbSBcIi4uL2NvbW1vbi10eXBlc1wiO1xyXG5cclxuQERpcmVjdGl2ZSh7XHJcbiAgICBzZWxlY3RvcjogXCJbaWNvbl1cIlxyXG59KVxyXG5leHBvcnQgY2xhc3MgSWNvbkRpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uQ2hhbmdlcywgT25Jbml0LCBPbkRlc3Ryb3kge1xyXG5cclxuICAgIEBJbnB1dCgpIGljb246IHN0cmluZztcclxuICAgIEBJbnB1dCgpIGFjdGl2ZUljb246IHN0cmluZztcclxuICAgIEBJbnB1dCgpIGFjdGl2ZTogYm9vbGVhbjtcclxuICAgIEBPdXRwdXQoKSBhY3RpdmVDaGFuZ2U6IEV2ZW50RW1pdHRlcjxib29sZWFuPjtcclxuXHJcbiAgICBASG9zdEJpbmRpbmcoXCJjbGFzcy5hY3RpdmVcIilcclxuICAgIGdldCBpc0FjdGl2ZSgpIHtcclxuICAgICAgICByZXR1cm4gdGhpcy5hY3RpdmU7XHJcbiAgICB9XHJcblxyXG4gICAgcHJvdGVjdGVkIGljb25zTG9hZGVkOiBTdWJzY3JpcHRpb247XHJcblxyXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBlbGVtZW50OiBFbGVtZW50UmVmLCBwcml2YXRlIHJlbmRlcmVyOiBSZW5kZXJlcjIsIEBJbmplY3QoSUNPTl9TRVJWSUNFKSBwcml2YXRlIGljb25zOiBJSWNvblNlcnZpY2UpIHtcclxuICAgICAgICB0aGlzLnJlbmRlcmVyLmFkZENsYXNzKHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LCBcInN2Zy1pY29uXCIpO1xyXG4gICAgICAgIHRoaXMuYWN0aXZlQ2hhbmdlID0gbmV3IEV2ZW50RW1pdHRlcjxib29sZWFuPigpO1xyXG4gICAgfVxyXG5cclxuICAgIG5nT25Jbml0KCk6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuaWNvbnNMb2FkZWQgPSB0aGlzLmljb25zLmljb25zTG9hZGVkLnN1YnNjcmliZSgoKSA9PiB0aGlzLmNoYW5nZUljb24oKSk7XHJcbiAgICB9XHJcblxyXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XHJcbiAgICAgICAgaWYgKHRoaXMuaWNvbnNMb2FkZWQpXHJcbiAgICAgICAgICAgIHRoaXMuaWNvbnNMb2FkZWQudW5zdWJzY3JpYmUoKTtcclxuICAgIH1cclxuXHJcbiAgICBuZ09uQ2hhbmdlcyhjaGFuZ2VzOiBTaW1wbGVDaGFuZ2VzKTogdm9pZCB7XHJcbiAgICAgICAgaWYgKGNoYW5nZXMuaWNvbikge1xyXG4gICAgICAgICAgICB0aGlzLnJlbmRlcmVyLnJlbW92ZUNsYXNzKHRoaXMuZWxlbWVudC5uYXRpdmVFbGVtZW50LCBgc3ZnLWljb24tJHtjaGFuZ2VzLmljb24ucHJldmlvdXNWYWx1ZX1gKTtcclxuICAgICAgICAgICAgdGhpcy5yZW5kZXJlci5hZGRDbGFzcyh0aGlzLmVsZW1lbnQubmF0aXZlRWxlbWVudCwgYHN2Zy1pY29uLSR7Y2hhbmdlcy5pY29uLmN1cnJlbnRWYWx1ZX1gKTtcclxuICAgICAgICB9XHJcbiAgICAgICAgdGhpcy5jaGFuZ2VJY29uKCk7XHJcbiAgICB9XHJcblxyXG4gICAgQEhvc3RMaXN0ZW5lcihcImNsaWNrXCIpXHJcbiAgICBjbGljaygpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLmFjdGl2ZSA9ICF0aGlzLmFjdGl2ZTtcclxuICAgICAgICB0aGlzLmFjdGl2ZUNoYW5nZS5lbWl0KHRoaXMuYWN0aXZlKTtcclxuICAgICAgICB0aGlzLmNoYW5nZUljb24oKTtcclxuICAgIH1cclxuXHJcbiAgICBwcml2YXRlIGNoYW5nZUljb24oKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5pY29ucy5nZXRJY29uKHRoaXMuaWNvbiwgdGhpcy5hY3RpdmVJY29uIHx8IGAke3RoaXMuaWNvbn0tYWN0aXZlYCwgdGhpcy5hY3RpdmUpLnRoZW4oaWNvbiA9PiB7XHJcbiAgICAgICAgICAgIGlmICh0aGlzLmljb25zLmlzRGlzYWJsZWQpIHJldHVybjtcclxuICAgICAgICAgICAgdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQuaW5uZXJIVE1MID0gaWNvbjtcclxuICAgICAgICB9KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/directives/ngx-template-outlet.directive.mjs

@@ -0,0 +1,90 @@
+import { Directive, Input, TemplateRef, ViewContainerRef } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class NgxTemplateOutletDirective {
+    constructor(_viewContainerRef) {
+        this._viewContainerRef = _viewContainerRef;
+    }
+    static hasContextShapeChanged(ctxChange) {
+        const prevCtxKeys = Object.keys(ctxChange.previousValue || {});
+        const currCtxKeys = Object.keys(ctxChange.currentValue || {});
+        if (prevCtxKeys.length === currCtxKeys.length) {
+            for (const propName of currCtxKeys) {
+                if (prevCtxKeys.indexOf(propName) === -1) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        else {
+            return true;
+        }
+    }
+    ngOnChanges(changes) {
+        const recreateView = this.shouldRecreateView(changes);
+        if (recreateView) {
+            if (this.viewRef)
+                this._viewContainerRef.remove(this._viewContainerRef.indexOf(this.viewRef));
+            if (this.ngxTemplateOutlet)
+                this.viewRef = this._viewContainerRef.createEmbeddedView(this.ngxTemplateOutlet, {});
+        }
+        this.ngDoCheck();
+    }
+    ngDoCheck() {
+        if (!this.viewRef)
+            return;
+        const context = this.viewRef.context;
+        this.updateExistingContext(this.context, context);
+        this.updateExistingContext(this.additionalContext, context);
+        context.$implicit = context;
+    }
+    shouldRecreateView(changes) {
+        const ctxChange = changes["context"];
+        const aCtxChange = changes["additionalContext"];
+        return !!changes["ngxTemplateOutlet"]
+            || (ctxChange && NgxTemplateOutletDirective.hasContextShapeChanged(ctxChange))
+            || (aCtxChange && NgxTemplateOutletDirective.hasContextShapeChanged(aCtxChange));
+    }
+    updateExistingContext(ctx, context) {
+        if (!ctx)
+            return;
+        let ctxProto = Object.getPrototypeOf(ctx);
+        if (ctxProto == Object.prototype) {
+            ctxProto = ctx;
+        }
+        const props = Object.getOwnPropertyNames(ctxProto);
+        for (const propName of props) {
+            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);
+            // Copy if its a getter and it is not $implicit
+            if (desc.get && propName !== "$implicit") {
+                Object.defineProperty(context, propName, desc);
+                continue;
+            }
+            const func = ObjectUtils.isFunction(desc.value) ? desc.value.bind(ctx) : null;
+            if (func && func !== ctxProto.constructor) {
+                context[propName] = func;
+            }
+        }
+        for (const propName of Object.keys(ctx)) {
+            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);
+            if (desc && desc.get && !desc.set)
+                continue;
+            context[propName] = ctx[propName];
+        }
+    }
+}
+NgxTemplateOutletDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxTemplateOutletDirective, deps: [{ token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+NgxTemplateOutletDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: NgxTemplateOutletDirective, selector: "[ngxTemplateOutlet]", inputs: { context: "context", additionalContext: "additionalContext", ngxTemplateOutlet: "ngxTemplateOutlet" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: NgxTemplateOutletDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[ngxTemplateOutlet]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ViewContainerRef }]; }, propDecorators: { context: [{
+                type: Input
+            }], additionalContext: [{
+                type: Input
+            }], ngxTemplateOutlet: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-template-outlet.directive.js","sourceRoot":"","sources":["../../../../src/ngx-utils/directives/ngx-template-outlet.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\r\n    Directive, DoCheck,\r\n    EmbeddedViewRef,\r\n    Input,\r\n    OnChanges,\r\n    SimpleChange,\r\n    SimpleChanges,\r\n    TemplateRef,\r\n    ViewContainerRef\r\n} from \"@angular/core\";\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\n\r\n@Directive({\r\n    selector: \"[ngxTemplateOutlet]\"\r\n})\r\nexport class NgxTemplateOutletDirective implements OnChanges, DoCheck {\r\n\r\n    private viewRef: EmbeddedViewRef<any>;\r\n\r\n    @Input() public context: Object;\r\n    @Input() public additionalContext: Object;\r\n    @Input() public ngxTemplateOutlet: TemplateRef<any>;\r\n\r\n    private static hasContextShapeChanged(ctxChange: SimpleChange): boolean {\r\n        const prevCtxKeys = Object.keys(ctxChange.previousValue || {});\r\n        const currCtxKeys = Object.keys(ctxChange.currentValue || {});\r\n\r\n        if (prevCtxKeys.length === currCtxKeys.length) {\r\n            for (const propName of currCtxKeys) {\r\n                if (prevCtxKeys.indexOf(propName) === -1) {\r\n                    return true;\r\n                }\r\n            }\r\n            return false;\r\n        } else {\r\n            return true;\r\n        }\r\n    }\r\n\r\n    constructor(private _viewContainerRef: ViewContainerRef) {}\r\n\r\n    ngOnChanges(changes: SimpleChanges) {\r\n        const recreateView = this.shouldRecreateView(changes);\r\n        if (recreateView) {\r\n            if (this.viewRef)\r\n                this._viewContainerRef.remove(this._viewContainerRef.indexOf(this.viewRef));\r\n            if (this.ngxTemplateOutlet)\r\n                this.viewRef = this._viewContainerRef.createEmbeddedView(this.ngxTemplateOutlet, {});\r\n        }\r\n        this.ngDoCheck();\r\n    }\r\n\r\n    ngDoCheck(): void {\r\n        if (!this.viewRef) return;\r\n        const context = this.viewRef.context;\r\n        this.updateExistingContext(this.context, context);\r\n        this.updateExistingContext(this.additionalContext, context);\r\n        context.$implicit = context;\r\n    }\r\n\r\n    private shouldRecreateView(changes: SimpleChanges): boolean {\r\n        const ctxChange = changes[\"context\"];\r\n        const aCtxChange = changes[\"additionalContext\"];\r\n        return !!changes[\"ngxTemplateOutlet\"]\r\n            || (ctxChange && NgxTemplateOutletDirective.hasContextShapeChanged(ctxChange))\r\n            || (aCtxChange && NgxTemplateOutletDirective.hasContextShapeChanged(aCtxChange));\r\n    }\r\n\r\n    private updateExistingContext(ctx: any, context: any): void {\r\n        if (!ctx) return;\r\n        let ctxProto = Object.getPrototypeOf(ctx);\r\n        if (ctxProto == Object.prototype) {\r\n            ctxProto = ctx;\r\n        }\r\n        const props = Object.getOwnPropertyNames(ctxProto);\r\n        for (const propName of props) {\r\n            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);\r\n            // Copy if its a getter and it is not $implicit\r\n            if (desc.get && propName !== \"$implicit\") {\r\n                Object.defineProperty(context, propName, desc);\r\n                continue;\r\n            }\r\n            const func: Function = ObjectUtils.isFunction(desc.value) ? desc.value.bind(ctx) : null;\r\n            if (func && func !== ctxProto.constructor) {\r\n                context[propName] = func;\r\n            }\r\n        }\r\n        for (const propName of Object.keys(ctx)) {\r\n\r\n            const desc = Object.getOwnPropertyDescriptor(ctxProto, propName);\r\n            if (desc && desc.get && !desc.set) continue;\r\n            context[propName] = ctx[propName];\r\n        }\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/directives/pagination-item.directive.mjs

@@ -0,0 +1,33 @@
+import { Directive, TemplateRef, ViewContainerRef } from "@angular/core";
+import { PaginationDirective } from "./pagination.directive";
+import * as i0 from "@angular/core";
+import * as i1 from "./pagination.directive";
+export class PaginationItemDirective {
+    constructor(pagination, viewContainer, templateRef) {
+        this.pagination = pagination;
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+    }
+    ngOnInit() {
+        this.onRefresh = this.pagination.onRefresh.subscribe(() => this.renderView());
+    }
+    ngOnDestroy() {
+        this.onRefresh.unsubscribe();
+    }
+    renderView() {
+        this.viewContainer.clear();
+        this.pagination.items.forEach((item) => {
+            item.$implicit = item;
+            this.viewContainer.createEmbeddedView(this.templateRef, item);
+        });
+    }
+}
+PaginationItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationItemDirective, deps: [{ token: i1.PaginationDirective }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+PaginationItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: PaginationItemDirective, selector: "[paginationItem]", ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[paginationItem]"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.PaginationDirective }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnaW5hdGlvbi1pdGVtLmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9uZ3gtdXRpbHMvZGlyZWN0aXZlcy9wYWdpbmF0aW9uLWl0ZW0uZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxTQUFTLEVBQXFCLFdBQVcsRUFBRSxnQkFBZ0IsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUUxRixPQUFPLEVBQUMsbUJBQW1CLEVBQUMsTUFBTSx3QkFBd0IsQ0FBQzs7O0FBSzNELE1BQU0sT0FBTyx1QkFBdUI7SUFJaEMsWUFBb0IsVUFBK0IsRUFBVSxhQUErQixFQUFVLFdBQTZCO1FBQS9HLGVBQVUsR0FBVixVQUFVLENBQXFCO1FBQVUsa0JBQWEsR0FBYixhQUFhLENBQWtCO1FBQVUsZ0JBQVcsR0FBWCxXQUFXLENBQWtCO0lBRW5JLENBQUM7SUFFRCxRQUFRO1FBQ0osSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsR0FBRyxFQUFFLENBQUMsSUFBSSxDQUFDLFVBQVUsRUFBRSxDQUFDLENBQUM7SUFDbEYsQ0FBQztJQUVELFdBQVc7UUFDUCxJQUFJLENBQUMsU0FBUyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ2pDLENBQUM7SUFFTyxVQUFVO1FBQ2QsSUFBSSxDQUFDLGFBQWEsQ0FBQyxLQUFLLEVBQUUsQ0FBQztRQUMzQixJQUFJLENBQUMsVUFBVSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFTLEVBQUUsRUFBRTtZQUN4QyxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQztZQUN0QixJQUFJLENBQUMsYUFBYSxDQUFDLGtCQUFrQixDQUFDLElBQUksQ0FBQyxXQUFXLEVBQUUsSUFBSSxDQUFDLENBQUM7UUFDbEUsQ0FBQyxDQUFDLENBQUM7SUFDUCxDQUFDOztvSEF0QlEsdUJBQXVCO3dHQUF2Qix1QkFBdUI7MkZBQXZCLHVCQUF1QjtrQkFIbkMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsa0JBQWtCO2lCQUMvQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBPbkRlc3Ryb3ksIE9uSW5pdCwgVGVtcGxhdGVSZWYsIFZpZXdDb250YWluZXJSZWZ9IGZyb20gXCJAYW5ndWxhci9jb3JlXCI7XHJcbmltcG9ydCB7U3Vic2NyaXB0aW9ufSBmcm9tIFwicnhqc1wiO1xyXG5pbXBvcnQge1BhZ2luYXRpb25EaXJlY3RpdmV9IGZyb20gXCIuL3BhZ2luYXRpb24uZGlyZWN0aXZlXCI7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICAgIHNlbGVjdG9yOiBcIltwYWdpbmF0aW9uSXRlbV1cIlxyXG59KVxyXG5leHBvcnQgY2xhc3MgUGFnaW5hdGlvbkl0ZW1EaXJlY3RpdmUgaW1wbGVtZW50cyBPbkluaXQsIE9uRGVzdHJveSB7XHJcblxyXG4gICAgcHJpdmF0ZSBvblJlZnJlc2g6IFN1YnNjcmlwdGlvbjtcclxuXHJcbiAgICBjb25zdHJ1Y3Rvcihwcml2YXRlIHBhZ2luYXRpb246IFBhZ2luYXRpb25EaXJlY3RpdmUsIHByaXZhdGUgdmlld0NvbnRhaW5lcjogVmlld0NvbnRhaW5lclJlZiwgcHJpdmF0ZSB0ZW1wbGF0ZVJlZjogVGVtcGxhdGVSZWY8YW55Pikge1xyXG5cclxuICAgIH1cclxuXHJcbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLm9uUmVmcmVzaCA9IHRoaXMucGFnaW5hdGlvbi5vblJlZnJlc2guc3Vic2NyaWJlKCgpID0+IHRoaXMucmVuZGVyVmlldygpKTtcclxuICAgIH1cclxuXHJcbiAgICBuZ09uRGVzdHJveSgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLm9uUmVmcmVzaC51bnN1YnNjcmliZSgpO1xyXG4gICAgfVxyXG5cclxuICAgIHByaXZhdGUgcmVuZGVyVmlldygpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLnZpZXdDb250YWluZXIuY2xlYXIoKTtcclxuICAgICAgICB0aGlzLnBhZ2luYXRpb24uaXRlbXMuZm9yRWFjaCgoaXRlbTogYW55KSA9PiB7XHJcbiAgICAgICAgICAgIGl0ZW0uJGltcGxpY2l0ID0gaXRlbTtcclxuICAgICAgICAgICAgdGhpcy52aWV3Q29udGFpbmVyLmNyZWF0ZUVtYmVkZGVkVmlldyh0aGlzLnRlbXBsYXRlUmVmLCBpdGVtKTtcclxuICAgICAgICB9KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/directives/pagination.directive.mjs

@@ -0,0 +1,83 @@
+import { Directive, EventEmitter, Input, NgZone, Output } from "@angular/core";
+import { PaginationItemContext } from "../common-types";
+import { TimerUtils } from "../utils/timer.utils";
+import * as i0 from "@angular/core";
+export class PaginationDirective {
+    constructor(zone) {
+        this.zone = zone;
+        this.pageChange = new EventEmitter();
+        this.onRefresh = new EventEmitter();
+        this.updateTimer = TimerUtils.createTimeout(() => this.loadData(), this.updateTime);
+    }
+    get total() {
+        return this.data ? this.data.total : 0;
+    }
+    get items() {
+        return this.data ? this.data.items : [];
+    }
+    ngOnChanges(changes) {
+        if (!changes.loader && !changes.itemsPerPage && !changes.page)
+            return;
+        this.page = isNaN(this.page) || this.page < 1 ? 1 : this.page;
+        this.itemsPerPage = isNaN(this.itemsPerPage) || this.itemsPerPage < 1 ? 20 : this.itemsPerPage;
+        this.updateTimer.time = isNaN(this.updateTime) || this.updateTime < 0 ? 100 : this.updateTime;
+        this.waitFor = this.waitFor || Promise.resolve(true);
+        this.refresh();
+    }
+    refresh() {
+        this.waitFor.then(() => {
+            this.updateTimer.run();
+        });
+    }
+    paginate(page) {
+        this.page = page;
+        this.pageChange.emit(page);
+        this.refresh();
+    }
+    loadData() {
+        if (!this.loader)
+            return;
+        this.loader(this.page, this.itemsPerPage).then(data => {
+            this.maxPage = !data || data.total <= 0 ? 1 : Math.floor((data.total - 1) / this.itemsPerPage) + 1;
+            this.data = data;
+            const baseIndex = (this.page - 1) * this.itemsPerPage;
+            const items = (data.items || []);
+            data.items = items.map((item, index) => {
+                const ix = baseIndex + index;
+                return item instanceof PaginationItemContext
+                    ? item
+                    : new PaginationItemContext(item, items, items.length, index, ix);
+            });
+            if (this.page > this.maxPage) {
+                this.paginate(this.maxPage);
+                return;
+            }
+            this.zone.run(() => this.onRefresh.emit(this));
+        });
+    }
+}
+PaginationDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationDirective, deps: [{ token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive });
+PaginationDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: PaginationDirective, selector: "[pagination]", inputs: { loader: ["pagination", "loader"], page: "page", itemsPerPage: "itemsPerPage", updateTime: "updateTime", waitFor: "waitFor" }, outputs: { pageChange: "pageChange", onRefresh: "onRefresh" }, exportAs: ["pagination"], usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: PaginationDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[pagination]",
+                    exportAs: "pagination"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.NgZone }]; }, propDecorators: { loader: [{
+                type: Input,
+                args: ["pagination"]
+            }], page: [{
+                type: Input
+            }], itemsPerPage: [{
+                type: Input
+            }], updateTime: [{
+                type: Input
+            }], waitFor: [{
+                type: Input
+            }], pageChange: [{
+                type: Output
+            }], onRefresh: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pagination.directive.js","sourceRoot":"","sources":["../../../../src/ngx-utils/directives/pagination.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, EventEmitter, Input, NgZone, OnChanges, Output, SimpleChanges} from \"@angular/core\";\r\nimport {IPaginationData, ITimer, PaginationDataLoader, PaginationItemContext} from \"../common-types\";\r\nimport {TimerUtils} from \"../utils/timer.utils\";\r\n\r\n@Directive({\r\n    selector: \"[pagination]\",\r\n    exportAs: \"pagination\"\r\n})\r\nexport class PaginationDirective implements OnChanges {\r\n\r\n    get total(): number {\r\n        return this.data ? this.data.total : 0;\r\n    }\r\n\r\n    get items(): any[] {\r\n        return this.data ? this.data.items : [];\r\n    }\r\n\r\n    @Input(\"pagination\") loader: PaginationDataLoader;\r\n    @Input() page: number;\r\n    @Input() itemsPerPage: number;\r\n    @Input() updateTime: number;\r\n    @Input() waitFor: Promise<any>;\r\n\r\n    @Output() pageChange: EventEmitter<number>;\r\n    @Output() onRefresh: EventEmitter<PaginationDirective>;\r\n\r\n    maxPage: number;\r\n\r\n    private data: IPaginationData;\r\n    private updateTimer: ITimer;\r\n\r\n    constructor(private zone: NgZone) {\r\n        this.pageChange = new EventEmitter<number>();\r\n        this.onRefresh = new EventEmitter<PaginationDirective>();\r\n        this.updateTimer = TimerUtils.createTimeout(() => this.loadData(), this.updateTime);\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if (!changes.loader && !changes.itemsPerPage && !changes.page) return;\r\n        this.page = isNaN(this.page) || this.page < 1 ? 1 : this.page;\r\n        this.itemsPerPage = isNaN(this.itemsPerPage) || this.itemsPerPage < 1 ? 20 : this.itemsPerPage;\r\n        this.updateTimer.time = isNaN(this.updateTime) || this.updateTime < 0 ? 100 : this.updateTime;\r\n        this.waitFor = this.waitFor || Promise.resolve(true);\r\n        this.refresh();\r\n    }\r\n\r\n    refresh(): void {\r\n        this.waitFor.then(() => {\r\n            this.updateTimer.run();\r\n        });\r\n    }\r\n\r\n    paginate(page: number): void {\r\n        this.page = page;\r\n        this.pageChange.emit(page);\r\n        this.refresh();\r\n    }\r\n\r\n    private loadData(): void {\r\n        if (!this.loader) return;\r\n        this.loader(this.page, this.itemsPerPage).then(data => {\r\n            this.maxPage = !data || data.total <= 0 ? 1 : Math.floor((data.total - 1) / this.itemsPerPage) + 1;\r\n            this.data = data;\r\n            const baseIndex = (this.page - 1) * this.itemsPerPage;\r\n            const items = (data.items || []);\r\n            data.items = items.map((item, index) => {\r\n                const ix = baseIndex + index;\r\n                return item instanceof PaginationItemContext\r\n                    ? item\r\n                    : new PaginationItemContext(item, items, items.length, index, ix);\r\n            });\r\n            if (this.page > this.maxPage) {\r\n                this.paginate(this.maxPage);\r\n                return;\r\n            }\r\n            this.zone.run(() => this.onRefresh.emit(this));\r\n        });\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/directives/resource-if.directive.mjs

@@ -0,0 +1,50 @@
+import { Directive, ViewContainerRef, TemplateRef, Input } from "@angular/core";
+import { HttpClient } from "@angular/common/http";
+import { ResourceIfContext } from "../common-types";
+import { FileUtils } from "../utils/file.utils";
+import { UniversalService } from "../services/universal.service";
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../services/universal.service";
+export class ResourceIfDirective {
+    constructor(http, viewContainer, templateRef, universal) {
+        this.http = http;
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        this.universal = universal;
+        this.context = new ResourceIfContext();
+    }
+    set resourceIf(resource) {
+        this.resource = resource;
+        this.renderView();
+    }
+    get resourceIf() {
+        return this.resource;
+    }
+    get url() {
+        return this.context.url;
+    }
+    renderView() {
+        this.context = new ResourceIfContext();
+        this.context.resource = this.resource;
+        this.viewContainer.clear();
+        if (this.universal.isBrowser && this.resource) {
+            FileUtils.readDataFromUrl(this.http, this.resource).then(url => {
+                this.context.url = url;
+                this.viewContainer.createEmbeddedView(this.templateRef, this.context);
+            }, console.log);
+        }
+    }
+}
+ResourceIfDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ResourceIfDirective, deps: [{ token: i1.HttpClient }, { token: i0.ViewContainerRef }, { token: i0.TemplateRef }, { token: i2.UniversalService }], target: i0.ɵɵFactoryTarget.Directive });
+ResourceIfDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: ResourceIfDirective, selector: "[resourceIf]", inputs: { resourceIf: "resourceIf" }, exportAs: ["resourceIf"], ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: ResourceIfDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[resourceIf]",
+                    exportAs: "resourceIf"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i0.ViewContainerRef }, { type: i0.TemplateRef }, { type: i2.UniversalService }]; }, propDecorators: { resourceIf: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/directives/sticky-class.directive.mjs

@@ -0,0 +1,34 @@
+import { Directive, ElementRef, Input, Renderer2 } from "@angular/core";
+import { EventsService } from "../services/events.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/events.service";
+export class StickyClassDirective {
+    constructor(events, element, renderer) {
+        this.events = events;
+        this.element = element;
+        this.renderer = renderer;
+    }
+    ngOnInit() {
+        this.stickyUpdated = this.events.stickyUpdated.subscribe(() => {
+            if (this.events.isSticky) {
+                this.renderer.addClass(this.element.nativeElement, this.stickyClass || "sticky-sibling");
+                return;
+            }
+            this.renderer.removeClass(this.element.nativeElement, this.stickyClass || "sticky-sibling");
+        });
+    }
+    ngOnDestroy() {
+        this.stickyUpdated.unsubscribe();
+    }
+}
+StickyClassDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StickyClassDirective, deps: [{ token: i1.EventsService }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive });
+StickyClassDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: StickyClassDirective, selector: "[stickyClass]", inputs: { stickyClass: "stickyClass" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StickyClassDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[stickyClass]"
+                }]
+        }], ctorParameters: function () { return [{ type: i1.EventsService }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { stickyClass: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/ngx-utils/directives/sticky.directive.mjs

@@ -0,0 +1,55 @@
+import { ChangeDetectorRef, Directive, ElementRef, HostBinding, HostListener } from "@angular/core";
+import { TimerUtils } from "../utils/timer.utils";
+import { EventsService } from "../services/events.service";
+import * as i0 from "@angular/core";
+import * as i1 from "../services/events.service";
+export class StickyDirective {
+    constructor(cdr, events, element) {
+        this.cdr = cdr;
+        this.events = events;
+        this.element = element;
+        this.parentElement = this.element.nativeElement.parentElement;
+        this.updateTimer = TimerUtils.createTimeout(() => {
+            this.isUpdating = false;
+            this.cdr.detectChanges();
+            this.events.updateSticky(this.isSticky);
+        }, 10);
+    }
+    ngOnInit() {
+        this.eventForwarded = this.events.eventForwarded.subscribe((e) => {
+            if (e && e.type === "scroll")
+                this.updateSticky();
+        });
+    }
+    ngOnDestroy() {
+        this.eventForwarded.unsubscribe();
+    }
+    updateSticky() {
+        const distanceToTop = this.parentElement.getBoundingClientRect().top;
+        this.isSticky = distanceToTop < 1;
+        this.isUpdating = true;
+        this.cdr.detectChanges();
+        this.updateTimer.run();
+    }
+}
+StickyDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StickyDirective, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.EventsService }, { token: i0.ElementRef }], target: i0.ɵɵFactoryTarget.Directive });
+StickyDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: StickyDirective, selector: "[sticky]", host: { listeners: { "window:resize": "updateSticky()", "window:scroll": "updateSticky()" }, properties: { "class.sticky": "this.isSticky", "class.sticky-update": "this.isUpdating" } }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: StickyDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[sticky]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.EventsService }, { type: i0.ElementRef }]; }, propDecorators: { isSticky: [{
+                type: HostBinding,
+                args: ["class.sticky"]
+            }], isUpdating: [{
+                type: HostBinding,
+                args: ["class.sticky-update"]
+            }], updateSticky: [{
+                type: HostListener,
+                args: ["window:resize"]
+            }, {
+                type: HostListener,
+                args: ["window:scroll"]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RpY2t5LmRpcmVjdGl2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9uZ3gtdXRpbHMvZGlyZWN0aXZlcy9zdGlja3kuZGlyZWN0aXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsVUFBVSxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQW9CLE1BQU0sZUFBZSxDQUFDO0FBR3JILE9BQU8sRUFBQyxVQUFVLEVBQUMsTUFBTSxzQkFBc0IsQ0FBQztBQUNoRCxPQUFPLEVBQUMsYUFBYSxFQUFDLE1BQU0sNEJBQTRCLENBQUM7OztBQUt6RCxNQUFNLE9BQU8sZUFBZTtJQVN4QixZQUFvQixHQUFzQixFQUFVLE1BQXFCLEVBQVUsT0FBbUI7UUFBbEYsUUFBRyxHQUFILEdBQUcsQ0FBbUI7UUFBVSxXQUFNLEdBQU4sTUFBTSxDQUFlO1FBQVUsWUFBTyxHQUFQLE9BQU8sQ0FBWTtRQUNsRyxJQUFJLENBQUMsYUFBYSxHQUFHLElBQUksQ0FBQyxPQUFPLENBQUMsYUFBYSxDQUFDLGFBQWEsQ0FBQztRQUM5RCxJQUFJLENBQUMsV0FBVyxHQUFHLFVBQVUsQ0FBQyxhQUFhLENBQUMsR0FBRyxFQUFFO1lBQzdDLElBQUksQ0FBQyxVQUFVLEdBQUcsS0FBSyxDQUFDO1lBQ3hCLElBQUksQ0FBQyxHQUFHLENBQUMsYUFBYSxFQUFFLENBQUM7WUFDekIsSUFBSSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO1FBQzVDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUNYLENBQUM7SUFFRCxRQUFRO1FBQ0osSUFBSSxDQUFDLGNBQWMsR0FBRyxJQUFJLENBQUMsTUFBTSxDQUFDLGNBQWMsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFRLEVBQUUsRUFBRTtZQUNwRSxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUMsSUFBSSxLQUFLLFFBQVE7Z0JBQUUsSUFBSSxDQUFDLFlBQVksRUFBRSxDQUFDO1FBQ3RELENBQUMsQ0FBQyxDQUFDO0lBQ1AsQ0FBQztJQUVELFdBQVc7UUFDUCxJQUFJLENBQUMsY0FBYyxDQUFDLFdBQVcsRUFBRSxDQUFDO0lBQ3RDLENBQUM7SUFJRCxZQUFZO1FBQ1IsTUFBTSxhQUFhLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxxQkFBcUIsRUFBRSxDQUFDLEdBQUcsQ0FBQztRQUNyRSxJQUFJLENBQUMsUUFBUSxHQUFHLGFBQWEsR0FBRyxDQUFDLENBQUM7UUFDbEMsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7UUFDdkIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxhQUFhLEVBQUUsQ0FBQztRQUN6QixJQUFJLENBQUMsV0FBVyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQzNCLENBQUM7OzRHQXBDUSxlQUFlO2dHQUFmLGVBQWU7MkZBQWYsZUFBZTtrQkFIM0IsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsVUFBVTtpQkFDdkI7NkpBR2dDLFFBQVE7c0JBQXBDLFdBQVc7dUJBQUMsY0FBYztnQkFDUyxVQUFVO3NCQUE3QyxXQUFXO3VCQUFDLHFCQUFxQjtnQkEyQmxDLFlBQVk7c0JBRlgsWUFBWTt1QkFBQyxlQUFlOztzQkFDNUIsWUFBWTt1QkFBQyxlQUFlIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtDaGFuZ2VEZXRlY3RvclJlZiwgRGlyZWN0aXZlLCBFbGVtZW50UmVmLCBIb3N0QmluZGluZywgSG9zdExpc3RlbmVyLCBPbkRlc3Ryb3ksIE9uSW5pdH0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtTdWJzY3JpcHRpb259IGZyb20gXCJyeGpzXCI7XHJcbmltcG9ydCB7SVRpbWVyfSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcbmltcG9ydCB7VGltZXJVdGlsc30gZnJvbSBcIi4uL3V0aWxzL3RpbWVyLnV0aWxzXCI7XHJcbmltcG9ydCB7RXZlbnRzU2VydmljZX0gZnJvbSBcIi4uL3NlcnZpY2VzL2V2ZW50cy5zZXJ2aWNlXCI7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICAgIHNlbGVjdG9yOiBcIltzdGlja3ldXCJcclxufSlcclxuZXhwb3J0IGNsYXNzIFN0aWNreURpcmVjdGl2ZSBpbXBsZW1lbnRzIE9uSW5pdCwgT25EZXN0cm95IHtcclxuXHJcbiAgICBASG9zdEJpbmRpbmcoXCJjbGFzcy5zdGlja3lcIikgaXNTdGlja3k6IGJvb2xlYW47XHJcbiAgICBASG9zdEJpbmRpbmcoXCJjbGFzcy5zdGlja3ktdXBkYXRlXCIpIGlzVXBkYXRpbmc6IGJvb2xlYW47XHJcbiAgICBwYXJlbnRFbGVtZW50OiBIVE1MRWxlbWVudDtcclxuXHJcbiAgICBwcml2YXRlIHVwZGF0ZVRpbWVyOiBJVGltZXI7XHJcbiAgICBwcml2YXRlIGV2ZW50Rm9yd2FyZGVkOiBTdWJzY3JpcHRpb247XHJcblxyXG4gICAgY29uc3RydWN0b3IocHJpdmF0ZSBjZHI6IENoYW5nZURldGVjdG9yUmVmLCBwcml2YXRlIGV2ZW50czogRXZlbnRzU2VydmljZSwgcHJpdmF0ZSBlbGVtZW50OiBFbGVtZW50UmVmKSB7XHJcbiAgICAgICAgdGhpcy5wYXJlbnRFbGVtZW50ID0gdGhpcy5lbGVtZW50Lm5hdGl2ZUVsZW1lbnQucGFyZW50RWxlbWVudDtcclxuICAgICAgICB0aGlzLnVwZGF0ZVRpbWVyID0gVGltZXJVdGlscy5jcmVhdGVUaW1lb3V0KCgpID0+IHtcclxuICAgICAgICAgICAgdGhpcy5pc1VwZGF0aW5nID0gZmFsc2U7XHJcbiAgICAgICAgICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKTtcclxuICAgICAgICAgICAgdGhpcy5ldmVudHMudXBkYXRlU3RpY2t5KHRoaXMuaXNTdGlja3kpO1xyXG4gICAgICAgIH0sIDEwKTtcclxuICAgIH1cclxuXHJcbiAgICBuZ09uSW5pdCgpOiB2b2lkIHtcclxuICAgICAgICB0aGlzLmV2ZW50Rm9yd2FyZGVkID0gdGhpcy5ldmVudHMuZXZlbnRGb3J3YXJkZWQuc3Vic2NyaWJlKChlOiBFdmVudCkgPT4ge1xyXG4gICAgICAgICAgICBpZiAoZSAmJiBlLnR5cGUgPT09IFwic2Nyb2xsXCIpIHRoaXMudXBkYXRlU3RpY2t5KCk7XHJcbiAgICAgICAgfSk7XHJcbiAgICB9XHJcblxyXG4gICAgbmdPbkRlc3Ryb3koKTogdm9pZCB7XHJcbiAgICAgICAgdGhpcy5ldmVudEZvcndhcmRlZC51bnN1YnNjcmliZSgpO1xyXG4gICAgfVxyXG5cclxuICAgIEBIb3N0TGlzdGVuZXIoXCJ3aW5kb3c6cmVzaXplXCIpXHJcbiAgICBASG9zdExpc3RlbmVyKFwid2luZG93OnNjcm9sbFwiKVxyXG4gICAgdXBkYXRlU3RpY2t5KCk6IHZvaWQge1xyXG4gICAgICAgIGNvbnN0IGRpc3RhbmNlVG9Ub3AgPSB0aGlzLnBhcmVudEVsZW1lbnQuZ2V0Qm91bmRpbmdDbGllbnRSZWN0KCkudG9wO1xyXG4gICAgICAgIHRoaXMuaXNTdGlja3kgPSBkaXN0YW5jZVRvVG9wIDwgMTtcclxuICAgICAgICB0aGlzLmlzVXBkYXRpbmcgPSB0cnVlO1xyXG4gICAgICAgIHRoaXMuY2RyLmRldGVjdENoYW5nZXMoKTtcclxuICAgICAgICB0aGlzLnVwZGF0ZVRpbWVyLnJ1bigpO1xyXG4gICAgfVxyXG59XHJcbiJdfQ==