@stemy/ngx-utils 12.1.1 → 12.1.4

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,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

package/esm2020/ngx-utils/directives/unordered-list-item.directive.mjs

@@ -0,0 +1,77 @@
+import { Directive, ElementRef, Input, Renderer2, ViewContainerRef } from "@angular/core";
+import { ObjectUtils } from "../utils/object.utils";
+import * as i0 from "@angular/core";
+export class UnorderedListItemDirective {
+    constructor(elementRef, renderer, viewContainer) {
+        this.elementRef = elementRef;
+        this.renderer = renderer;
+        this.viewContainer = viewContainer;
+    }
+    get elem() {
+        return this.elementRef.nativeElement;
+    }
+    ngOnChanges(changes) {
+        if (!this.templates || !this.defaultTemplates || !this.item)
+            return;
+        const promise = this.item.value instanceof Promise ? this.item.value : Promise.resolve(this.item.value);
+        promise.then(value => {
+            this.item.value = value;
+            this.path = ObjectUtils.isNullOrUndefined(this.path) ? "" : this.path.toString();
+            this.isArray = ObjectUtils.isArray(this.data);
+            this.isObject = ObjectUtils.isObject(this.data);
+            this.valueIsArray = ObjectUtils.isArray(this.item.value);
+            this.valueIsObject = ObjectUtils.isObject(this.item.value);
+            this.valueType = ObjectUtils.getType(this.item.value);
+            const context = this;
+            const template = this.templates.find(t => t.type == this.type && ObjectUtils.evaluate(t.selector, context)) || this.defaultTemplates[this.type];
+            // Set view
+            this.viewContainer.clear();
+            this.viewContainer.createEmbeddedView(template, context);
+            // Set classes
+            if (this.type !== "item")
+                return;
+            this.item.classList = [];
+            this.isClass("is-array", this.valueIsArray);
+            this.isClass("is-object", this.valueIsObject);
+            this.isClass("is-value", !this.valueIsObject && !this.valueIsArray);
+            this.isClass(`type-${this.valueType}`);
+            this.isClass(`path-${this.path.replace(/\./g, "-")}`);
+            this.isClass(`key-${this.item.key}`);
+        }, reason => {
+            console.log("Can't handle promise rejection", reason);
+        });
+    }
+    isClass(className, value = true) {
+        if (!value)
+            return;
+        this.item.classList.push(className);
+    }
+}
+UnorderedListItemDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListItemDirective, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+UnorderedListItemDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: UnorderedListItemDirective, selector: "[unorderedListItem]", inputs: { item: ["unorderedListItem", "item"], type: "type", data: "data", keyPrefix: "keyPrefix", listStyle: "listStyle", path: "path", level: "level", templates: "templates", defaultTemplates: "defaultTemplates" }, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListItemDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "[unorderedListItem]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i0.ViewContainerRef }]; }, propDecorators: { item: [{
+                type: Input,
+                args: ["unorderedListItem"]
+            }], type: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], keyPrefix: [{
+                type: Input
+            }], listStyle: [{
+                type: Input
+            }], path: [{
+                type: Input
+            }], level: [{
+                type: Input
+            }], templates: [{
+                type: Input
+            }], defaultTemplates: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"unordered-list-item.directive.js","sourceRoot":"","sources":["../../../../src/ngx-utils/directives/unordered-list-item.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {Directive, ElementRef, Input, OnChanges, Renderer2, SimpleChanges, ViewContainerRef} from \"@angular/core\";\r\nimport {UnorderedListStyle, UnorderedListTemplates, UnorederedListTemplate} from \"../common-types\";\r\nimport {ObjectUtils} from \"../utils/object.utils\";\r\nimport {StringUtils} from \"../utils/string.utils\";\r\n\r\n@Directive({\r\n    selector: \"[unorderedListItem]\"\r\n})\r\nexport class UnorderedListItemDirective implements OnChanges {\r\n\r\n    @Input(\"unorderedListItem\") item: any;\r\n    @Input() type: string;\r\n    @Input() data: any;\r\n    @Input() keyPrefix: string;\r\n    @Input() listStyle: UnorderedListStyle;\r\n    @Input() path: string;\r\n    @Input() level: number;\r\n    @Input() templates: UnorederedListTemplate[];\r\n    @Input() defaultTemplates: UnorderedListTemplates;\r\n\r\n    isArray: boolean;\r\n    isObject: boolean;\r\n    valueIsArray: boolean;\r\n    valueIsObject: boolean;\r\n    valueType: string;\r\n\r\n    get elem(): HTMLElement {\r\n        return this.elementRef.nativeElement;\r\n    }\r\n\r\n    constructor(private elementRef: ElementRef, private renderer: Renderer2, private viewContainer: ViewContainerRef) {\r\n\r\n    }\r\n\r\n    ngOnChanges(changes: SimpleChanges): void {\r\n        if (!this.templates || !this.defaultTemplates || !this.item) return;\r\n        const promise = this.item.value instanceof Promise ? this.item.value : Promise.resolve(this.item.value);\r\n        promise.then(value => {\r\n            this.item.value = value;\r\n            this.path = ObjectUtils.isNullOrUndefined(this.path) ? \"\" : this.path.toString();\r\n            this.isArray = ObjectUtils.isArray(this.data);\r\n            this.isObject = ObjectUtils.isObject(this.data);\r\n            this.valueIsArray = ObjectUtils.isArray(this.item.value);\r\n            this.valueIsObject = ObjectUtils.isObject(this.item.value);\r\n            this.valueType = ObjectUtils.getType(this.item.value);\r\n            const context: any = this;\r\n            const template = this.templates.find(t => t.type == this.type && ObjectUtils.evaluate(t.selector, context)) || this.defaultTemplates[this.type];\r\n            // Set view\r\n            this.viewContainer.clear();\r\n            this.viewContainer.createEmbeddedView(template, context);\r\n            // Set classes\r\n            if (this.type !== \"item\") return;\r\n            this.item.classList = [];\r\n            this.isClass(\"is-array\", this.valueIsArray);\r\n            this.isClass(\"is-object\", this.valueIsObject);\r\n            this.isClass(\"is-value\", !this.valueIsObject && !this.valueIsArray);\r\n            this.isClass(`type-${this.valueType}`);\r\n            this.isClass(`path-${this.path.replace(/\\./g, \"-\")}`);\r\n            this.isClass(`key-${this.item.key}`);\r\n        }, reason => {\r\n            console.log(\"Can't handle promise rejection\", reason);\r\n        });\r\n    }\r\n\r\n    private isClass(className: string, value: boolean = true): void {\r\n        if (!value) return;\r\n        this.item.classList.push(className);\r\n    }\r\n}\r\n"]}

package/esm2020/ngx-utils/directives/unordered-list-template.directive.mjs

@@ -0,0 +1,26 @@
+import { Directive, ElementRef, Input, TemplateRef } from "@angular/core";
+import { UnorederedListTemplate } from "../common-types";
+import * as i0 from "@angular/core";
+export class UnorderedListTemplateDirective extends UnorederedListTemplate {
+    constructor(elementRef, templateRef) {
+        super();
+        this.elementRef = elementRef;
+        this.templateRef = templateRef;
+    }
+    createEmbeddedView(context) {
+        return this.templateRef.createEmbeddedView(context);
+    }
+}
+UnorderedListTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListTemplateDirective, deps: [{ token: i0.ElementRef }, { token: i0.TemplateRef }], target: i0.ɵɵFactoryTarget.Directive });
+UnorderedListTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.3.8", type: UnorderedListTemplateDirective, selector: "ng-template[type][selector]", inputs: { type: "type", selector: "selector" }, usesInheritance: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.8", ngImport: i0, type: UnorderedListTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: "ng-template[type][selector]"
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.TemplateRef }]; }, propDecorators: { type: [{
+                type: Input
+            }], selector: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5vcmRlcmVkLWxpc3QtdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL25neC11dGlscy9kaXJlY3RpdmVzL3Vub3JkZXJlZC1saXN0LXRlbXBsYXRlLmRpcmVjdGl2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUMsU0FBUyxFQUFFLFVBQVUsRUFBbUIsS0FBSyxFQUFFLFdBQVcsRUFBQyxNQUFNLGVBQWUsQ0FBQztBQUN6RixPQUFPLEVBQUMsc0JBQXNCLEVBQUMsTUFBTSxpQkFBaUIsQ0FBQzs7QUFNdkQsTUFBTSxPQUFPLDhCQUErQixTQUFRLHNCQUFzQjtJQUt0RSxZQUFtQixVQUFzQixFQUFTLFdBQTZCO1FBQzNFLEtBQUssRUFBRSxDQUFDO1FBRE8sZUFBVSxHQUFWLFVBQVUsQ0FBWTtRQUFTLGdCQUFXLEdBQVgsV0FBVyxDQUFrQjtJQUUvRSxDQUFDO0lBRUQsa0JBQWtCLENBQUMsT0FBWTtRQUMzQixPQUFPLElBQUksQ0FBQyxXQUFXLENBQUMsa0JBQWtCLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDeEQsQ0FBQzs7MkhBWFEsOEJBQThCOytHQUE5Qiw4QkFBOEI7MkZBQTlCLDhCQUE4QjtrQkFKMUMsU0FBUzttQkFBQztvQkFDUCxRQUFRLEVBQUUsNkJBQTZCO2lCQUMxQzsySEFJWSxJQUFJO3NCQUFaLEtBQUs7Z0JBQ0csUUFBUTtzQkFBaEIsS0FBSyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7RGlyZWN0aXZlLCBFbGVtZW50UmVmLCBFbWJlZGRlZFZpZXdSZWYsIElucHV0LCBUZW1wbGF0ZVJlZn0gZnJvbSBcIkBhbmd1bGFyL2NvcmVcIjtcclxuaW1wb3J0IHtVbm9yZWRlcmVkTGlzdFRlbXBsYXRlfSBmcm9tIFwiLi4vY29tbW9uLXR5cGVzXCI7XHJcblxyXG5ARGlyZWN0aXZlKHtcclxuICAgIHNlbGVjdG9yOiBcIm5nLXRlbXBsYXRlW3R5cGVdW3NlbGVjdG9yXVwiXHJcbn0pXHJcblxyXG5leHBvcnQgY2xhc3MgVW5vcmRlcmVkTGlzdFRlbXBsYXRlRGlyZWN0aXZlIGV4dGVuZHMgVW5vcmVkZXJlZExpc3RUZW1wbGF0ZSB7XHJcblxyXG4gICAgQElucHV0KCkgdHlwZTogc3RyaW5nO1xyXG4gICAgQElucHV0KCkgc2VsZWN0b3I6IHN0cmluZztcclxuXHJcbiAgICBjb25zdHJ1Y3RvcihwdWJsaWMgZWxlbWVudFJlZjogRWxlbWVudFJlZiwgcHVibGljIHRlbXBsYXRlUmVmOiBUZW1wbGF0ZVJlZjxhbnk+KSB7XHJcbiAgICAgICAgc3VwZXIoKTtcclxuICAgIH1cclxuXHJcbiAgICBjcmVhdGVFbWJlZGRlZFZpZXcoY29udGV4dDogYW55KTogRW1iZWRkZWRWaWV3UmVmPGFueT4ge1xyXG4gICAgICAgIHJldHVybiB0aGlzLnRlbXBsYXRlUmVmLmNyZWF0ZUVtYmVkZGVkVmlldyhjb250ZXh0KTtcclxuICAgIH1cclxufVxyXG4iXX0=

package/esm2020/ngx-utils/ngx-utils.imports.mjs

@@ -0,0 +1,165 @@
+import { ErrorHandler } from "@angular/core";
+import { EVENT_MANAGER_PLUGINS } from "@angular/platform-browser";
+import { UrlSerializer } from "@angular/router";
+import { DeviceDetectorService } from "ngx-device-detector";
+import { AuthGuard } from "./utils/auth.guard";
+import { AclService } from "./services/acl.service";
+import { ApiService } from "./services/api.service";
+import { StaticAuthService } from "./services/auth.service";
+import { BaseHttpClient } from "./services/base-http.client";
+import { BaseHttpService } from "./services/base-http.service";
+import { ConfigService } from "./services/config.service";
+import { ErrorHandlerService } from "./services/error-handler.service";
+import { EventsService } from "./services/events.service";
+import { FormatterService } from "./services/formatter.service";
+import { GlobalTemplateService } from "./services/global-template.service";
+import { IconService } from "./services/icon.service";
+import { LanguageService } from "./services/language.service";
+import { PromiseService } from "./services/promise.service";
+import { OpenApiService } from "./services/open-api.service";
+import { StateService } from "./services/state.service";
+import { StaticLanguageService } from "./services/static-language.service";
+import { StorageService } from "./services/storage.service";
+import { ConsoleToasterService } from "./services/toaster.service";
+import { TranslatedUrlSerializer } from "./services/translated-url.serializer";
+import { UniversalService } from "./services/universal.service";
+import { ResizeEventPlugin } from "./plugins/resize-event.plugin";
+import { ScrollEventPlugin } from "./plugins/scroll-event.plugin";
+import { AsyncMethodBase } from "./directives/async-method.base";
+import { AsyncMethodDirective } from "./directives/async-method.directive";
+import { BackgroundDirective } from "./directives/background.directive";
+import { DynamicTableTemplateDirective } from "./directives/dynamic-table-template.directive";
+import { GlobalTemplateDirective } from "./directives/global-template.directive";
+import { IconDirective } from "./directives/icon.directive";
+import { NgxTemplateOutletDirective } from "./directives/ngx-template-outlet.directive";
+import { PaginationDirective } from "./directives/pagination.directive";
+import { PaginationItemDirective } from "./directives/pagination-item.directive";
+import { ResourceIfDirective } from "./directives/resource-if.directive";
+import { StickyDirective } from "./directives/sticky.directive";
+import { StickyClassDirective } from "./directives/sticky-class.directive";
+import { UnorderedListItemDirective } from "./directives/unordered-list-item.directive";
+import { UnorderedListTemplateDirective } from "./directives/unordered-list-template.directive";
+import { ChunkPipe } from "./pipes/chunk.pipe";
+import { EntriesPipe } from "./pipes/entries.pipe";
+import { ExtraItemPropertiesPipe } from "./pipes/extra-item-properties.pipe";
+import { FilterPipe } from "./pipes/filter.pipe";
+import { FindPipe } from "./pipes/find.pipe";
+import { FormatNumberPipe } from "./pipes/format-number.pipe";
+import { GetOffsetPipe } from "./pipes/get-offset.pipe";
+import { GetTypePipe } from "./pipes/get-type.pipe";
+import { GlobalTemplatePipe } from "./pipes/global-template.pipe";
+import { GroupByPipe } from "./pipes/group-by.pipe";
+import { IsTypePipe } from "./pipes/is-type.pipe";
+import { JoinPipe } from "./pipes/join.pipe";
+import { KeysPipe } from "./pipes/keys.pipe";
+import { MapPipe } from "./pipes/map.pipe";
+import { MaxPipe } from "./pipes/max.pipe";
+import { MinPipe } from "./pipes/min.pipe";
+import { ReducePipe } from "./pipes/reduce.pipe";
+import { RemapPipe } from "./pipes/remap.pipe";
+import { ReplacePipe } from "./pipes/replace.pipe";
+import { ReversePipe } from "./pipes/reverse.pipe";
+import { RoundPipe } from "./pipes/round.pipe";
+import { SafeHtmlPipe } from "./pipes/safe-html.pipe";
+import { TranslatePipe } from "./pipes/translate.pipe";
+import { ValuesPipe } from "./pipes/values.pipe";
+import { DynamicTableComponent } from "./components/dynamic-table/dynamic-table.component";
+import { PaginationMenuComponent } from "./components/pagination-menu/pagination-menu.component";
+import { UnorderedListComponent } from "./components/unordered-list/unordered-list.component";
+// --- Pipes ---
+export const pipes = [
+    ChunkPipe,
+    EntriesPipe,
+    ExtraItemPropertiesPipe,
+    FilterPipe,
+    FindPipe,
+    FormatNumberPipe,
+    GetOffsetPipe,
+    GetTypePipe,
+    GlobalTemplatePipe,
+    GroupByPipe,
+    IsTypePipe,
+    JoinPipe,
+    KeysPipe,
+    MapPipe,
+    MaxPipe,
+    MinPipe,
+    ReducePipe,
+    RemapPipe,
+    ReplacePipe,
+    ReversePipe,
+    RoundPipe,
+    SafeHtmlPipe,
+    TranslatePipe,
+    ValuesPipe
+];
+// --- Directives ---
+export const directives = [
+    AsyncMethodBase,
+    AsyncMethodDirective,
+    BackgroundDirective,
+    DynamicTableTemplateDirective,
+    GlobalTemplateDirective,
+    IconDirective,
+    NgxTemplateOutletDirective,
+    PaginationDirective,
+    PaginationItemDirective,
+    ResourceIfDirective,
+    StickyDirective,
+    StickyClassDirective,
+    UnorderedListItemDirective,
+    UnorderedListTemplateDirective
+];
+// --- Components ---
+export const components = [
+    DynamicTableComponent,
+    PaginationMenuComponent,
+    UnorderedListComponent
+];
+export const providers = [
+    ...pipes,
+    BaseHttpClient,
+    BaseHttpService,
+    AuthGuard,
+    AclService,
+    ApiService,
+    StaticAuthService,
+    ConfigService,
+    ErrorHandlerService,
+    EventsService,
+    FormatterService,
+    GlobalTemplateService,
+    IconService,
+    LanguageService,
+    OpenApiService,
+    PromiseService,
+    StateService,
+    StaticLanguageService,
+    StorageService,
+    ConsoleToasterService,
+    TranslatedUrlSerializer,
+    UniversalService,
+    DeviceDetectorService,
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ResizeEventPlugin,
+        multi: true
+    },
+    {
+        provide: EVENT_MANAGER_PLUGINS,
+        useClass: ScrollEventPlugin,
+        multi: true
+    },
+    {
+        provide: UrlSerializer,
+        useExisting: TranslatedUrlSerializer
+    },
+    {
+        provide: ErrorHandler,
+        useExisting: ErrorHandlerService
+    }
+];
+export function loadConfig(config) {
+    return config.load;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ngx-utils.imports.js","sourceRoot":"","sources":["../../../src/ngx-utils/ngx-utils.imports.ts"],"names":[],"mappings":"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","sourcesContent":["import {ErrorHandler} from \"@angular/core\";\r\nimport {EVENT_MANAGER_PLUGINS} from \"@angular/platform-browser\";\r\nimport {UrlSerializer} from \"@angular/router\";\r\nimport {DeviceDetectorService} from \"ngx-device-detector\";\r\n\r\nimport {IConfigService} from \"./common-types\";\r\n\r\nimport {AuthGuard} from \"./utils/auth.guard\";\r\nimport {AclService} from \"./services/acl.service\";\r\nimport {ApiService} from \"./services/api.service\";\r\nimport {StaticAuthService} from \"./services/auth.service\";\r\nimport {BaseHttpClient} from \"./services/base-http.client\";\r\nimport {BaseHttpService} from \"./services/base-http.service\";\r\nimport {ConfigService} from \"./services/config.service\";\r\nimport {ErrorHandlerService} from \"./services/error-handler.service\";\r\nimport {EventsService} from \"./services/events.service\";\r\nimport {FormatterService} from \"./services/formatter.service\";\r\nimport {GlobalTemplateService} from \"./services/global-template.service\";\r\nimport {IconService} from \"./services/icon.service\";\r\nimport {LanguageService} from \"./services/language.service\";\r\nimport {PromiseService} from \"./services/promise.service\";\r\nimport {OpenApiService} from \"./services/open-api.service\";\r\nimport {StateService} from \"./services/state.service\";\r\nimport {StaticLanguageService} from \"./services/static-language.service\";\r\nimport {StorageService} from \"./services/storage.service\";\r\nimport {ConsoleToasterService} from \"./services/toaster.service\";\r\nimport {TranslatedUrlSerializer} from \"./services/translated-url.serializer\";\r\nimport {UniversalService} from \"./services/universal.service\";\r\nimport {ResizeEventPlugin} from \"./plugins/resize-event.plugin\";\r\nimport {ScrollEventPlugin} from \"./plugins/scroll-event.plugin\";\r\nimport {AsyncMethodBase} from \"./directives/async-method.base\";\r\nimport {AsyncMethodDirective} from \"./directives/async-method.directive\";\r\nimport {BackgroundDirective} from \"./directives/background.directive\";\r\nimport {DynamicTableTemplateDirective} from \"./directives/dynamic-table-template.directive\";\r\nimport {GlobalTemplateDirective} from \"./directives/global-template.directive\";\r\nimport {IconDirective} from \"./directives/icon.directive\";\r\nimport {NgxTemplateOutletDirective} from \"./directives/ngx-template-outlet.directive\";\r\nimport {PaginationDirective} from \"./directives/pagination.directive\";\r\nimport {PaginationItemDirective} from \"./directives/pagination-item.directive\";\r\nimport {ResourceIfDirective} from \"./directives/resource-if.directive\";\r\nimport {StickyDirective} from \"./directives/sticky.directive\";\r\nimport {StickyClassDirective} from \"./directives/sticky-class.directive\";\r\nimport {UnorderedListItemDirective} from \"./directives/unordered-list-item.directive\";\r\nimport {UnorderedListTemplateDirective} from \"./directives/unordered-list-template.directive\";\r\n\r\nimport {ChunkPipe} from \"./pipes/chunk.pipe\";\r\nimport {EntriesPipe} from \"./pipes/entries.pipe\";\r\nimport {ExtraItemPropertiesPipe} from \"./pipes/extra-item-properties.pipe\";\r\nimport {FilterPipe} from \"./pipes/filter.pipe\";\r\nimport {FindPipe} from \"./pipes/find.pipe\";\r\nimport {FormatNumberPipe} from \"./pipes/format-number.pipe\";\r\nimport {GetOffsetPipe} from \"./pipes/get-offset.pipe\";\r\nimport {GetTypePipe} from \"./pipes/get-type.pipe\";\r\nimport {GlobalTemplatePipe} from \"./pipes/global-template.pipe\";\r\nimport {GroupByPipe} from \"./pipes/group-by.pipe\";\r\nimport {IsTypePipe} from \"./pipes/is-type.pipe\";\r\nimport {JoinPipe} from \"./pipes/join.pipe\";\r\nimport {KeysPipe} from \"./pipes/keys.pipe\";\r\nimport {MapPipe} from \"./pipes/map.pipe\";\r\nimport {MaxPipe} from \"./pipes/max.pipe\";\r\nimport {MinPipe} from \"./pipes/min.pipe\";\r\nimport {ReducePipe} from \"./pipes/reduce.pipe\";\r\nimport {RemapPipe} from \"./pipes/remap.pipe\";\r\nimport {ReplacePipe} from \"./pipes/replace.pipe\";\r\nimport {ReversePipe} from \"./pipes/reverse.pipe\";\r\nimport {RoundPipe} from \"./pipes/round.pipe\";\r\nimport {SafeHtmlPipe} from \"./pipes/safe-html.pipe\";\r\nimport {TranslatePipe} from \"./pipes/translate.pipe\";\r\nimport {ValuesPipe} from \"./pipes/values.pipe\";\r\n\r\nimport {DynamicTableComponent} from \"./components/dynamic-table/dynamic-table.component\";\r\nimport {PaginationMenuComponent} from \"./components/pagination-menu/pagination-menu.component\";\r\nimport {UnorderedListComponent} from \"./components/unordered-list/unordered-list.component\";\r\n\r\n// --- Pipes ---\r\nexport const pipes = [\r\n    ChunkPipe,\r\n    EntriesPipe,\r\n    ExtraItemPropertiesPipe,\r\n    FilterPipe,\r\n    FindPipe,\r\n    FormatNumberPipe,\r\n    GetOffsetPipe,\r\n    GetTypePipe,\r\n    GlobalTemplatePipe,\r\n    GroupByPipe,\r\n    IsTypePipe,\r\n    JoinPipe,\r\n    KeysPipe,\r\n    MapPipe,\r\n    MaxPipe,\r\n    MinPipe,\r\n    ReducePipe,\r\n    RemapPipe,\r\n    ReplacePipe,\r\n    ReversePipe,\r\n    RoundPipe,\r\n    SafeHtmlPipe,\r\n    TranslatePipe,\r\n    ValuesPipe\r\n];\r\n\r\n// --- Directives ---\r\nexport const directives = [\r\n    AsyncMethodBase,\r\n    AsyncMethodDirective,\r\n    BackgroundDirective,\r\n    DynamicTableTemplateDirective,\r\n    GlobalTemplateDirective,\r\n    IconDirective,\r\n    NgxTemplateOutletDirective,\r\n    PaginationDirective,\r\n    PaginationItemDirective,\r\n    ResourceIfDirective,\r\n    StickyDirective,\r\n    StickyClassDirective,\r\n    UnorderedListItemDirective,\r\n    UnorderedListTemplateDirective\r\n];\r\n\r\n// --- Components ---\r\nexport const components = [\r\n    DynamicTableComponent,\r\n    PaginationMenuComponent,\r\n    UnorderedListComponent\r\n];\r\n\r\nexport const providers = [\r\n    ...pipes,\r\n    BaseHttpClient,\r\n    BaseHttpService,\r\n    AuthGuard,\r\n    AclService,\r\n    ApiService,\r\n    StaticAuthService,\r\n    ConfigService,\r\n    ErrorHandlerService,\r\n    EventsService,\r\n    FormatterService,\r\n    GlobalTemplateService,\r\n    IconService,\r\n    LanguageService,\r\n    OpenApiService,\r\n    PromiseService,\r\n    StateService,\r\n    StaticLanguageService,\r\n    StorageService,\r\n    ConsoleToasterService,\r\n    TranslatedUrlSerializer,\r\n    UniversalService,\r\n    DeviceDetectorService,\r\n    {\r\n        provide: EVENT_MANAGER_PLUGINS,\r\n        useClass: ResizeEventPlugin,\r\n        multi: true\r\n    },\r\n    {\r\n        provide: EVENT_MANAGER_PLUGINS,\r\n        useClass: ScrollEventPlugin,\r\n        multi: true\r\n    },\r\n    {\r\n        provide: UrlSerializer,\r\n        useExisting: TranslatedUrlSerializer\r\n    },\r\n    {\r\n        provide: ErrorHandler,\r\n        useExisting: ErrorHandlerService\r\n    }\r\n\r\n];\r\n\r\nexport function loadConfig(config: IConfigService): any {\r\n    return config.load;\r\n}\r\n"]}