@stemy/ngx-utils 12.1.3 → 13.0.0

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=