@ng-nest/ui 12.0.11 → 13.0.3

package/esm2020/popover/popover.directive.mjs

@@ -0,0 +1,162 @@
+import { Directive, HostListener } from '@angular/core';
+import { XPortalConnectedPosition } from '@ng-nest/ui/portal';
+import { XPopoverPortalComponent } from './popover-portal.component';
+import { XPopoverPrefix, XPopoverProperty } from './popover.property';
+import { BehaviorSubject, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { XIsChange } from '@ng-nest/ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-nest/ui/portal";
+import * as i2 from "@angular/cdk/overlay";
+import * as i3 from "@ng-nest/ui/core";
+export class XPopoverDirective extends XPopoverProperty {
+    constructor(elementRef, portalService, viewContainerRef, overlay, configService) {
+        super();
+        this.elementRef = elementRef;
+        this.portalService = portalService;
+        this.viewContainerRef = viewContainerRef;
+        this.overlay = overlay;
+        this.configService = configService;
+        this.contentChange = new BehaviorSubject(null);
+        this.positionChange = new Subject();
+        this._unSubject = new Subject();
+    }
+    click() {
+        if (this.trigger === 'click') {
+            this.visible = !this.visible;
+            if (this.visible)
+                this.show();
+            else
+                this.hide();
+            this.visibleChange.emit(this.visible);
+        }
+    }
+    mouseenter() {
+        if (this.trigger === 'hover')
+            this.show();
+    }
+    mouseleave() {
+        if (this.trigger === 'hover')
+            this.hide();
+    }
+    ngOnInit() { }
+    ngOnChanges(changes) {
+        const { content, visible } = changes;
+        XIsChange(content) && this.contentChange.next(this.content);
+        if (XIsChange(visible)) {
+            if (this.visible)
+                this.show();
+            else
+                this.hide();
+        }
+    }
+    ngOnDestroy() {
+        this._unSubject.next();
+        this._unSubject.unsubscribe();
+        this.contentChange.unsubscribe();
+    }
+    ngAfterViewInit() { }
+    show() {
+        if (this.timeoutHide)
+            clearTimeout(this.timeoutHide);
+        if (!this.portal || (this.portal && !this.portal.overlayRef?.hasAttached())) {
+            this.visible = true;
+            this.createPortal();
+            this.visibleChange.emit(this.visible);
+        }
+    }
+    hide() {
+        if (this.portal.overlayRef?.hasAttached()) {
+            this.timeoutHide = setTimeout(() => {
+                this.visible = false;
+                this.portal.overlayRef?.dispose();
+                this.visibleChange.emit(this.visible);
+            });
+        }
+    }
+    createPortal() {
+        const config = {
+            backdropClass: '',
+            positionStrategy: this.portalService.setPlacement({
+                elementRef: this.elementRef,
+                placement: [this.placement, 'bottom', 'top', 'left', 'right']
+            }),
+            scrollStrategy: this.overlay.scrollStrategies.reposition()
+        };
+        this.setPosition(config);
+        this.portal = this.portalService.attach({
+            content: XPopoverPortalComponent,
+            viewContainerRef: this.viewContainerRef,
+            overlayConfig: config
+        });
+        if (this.trigger === 'click') {
+            this.portal.overlayRef
+                ?.outsidePointerEvents()
+                .pipe(takeUntil(this._unSubject))
+                .subscribe(() => {
+                this.hide();
+            });
+        }
+        this.setInstance();
+    }
+    setPosition(config) {
+        let position = config.positionStrategy;
+        position.positionChanges.pipe(takeUntil(this._unSubject)).subscribe((pos) => {
+            const place = XPortalConnectedPosition.get(pos.connectionPair);
+            if (place !== this.realPlacement) {
+                this.realPlacement = place;
+                this.positionChange.next(place);
+                this.portal.overlayRef?.updatePosition();
+            }
+        });
+    }
+    setInstance() {
+        let componentRef = this.portal?.componentRef;
+        if (!componentRef)
+            return;
+        this.box = this.elementRef.nativeElement.getBoundingClientRect();
+        this.realPlacement = `${this.placement}`;
+        Object.assign(componentRef.instance, {
+            box: this.box,
+            title: this.title,
+            content: this.content,
+            footer: this.footer,
+            contentChange: this.contentChange,
+            positionChange: this.positionChange,
+            trigger: this.trigger,
+            placement: this.placement,
+            width: this.width,
+            portalHover: (hover) => {
+                if (this.timeoutHide && hover) {
+                    clearTimeout(this.timeoutHide);
+                }
+                else {
+                    this.hide();
+                }
+            },
+            closePortal: () => this.hide(),
+            viewInit: () => this.portal.overlayRef?.updatePosition()
+        });
+        componentRef.changeDetectorRef.detectChanges();
+    }
+    update() {
+        if (this.portal)
+            this.portal.overlayRef?.updatePosition();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XPopoverDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverDirective, deps: [{ token: i0.ElementRef }, { token: i1.XPortalService }, { token: i0.ViewContainerRef }, { token: i2.Overlay }, { token: i3.XConfigService }], target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ XPopoverDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: XPopoverDirective, selector: "[x-popover], x-popover", host: { listeners: { "click": "click()", "mouseenter": "mouseenter()", "mouseleave": "mouseleave()" } }, usesInheritance: true, usesOnChanges: true, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: `[${XPopoverPrefix}], ${XPopoverPrefix}` }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i1.XPortalService }, { type: i0.ViewContainerRef }, { type: i2.Overlay }, { type: i3.XConfigService }]; }, propDecorators: { click: [{
+                type: HostListener,
+                args: ['click']
+            }], mouseenter: [{
+                type: HostListener,
+                args: ['mouseenter']
+            }], mouseleave: [{
+                type: HostListener,
+                args: ['mouseleave']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"popover.directive.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/popover/popover.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import { OnInit, ElementRef, ViewContainerRef, Directive, HostListener, OnChanges, SimpleChanges } from '@angular/core';\r\nimport { XPortalService, XPortalOverlayRef, XPortalConnectedPosition } from '@ng-nest/ui/portal';\r\nimport { XPopoverPortalComponent } from './popover-portal.component';\r\nimport { XPopoverPrefix, XPopoverProperty } from './popover.property';\r\nimport { BehaviorSubject, Subject } from 'rxjs';\r\nimport { OverlayConfig, FlexibleConnectedPositionStrategy, ConnectedOverlayPositionChange, Overlay } from '@angular/cdk/overlay';\r\nimport { takeUntil } from 'rxjs/operators';\r\nimport { XPlacement, XIsChange, XConfigService } from '@ng-nest/ui/core';\r\n\r\n@Directive({ selector: `[${XPopoverPrefix}], ${XPopoverPrefix}` })\r\nexport class XPopoverDirective extends XPopoverProperty implements OnInit, OnChanges {\r\n  portal!: XPortalOverlayRef<XPopoverPortalComponent>;\r\n  box!: DOMRect;\r\n  contentChange: BehaviorSubject<any> = new BehaviorSubject(null);\r\n  positionChange: Subject<any> = new Subject();\r\n  timeoutHide: any;\r\n  private _unSubject = new Subject<void>();\r\n  private realPlacement!: XPlacement;\r\n\r\n  constructor(\r\n    private elementRef: ElementRef,\r\n    private portalService: XPortalService,\r\n    private viewContainerRef: ViewContainerRef,\r\n    private overlay: Overlay,\r\n    public configService: XConfigService\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  @HostListener('click') click() {\r\n    if (this.trigger === 'click') {\r\n      this.visible = !this.visible;\r\n      if (this.visible) this.show();\r\n      else this.hide();\r\n      this.visibleChange.emit(this.visible);\r\n    }\r\n  }\r\n\r\n  @HostListener('mouseenter') mouseenter() {\r\n    if (this.trigger === 'hover') this.show();\r\n  }\r\n\r\n  @HostListener('mouseleave') mouseleave() {\r\n    if (this.trigger === 'hover') this.hide();\r\n  }\r\n\r\n  ngOnInit() {}\r\n\r\n  ngOnChanges(changes: SimpleChanges): void {\r\n    const { content, visible } = changes;\r\n    XIsChange(content) && this.contentChange.next(this.content);\r\n    if (XIsChange(visible)) {\r\n      if (this.visible) this.show();\r\n      else this.hide();\r\n    }\r\n  }\r\n\r\n  ngOnDestroy(): void {\r\n    this._unSubject.next();\r\n    this._unSubject.unsubscribe();\r\n    this.contentChange.unsubscribe();\r\n  }\r\n\r\n  ngAfterViewInit() {}\r\n\r\n  show() {\r\n    if (this.timeoutHide) clearTimeout(this.timeoutHide);\r\n    if (!this.portal || (this.portal && !this.portal.overlayRef?.hasAttached())) {\r\n      this.visible = true;\r\n      this.createPortal();\r\n      this.visibleChange.emit(this.visible);\r\n    }\r\n  }\r\n\r\n  hide() {\r\n    if (this.portal.overlayRef?.hasAttached()) {\r\n      this.timeoutHide = setTimeout(() => {\r\n        this.visible = false;\r\n        this.portal.overlayRef?.dispose();\r\n        this.visibleChange.emit(this.visible);\r\n      });\r\n    }\r\n  }\r\n\r\n  createPortal() {\r\n    const config: OverlayConfig = {\r\n      backdropClass: '',\r\n      positionStrategy: this.portalService.setPlacement({\r\n        elementRef: this.elementRef,\r\n        placement: [this.placement as XPlacement, 'bottom', 'top', 'left', 'right']\r\n      }),\r\n      scrollStrategy: this.overlay.scrollStrategies.reposition()\r\n    };\r\n    this.setPosition(config);\r\n    this.portal = this.portalService.attach({\r\n      content: XPopoverPortalComponent,\r\n      viewContainerRef: this.viewContainerRef,\r\n      overlayConfig: config\r\n    });\r\n    if (this.trigger === 'click') {\r\n      this.portal.overlayRef\r\n        ?.outsidePointerEvents()\r\n        .pipe(takeUntil(this._unSubject))\r\n        .subscribe(() => {\r\n          this.hide();\r\n        });\r\n    }\r\n    this.setInstance();\r\n  }\r\n\r\n  setPosition(config: OverlayConfig) {\r\n    let position = config.positionStrategy as FlexibleConnectedPositionStrategy;\r\n    position.positionChanges.pipe(takeUntil(this._unSubject)).subscribe((pos: ConnectedOverlayPositionChange) => {\r\n      const place = XPortalConnectedPosition.get(pos.connectionPair) as XPlacement;\r\n      if (place !== this.realPlacement) {\r\n        this.realPlacement = place;\r\n        this.positionChange.next(place);\r\n        this.portal.overlayRef?.updatePosition();\r\n      }\r\n    });\r\n  }\r\n\r\n  setInstance() {\r\n    let componentRef = this.portal?.componentRef;\r\n    if (!componentRef) return;\r\n    this.box = this.elementRef.nativeElement.getBoundingClientRect();\r\n    this.realPlacement = `${this.placement}` as XPlacement;\r\n    Object.assign(componentRef.instance, {\r\n      box: this.box,\r\n      title: this.title,\r\n      content: this.content,\r\n      footer: this.footer,\r\n      contentChange: this.contentChange,\r\n      positionChange: this.positionChange,\r\n      trigger: this.trigger,\r\n      placement: this.placement,\r\n      width: this.width,\r\n      portalHover: (hover: boolean) => {\r\n        if (this.timeoutHide && hover) {\r\n          clearTimeout(this.timeoutHide);\r\n        } else {\r\n          this.hide();\r\n        }\r\n      },\r\n      closePortal: () => this.hide(),\r\n      viewInit: () => this.portal.overlayRef?.updatePosition()\r\n    });\r\n    componentRef.changeDetectorRef.detectChanges();\r\n  }\r\n\r\n  update() {\r\n    if (this.portal) this.portal.overlayRef?.updatePosition();\r\n  }\r\n}\r\n"]}

package/esm2020/popover/popover.module.mjs

@@ -0,0 +1,23 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { XPopoverDirective } from './popover.directive';
+import { XPopoverPortalComponent } from './popover-portal.component';
+import { XPortalModule } from '@ng-nest/ui/portal';
+import { XOutletModule } from '@ng-nest/ui/outlet';
+import { XPopoverProperty } from './popover.property';
+import * as i0 from "@angular/core";
+export class XPopoverModule {
+}
+/** @nocollapse */ /** @nocollapse */ XPopoverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ XPopoverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverModule, declarations: [XPopoverDirective, XPopoverPortalComponent, XPopoverProperty], imports: [CommonModule, XPortalModule, XOutletModule], exports: [XPopoverDirective, XPopoverPortalComponent] });
+/** @nocollapse */ /** @nocollapse */ XPopoverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverModule, imports: [[CommonModule, XPortalModule, XOutletModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [XPopoverDirective, XPopoverPortalComponent, XPopoverProperty],
+                    exports: [XPopoverDirective, XPopoverPortalComponent],
+                    imports: [CommonModule, XPortalModule, XOutletModule],
+                    entryComponents: [XPopoverPortalComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/popover/popover.property.mjs

@@ -0,0 +1,65 @@
+import { __decorate } from "tslib";
+import { XProperty, XInputBoolean, XWithConfig } from '@ng-nest/ui/core';
+import { Input, Output, EventEmitter, Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Popover
+ * @selector x-popover
+ * @decorator directive
+ */
+export const XPopoverPrefix = 'x-popover';
+const X_CONFIG_NAME = 'popover';
+/**
+ * Popover Property
+ */
+export class XPopoverProperty extends XProperty {
+    constructor() {
+        super(...arguments);
+        /**
+         * @zh_CN 显示/隐藏改变的事件
+         * @en_US Show/hide changed events
+         */
+        this.visibleChange = new EventEmitter();
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XPopoverProperty.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverProperty, deps: null, target: i0.ɵɵFactoryTarget.Directive });
+/** @nocollapse */ /** @nocollapse */ XPopoverProperty.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.0.2", type: XPopoverProperty, selector: "[x-popover], x-popover", inputs: { title: "title", content: "content", footer: "footer", placement: "placement", trigger: "trigger", width: "width", visible: "visible" }, outputs: { visibleChange: "visibleChange" }, usesInheritance: true, ngImport: i0 });
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 'bottom')
+], XPopoverProperty.prototype, "placement", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, 'hover')
+], XPopoverProperty.prototype, "trigger", void 0);
+__decorate([
+    XWithConfig(X_CONFIG_NAME, '10rem')
+], XPopoverProperty.prototype, "width", void 0);
+__decorate([
+    XInputBoolean()
+], XPopoverProperty.prototype, "visible", void 0);
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPopoverProperty, decorators: [{
+            type: Directive,
+            args: [{ selector: `[${XPopoverPrefix}], ${XPopoverPrefix}` }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], content: [{
+                type: Input
+            }], footer: [{
+                type: Input
+            }], placement: [{
+                type: Input
+            }], trigger: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], visible: [{
+                type: Input
+            }], visibleChange: [{
+                type: Output
+            }] } });
+/**
+ * Popover Portal
+ * @selector x-popover-portal
+ * @decorator component
+ */
+export const XPopoverPortalPrefix = 'x-popover-portal';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/portal/portal.module.mjs

@@ -0,0 +1,18 @@
+import { NgModule } from '@angular/core';
+import { OverlayModule } from '@angular/cdk/overlay';
+import { PortalModule } from '@angular/cdk/portal';
+import { XPortalService } from './portal.service';
+import * as i0 from "@angular/core";
+export class XPortalModule {
+}
+/** @nocollapse */ /** @nocollapse */ XPortalModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ XPortalModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalModule, imports: [OverlayModule, PortalModule] });
+/** @nocollapse */ /** @nocollapse */ XPortalModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalModule, providers: [XPortalService], imports: [[OverlayModule, PortalModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [OverlayModule, PortalModule],
+                    providers: [XPortalService]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicG9ydGFsLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYi9uZy1uZXN0L3VpL3BvcnRhbC9wb3J0YWwubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQ3JELE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUNuRCxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7O0FBTWxELE1BQU0sT0FBTyxhQUFhOztnSkFBYixhQUFhO2lKQUFiLGFBQWEsWUFIZCxhQUFhLEVBQUUsWUFBWTtpSkFHMUIsYUFBYSxhQUZiLENBQUMsY0FBYyxDQUFDLFlBRGxCLENBQUMsYUFBYSxFQUFFLFlBQVksQ0FBQzsyRkFHM0IsYUFBYTtrQkFKekIsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxhQUFhLEVBQUUsWUFBWSxDQUFDO29CQUN0QyxTQUFTLEVBQUUsQ0FBQyxjQUFjLENBQUM7aUJBQzVCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgT3ZlcmxheU1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2Nkay9vdmVybGF5JztcclxuaW1wb3J0IHsgUG9ydGFsTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY2RrL3BvcnRhbCc7XHJcbmltcG9ydCB7IFhQb3J0YWxTZXJ2aWNlIH0gZnJvbSAnLi9wb3J0YWwuc2VydmljZSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGltcG9ydHM6IFtPdmVybGF5TW9kdWxlLCBQb3J0YWxNb2R1bGVdLFxyXG4gIHByb3ZpZGVyczogW1hQb3J0YWxTZXJ2aWNlXVxyXG59KVxyXG5leHBvcnQgY2xhc3MgWFBvcnRhbE1vZHVsZSB7fVxyXG4iXX0=

package/esm2020/portal/portal.service.mjs

@@ -0,0 +1,108 @@
+import { Injectable, TemplateRef } from '@angular/core';
+import { TemplatePortal, ComponentPortal, PortalInjector } from '@angular/cdk/portal';
+import { XPortalPlacement } from './portal.property';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/cdk/overlay";
+/**
+ * 动态创建视图服务
+ */
+export class XPortalService {
+    constructor(overlay, injector) {
+        this.overlay = overlay;
+        this.injector = injector;
+    }
+    attach(option) {
+        let portal = {};
+        if (typeof option.content === 'undefined')
+            return portal;
+        portal.overlayRef = this.createOverlayRef(option);
+        if (option.content instanceof TemplateRef && option.viewContainerRef) {
+            portal.templatePortal = new TemplatePortal(option.content, option.viewContainerRef, option.context);
+            portal.embeddedViewRef = portal.overlayRef.attach(portal.templatePortal);
+        }
+        else {
+            portal.componentPortal = new ComponentPortal(option.content, option.viewContainerRef, option.injector, option.componentFactoryResolver);
+            portal.componentRef = portal.overlayRef.attach(portal.componentPortal);
+        }
+        return portal;
+    }
+    createInjector(data, token) {
+        const injectorTokens = new WeakMap();
+        injectorTokens.set(token, data);
+        return new PortalInjector(this.injector, injectorTokens);
+    }
+    setPlacement(param) {
+        if (!param) {
+            return this.overlay.position().global().centerHorizontally().centerVertically();
+        }
+        else {
+            return this.overlay
+                .position()
+                .flexibleConnectedTo(param.elementRef)
+                // .withLockedPosition(true)
+                .withFlexibleDimensions(false)
+                .withPush(false)
+                .withPositions(this.setConnectedPosition(...param.placement))
+                .withTransformOriginOn(param.transformOriginOn);
+        }
+    }
+    setPosition(position, width, height) {
+        let result = this.overlay.position().global().width(width).height(height);
+        switch (position) {
+            case 'left':
+                return result.left();
+            case 'right':
+                return result.right();
+            case 'top':
+                return result.top();
+            case 'bottom':
+            default:
+                return result.bottom();
+        }
+    }
+    setPlace(place, width, height, ...offset) {
+        let result = this.overlay.position().global().width(width).height(height);
+        if (offset.length === 0)
+            offset = Array.from({ length: 4 }).map(() => `0`);
+        else if (offset.length < 4) {
+            Array.from({ length: 4 - offset.length }).map(() => (offset = [...offset, offset[offset.length - 1]]));
+        }
+        let [top, right, bottom, left] = offset;
+        switch (place) {
+            case 'top-start':
+                return result.top(top).left(right);
+            case 'top':
+                return result.centerHorizontally().top(top);
+            case 'top-end':
+                return result.top(bottom).right(left);
+            case 'left':
+                return result.centerVertically().left(left);
+            case 'center':
+                return result.centerVertically().centerHorizontally();
+            case 'right':
+                return result.centerVertically().right(right);
+            case 'bottom-start':
+                return result.bottom(bottom).left(left);
+            case 'bottom':
+                return result.centerHorizontally().bottom(bottom);
+            case 'bottom-end':
+                return result.bottom(bottom).right(right);
+            default:
+                return result.centerVertically().centerHorizontally();
+        }
+    }
+    createOverlayRef(option) {
+        return this.overlay.create(option.overlayConfig);
+    }
+    setConnectedPosition(...placement) {
+        let result = [];
+        placement.forEach((place) => result.push(XPortalPlacement[place]));
+        return result;
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XPortalService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalService, deps: [{ token: i1.Overlay }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ XPortalService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XPortalService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Overlay }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"portal.service.js","sourceRoot":"","sources":["../../../../../lib/ng-nest/ui/portal/portal.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, TemplateRef, Injector, InjectionToken, ElementRef } from '@angular/core';\r\nimport { Overlay, OverlayRef, PositionStrategy, ConnectedPosition, ComponentType } from '@angular/cdk/overlay';\r\nimport { TemplatePortal, ComponentPortal, PortalInjector } from '@angular/cdk/portal';\r\nimport { XPortalProperty, XPortalOverlayRef, XPortalPlacement } from './portal.property';\r\nimport { XPlacement, XPosition, XPlace } from '@ng-nest/ui/core';\r\n\r\n/**\r\n * 动态创建视图服务\r\n */\r\n@Injectable()\r\nexport class XPortalService {\r\n  constructor(public overlay: Overlay, public injector: Injector) {}\r\n\r\n  attach<T>(option: XPortalProperty): XPortalOverlayRef<T> {\r\n    let portal: XPortalOverlayRef<T> = {};\r\n    if (typeof option.content === 'undefined') return portal;\r\n    portal.overlayRef = this.createOverlayRef(option);\r\n    if (option.content instanceof TemplateRef && option.viewContainerRef) {\r\n      portal.templatePortal = new TemplatePortal(option.content, option.viewContainerRef, option.context);\r\n      portal.embeddedViewRef = portal.overlayRef.attach(portal.templatePortal);\r\n    } else {\r\n      portal.componentPortal = new ComponentPortal(\r\n        option.content as ComponentType<any>,\r\n        option.viewContainerRef,\r\n        option.injector,\r\n        option.componentFactoryResolver\r\n      );\r\n      portal.componentRef = portal.overlayRef.attach(portal.componentPortal);\r\n    }\r\n\r\n    return portal;\r\n  }\r\n\r\n  createInjector(data: any, token: InjectionToken<any>): PortalInjector {\r\n    const injectorTokens = new WeakMap();\r\n    injectorTokens.set(token, data);\r\n    return new PortalInjector(this.injector, injectorTokens);\r\n  }\r\n\r\n  setPlacement(param?: { elementRef?: ElementRef; placement?: XPlace[] | XPlacement[]; transformOriginOn?: string }): PositionStrategy {\r\n    if (!param) {\r\n      return this.overlay.position().global().centerHorizontally().centerVertically();\r\n    } else {\r\n      return this.overlay\r\n        .position()\r\n        .flexibleConnectedTo(param.elementRef!)\r\n        // .withLockedPosition(true)\r\n        .withFlexibleDimensions(false)\r\n        .withPush(false)\r\n        .withPositions(this.setConnectedPosition(...param.placement))\r\n        .withTransformOriginOn(param.transformOriginOn!);\r\n    }\r\n  }\r\n\r\n  setPosition(position?: XPosition, width?: string, height?: string): PositionStrategy {\r\n    let result = this.overlay.position().global().width(width).height(height);\r\n    switch (position) {\r\n      case 'left':\r\n        return result.left();\r\n      case 'right':\r\n        return result.right();\r\n      case 'top':\r\n        return result.top();\r\n      case 'bottom':\r\n      default:\r\n        return result.bottom();\r\n    }\r\n  }\r\n\r\n  setPlace(place?: XPlace, width?: string, height?: string, ...offset: string[]): PositionStrategy {\r\n    let result = this.overlay.position().global().width(width).height(height);\r\n    if (offset.length === 0) offset = Array.from({ length: 4 }).map(() => `0`);\r\n    else if (offset.length < 4) {\r\n      Array.from({ length: 4 - offset.length }).map(() => (offset = [...offset, offset[offset.length - 1]]));\r\n    }\r\n    let [top, right, bottom, left] = offset;\r\n    switch (place) {\r\n      case 'top-start':\r\n        return result.top(top).left(right);\r\n      case 'top':\r\n        return result.centerHorizontally().top(top);\r\n      case 'top-end':\r\n        return result.top(bottom).right(left);\r\n      case 'left':\r\n        return result.centerVertically().left(left);\r\n      case 'center':\r\n        return result.centerVertically().centerHorizontally();\r\n      case 'right':\r\n        return result.centerVertically().right(right);\r\n      case 'bottom-start':\r\n        return result.bottom(bottom).left(left);\r\n      case 'bottom':\r\n        return result.centerHorizontally().bottom(bottom);\r\n      case 'bottom-end':\r\n        return result.bottom(bottom).right(right);\r\n      default:\r\n        return result.centerVertically().centerHorizontally();\r\n    }\r\n  }\r\n\r\n  createOverlayRef(option: XPortalProperty): OverlayRef {\r\n    return this.overlay.create(option.overlayConfig);\r\n  }\r\n\r\n  setConnectedPosition(...placement: XPlace[] | XPlacement[]): ConnectedPosition[] {\r\n    let result: ConnectedPosition[] = [];\r\n    placement.forEach((place: XPlace | XPlacement) => result.push(XPortalPlacement[place]));\r\n    return result;\r\n  }\r\n}\r\n"]}

package/esm2020/progress/progress.component.mjs

@@ -0,0 +1,60 @@
+import { Component, ViewEncapsulation, ChangeDetectionStrategy } from '@angular/core';
+import { XProgressPrefix, XProgressProperty } from './progress.property';
+import { XIsFunction, XIsString, XIsObjectArray, XIsEmpty, XIsChange } from '@ng-nest/ui/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ng-nest/ui/core";
+import * as i2 from "@ng-nest/ui/icon";
+import * as i3 from "@angular/common";
+export class XProgressComponent extends XProgressProperty {
+    constructor(renderer, elementRef, cdr, configService) {
+        super();
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this.configService = configService;
+    }
+    ngOnInit() { }
+    ngOnChanges(simples) {
+        const { status, percent } = simples;
+        XIsChange(status) && this.setClassMap();
+        XIsChange(percent) && this.setColor();
+    }
+    setClassMap() {
+        this.classMap = {
+            [`${XProgressPrefix}-${this.status}`]: true,
+            [`${XProgressPrefix}-inside`]: Boolean(this.inside)
+        };
+    }
+    setColor() {
+        if (XIsEmpty(this.color))
+            return;
+        if (XIsString(this.color)) {
+            this.currentColor = this.color;
+        }
+        else if (XIsObjectArray(this.color)) {
+            this.currentColor = this.getLevelColor(this.percent);
+        }
+        else if (XIsFunction(this.color)) {
+            this.currentColor = this.color(this.percent);
+        }
+    }
+    getLevelColor(percent) {
+        let colors = this.color.sort((a, b) => a.percent - b.percent);
+        for (let i = 0; i < colors.length; i++) {
+            if (colors[i].percent > Number(percent)) {
+                return colors[i].color;
+            }
+        }
+        return colors[colors.length - 1].color;
+    }
+    onFormat(percent) {
+        return this.format && this.format(percent);
+    }
+}
+/** @nocollapse */ /** @nocollapse */ XProgressComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i1.XConfigService }], target: i0.ɵɵFactoryTarget.Component });
+/** @nocollapse */ /** @nocollapse */ XProgressComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.2", type: XProgressComponent, selector: "x-progress", usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<div class=\"x-progress\" [ngClass]=\"classMap\">\r\n  <div class=\"x-progress-track\">\r\n    <div class=\"x-progress-rail\">\r\n      <div\r\n        class=\"x-progress-bg\"\r\n        [style.width.%]=\"percent\"\r\n        [style.background-color]=\"currentColor\"\r\n        [style.height]=\"height\"\r\n        [style.line-height]=\"height\"\r\n      >\r\n        <span *ngIf=\"inside\">{{ percent }}%</span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <span class=\"x-progress-text\" *ngIf=\"info && !inside\" [ngSwitch]=\"status\">\r\n    <ng-container *ngSwitchCase=\"'success'\">\r\n      <x-icon type=\"fto-check-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchCase=\"'exception'\">\r\n      <x-icon type=\"fto-x-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchCase=\"'warning'\">\r\n      <x-icon type=\"fto-help-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchDefault>\r\n      <ng-container *ngIf=\"format; else defaultTemp\">{{ onFormat(percent) }}</ng-container>\r\n      <ng-template #defaultTemp>{{ percent }}%</ng-template>\r\n    </ng-container>\r\n  </span>\r\n</div>\r\n", styles: ["@keyframes x-progress-active{0%{width:0;opacity:.1}20%{width:0;opacity:.5}to{width:100%;opacity:0}}x-progress{display:flex;align-items:center}.x-progress{margin:0;padding:0;display:inline-flex;align-items:center;width:100%}.x-progress-track{width:100%;display:inline-flex;align-items:center}.x-progress-rail{position:relative;display:inline-block;width:100%;overflow:hidden;vertical-align:middle;background-color:var(--x-border-100);border-radius:var(--x-border-radius)}.x-progress-bg{position:relative;background-color:var(--x-primary);transition:all .3s cubic-bezier(.08,.82,.17,1) 0s;border-radius:var(--x-border-radius);text-align:right;color:#fff}.x-progress-bg>span{margin:0 .325rem}.x-progress-text{margin-left:.5rem;display:inline-flex;align-items:center;white-space:nowrap}.x-progress-active .x-progress-bg:before{position:absolute;top:0;right:0;bottom:0;left:0;background:var(--x-background-100);border-radius:var(--x-border-radius);opacity:0;animation:x-progress-active 2s cubic-bezier(.23,1,.32,1) infinite;content:\"\"}.x-progress-exception .x-progress-text{color:var(--x-danger)}.x-progress-exception .x-progress-bg{background-color:var(--x-danger)}.x-progress-success .x-progress-text{color:var(--x-success)}.x-progress-success .x-progress-bg{background-color:var(--x-success)}.x-progress-warning .x-progress-text{color:var(--x-warning)}.x-progress-warning .x-progress-bg{background-color:var(--x-warning)}\n"], components: [{ type: i2.XIconComponent, selector: "x-icon" }], directives: [{ type: i3.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i3.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i3.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i3.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i3.NgSwitchDefault, selector: "[ngSwitchDefault]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressComponent, decorators: [{
+            type: Component,
+            args: [{ selector: `${XProgressPrefix}`, encapsulation: ViewEncapsulation.None, changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"x-progress\" [ngClass]=\"classMap\">\r\n  <div class=\"x-progress-track\">\r\n    <div class=\"x-progress-rail\">\r\n      <div\r\n        class=\"x-progress-bg\"\r\n        [style.width.%]=\"percent\"\r\n        [style.background-color]=\"currentColor\"\r\n        [style.height]=\"height\"\r\n        [style.line-height]=\"height\"\r\n      >\r\n        <span *ngIf=\"inside\">{{ percent }}%</span>\r\n      </div>\r\n    </div>\r\n  </div>\r\n  <span class=\"x-progress-text\" *ngIf=\"info && !inside\" [ngSwitch]=\"status\">\r\n    <ng-container *ngSwitchCase=\"'success'\">\r\n      <x-icon type=\"fto-check-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchCase=\"'exception'\">\r\n      <x-icon type=\"fto-x-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchCase=\"'warning'\">\r\n      <x-icon type=\"fto-help-circle\"></x-icon>\r\n    </ng-container>\r\n    <ng-container *ngSwitchDefault>\r\n      <ng-container *ngIf=\"format; else defaultTemp\">{{ onFormat(percent) }}</ng-container>\r\n      <ng-template #defaultTemp>{{ percent }}%</ng-template>\r\n    </ng-container>\r\n  </span>\r\n</div>\r\n", styles: ["@keyframes x-progress-active{0%{width:0;opacity:.1}20%{width:0;opacity:.5}to{width:100%;opacity:0}}x-progress{display:flex;align-items:center}.x-progress{margin:0;padding:0;display:inline-flex;align-items:center;width:100%}.x-progress-track{width:100%;display:inline-flex;align-items:center}.x-progress-rail{position:relative;display:inline-block;width:100%;overflow:hidden;vertical-align:middle;background-color:var(--x-border-100);border-radius:var(--x-border-radius)}.x-progress-bg{position:relative;background-color:var(--x-primary);transition:all .3s cubic-bezier(.08,.82,.17,1) 0s;border-radius:var(--x-border-radius);text-align:right;color:#fff}.x-progress-bg>span{margin:0 .325rem}.x-progress-text{margin-left:.5rem;display:inline-flex;align-items:center;white-space:nowrap}.x-progress-active .x-progress-bg:before{position:absolute;top:0;right:0;bottom:0;left:0;background:var(--x-background-100);border-radius:var(--x-border-radius);opacity:0;animation:x-progress-active 2s cubic-bezier(.23,1,.32,1) infinite;content:\"\"}.x-progress-exception .x-progress-text{color:var(--x-danger)}.x-progress-exception .x-progress-bg{background-color:var(--x-danger)}.x-progress-success .x-progress-text{color:var(--x-success)}.x-progress-success .x-progress-bg{background-color:var(--x-success)}.x-progress-warning .x-progress-text{color:var(--x-warning)}.x-progress-warning .x-progress-bg{background-color:var(--x-warning)}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i1.XConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MuY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL25nLW5lc3QvdWkvcHJvZ3Jlc3MvcHJvZ3Jlc3MuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vbGliL25nLW5lc3QvdWkvcHJvZ3Jlc3MvcHJvZ3Jlc3MuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLFNBQVMsRUFFVCxpQkFBaUIsRUFJakIsdUJBQXVCLEVBR3hCLE1BQU0sZUFBZSxDQUFDO0FBQ3ZCLE9BQU8sRUFBRSxlQUFlLEVBQUUsaUJBQWlCLEVBQUUsTUFBTSxxQkFBcUIsQ0FBQztBQUN6RSxPQUFPLEVBQUUsV0FBVyxFQUFFLFNBQVMsRUFBRSxjQUFjLEVBQUUsUUFBUSxFQUFFLFNBQVMsRUFBMkIsTUFBTSxrQkFBa0IsQ0FBQzs7Ozs7QUFTeEgsTUFBTSxPQUFPLGtCQUFtQixTQUFRLGlCQUFpQjtJQUd2RCxZQUNTLFFBQW1CLEVBQ25CLFVBQXNCLEVBQ3RCLEdBQXNCLEVBQ3RCLGFBQTZCO1FBRXBDLEtBQUssRUFBRSxDQUFDO1FBTEQsYUFBUSxHQUFSLFFBQVEsQ0FBVztRQUNuQixlQUFVLEdBQVYsVUFBVSxDQUFZO1FBQ3RCLFFBQUcsR0FBSCxHQUFHLENBQW1CO1FBQ3RCLGtCQUFhLEdBQWIsYUFBYSxDQUFnQjtJQUd0QyxDQUFDO0lBRUQsUUFBUSxLQUFJLENBQUM7SUFFYixXQUFXLENBQUMsT0FBc0I7UUFDaEMsTUFBTSxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsR0FBRyxPQUFPLENBQUM7UUFDcEMsU0FBUyxDQUFDLE1BQU0sQ0FBQyxJQUFJLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztRQUN4QyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3hDLENBQUM7SUFFRCxXQUFXO1FBQ1QsSUFBSSxDQUFDLFFBQVEsR0FBRztZQUNkLENBQUMsR0FBRyxlQUFlLElBQUksSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsSUFBSTtZQUMzQyxDQUFDLEdBQUcsZUFBZSxTQUFTLENBQUMsRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQztTQUNwRCxDQUFDO0lBQ0osQ0FBQztJQUVELFFBQVE7UUFDTixJQUFJLFFBQVEsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDO1lBQUUsT0FBTztRQUNqQyxJQUFJLFNBQVMsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDekIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsS0FBZSxDQUFDO1NBQzFDO2FBQU0sSUFBSSxjQUFjLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3JDLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLGFBQWEsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDdEQ7YUFBTSxJQUFJLFdBQVcsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUU7WUFDbEMsSUFBSSxDQUFDLFlBQVksR0FBSSxJQUFJLENBQUMsS0FBa0IsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7U0FDNUQ7SUFDSCxDQUFDO0lBRUQsYUFBYSxDQUFDLE9BQWdCO1FBQzVCLElBQUksTUFBTSxHQUFJLElBQUksQ0FBQyxLQUE4QyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUMsQ0FBQyxPQUFPLEdBQUcsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3hHLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFO1lBQ3RDLElBQUksTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUMsT0FBTyxDQUFDLEVBQUU7Z0JBQ3ZDLE9BQU8sTUFBTSxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQzthQUN4QjtTQUNGO1FBQ0QsT0FBTyxNQUFNLENBQUMsTUFBTSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxLQUFLLENBQUM7SUFDekMsQ0FBQztJQUVELFFBQVEsQ0FBQyxPQUFnQjtRQUN2QixPQUFPLElBQUksQ0FBQyxNQUFNLElBQUksSUFBSSxDQUFDLE1BQU0sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM3QyxDQUFDOztxSkFsRFUsa0JBQWtCO3lJQUFsQixrQkFBa0IsOEZDckIvQixncENBOEJBOzJGRFRhLGtCQUFrQjtrQkFQOUIsU0FBUzsrQkFDRSxHQUFHLGVBQWUsRUFBRSxpQkFHZixpQkFBaUIsQ0FBQyxJQUFJLG1CQUNwQix1QkFBdUIsQ0FBQyxNQUFNIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcclxuICBDb21wb25lbnQsXHJcbiAgT25Jbml0LFxyXG4gIFZpZXdFbmNhcHN1bGF0aW9uLFxyXG4gIFJlbmRlcmVyMixcclxuICBFbGVtZW50UmVmLFxyXG4gIENoYW5nZURldGVjdG9yUmVmLFxyXG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxyXG4gIFNpbXBsZUNoYW5nZXMsXHJcbiAgT25DaGFuZ2VzXHJcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFhQcm9ncmVzc1ByZWZpeCwgWFByb2dyZXNzUHJvcGVydHkgfSBmcm9tICcuL3Byb2dyZXNzLnByb3BlcnR5JztcclxuaW1wb3J0IHsgWElzRnVuY3Rpb24sIFhJc1N0cmluZywgWElzT2JqZWN0QXJyYXksIFhJc0VtcHR5LCBYSXNDaGFuZ2UsIFhOdW1iZXIsIFhDb25maWdTZXJ2aWNlIH0gZnJvbSAnQG5nLW5lc3QvdWkvY29yZSc7XHJcblxyXG5AQ29tcG9uZW50KHtcclxuICBzZWxlY3RvcjogYCR7WFByb2dyZXNzUHJlZml4fWAsXHJcbiAgdGVtcGxhdGVVcmw6ICcuL3Byb2dyZXNzLmNvbXBvbmVudC5odG1sJyxcclxuICBzdHlsZVVybHM6IFsnLi9wcm9ncmVzcy5jb21wb25lbnQuc2NzcyddLFxyXG4gIGVuY2Fwc3VsYXRpb246IFZpZXdFbmNhcHN1bGF0aW9uLk5vbmUsXHJcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2hcclxufSlcclxuZXhwb3J0IGNsYXNzIFhQcm9ncmVzc0NvbXBvbmVudCBleHRlbmRzIFhQcm9ncmVzc1Byb3BlcnR5IGltcGxlbWVudHMgT25Jbml0LCBPbkNoYW5nZXMge1xyXG4gIGN1cnJlbnRDb2xvciE6IHN0cmluZztcclxuXHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBwdWJsaWMgcmVuZGVyZXI6IFJlbmRlcmVyMixcclxuICAgIHB1YmxpYyBlbGVtZW50UmVmOiBFbGVtZW50UmVmLFxyXG4gICAgcHVibGljIGNkcjogQ2hhbmdlRGV0ZWN0b3JSZWYsXHJcbiAgICBwdWJsaWMgY29uZmlnU2VydmljZTogWENvbmZpZ1NlcnZpY2VcclxuICApIHtcclxuICAgIHN1cGVyKCk7XHJcbiAgfVxyXG5cclxuICBuZ09uSW5pdCgpIHt9XHJcblxyXG4gIG5nT25DaGFuZ2VzKHNpbXBsZXM6IFNpbXBsZUNoYW5nZXMpIHtcclxuICAgIGNvbnN0IHsgc3RhdHVzLCBwZXJjZW50IH0gPSBzaW1wbGVzO1xyXG4gICAgWElzQ2hhbmdlKHN0YXR1cykgJiYgdGhpcy5zZXRDbGFzc01hcCgpO1xyXG4gICAgWElzQ2hhbmdlKHBlcmNlbnQpICYmIHRoaXMuc2V0Q29sb3IoKTtcclxuICB9XHJcblxyXG4gIHNldENsYXNzTWFwKCkge1xyXG4gICAgdGhpcy5jbGFzc01hcCA9IHtcclxuICAgICAgW2Ake1hQcm9ncmVzc1ByZWZpeH0tJHt0aGlzLnN0YXR1c31gXTogdHJ1ZSxcclxuICAgICAgW2Ake1hQcm9ncmVzc1ByZWZpeH0taW5zaWRlYF06IEJvb2xlYW4odGhpcy5pbnNpZGUpXHJcbiAgICB9O1xyXG4gIH1cclxuXHJcbiAgc2V0Q29sb3IoKSB7XHJcbiAgICBpZiAoWElzRW1wdHkodGhpcy5jb2xvcikpIHJldHVybjtcclxuICAgIGlmIChYSXNTdHJpbmcodGhpcy5jb2xvcikpIHtcclxuICAgICAgdGhpcy5jdXJyZW50Q29sb3IgPSB0aGlzLmNvbG9yIGFzIHN0cmluZztcclxuICAgIH0gZWxzZSBpZiAoWElzT2JqZWN0QXJyYXkodGhpcy5jb2xvcikpIHtcclxuICAgICAgdGhpcy5jdXJyZW50Q29sb3IgPSB0aGlzLmdldExldmVsQ29sb3IodGhpcy5wZXJjZW50KTtcclxuICAgIH0gZWxzZSBpZiAoWElzRnVuY3Rpb24odGhpcy5jb2xvcikpIHtcclxuICAgICAgdGhpcy5jdXJyZW50Q29sb3IgPSAodGhpcy5jb2xvciBhcyBGdW5jdGlvbikodGhpcy5wZXJjZW50KTtcclxuICAgIH1cclxuICB9XHJcblxyXG4gIGdldExldmVsQ29sb3IocGVyY2VudDogWE51bWJlcikge1xyXG4gICAgbGV0IGNvbG9ycyA9ICh0aGlzLmNvbG9yIGFzIHsgY29sb3I6IHN0cmluZzsgcGVyY2VudDogbnVtYmVyIH1bXSkuc29ydCgoYSwgYikgPT4gYS5wZXJjZW50IC0gYi5wZXJjZW50KTtcclxuICAgIGZvciAobGV0IGkgPSAwOyBpIDwgY29sb3JzLmxlbmd0aDsgaSsrKSB7XHJcbiAgICAgIGlmIChjb2xvcnNbaV0ucGVyY2VudCA+IE51bWJlcihwZXJjZW50KSkge1xyXG4gICAgICAgIHJldHVybiBjb2xvcnNbaV0uY29sb3I7XHJcbiAgICAgIH1cclxuICAgIH1cclxuICAgIHJldHVybiBjb2xvcnNbY29sb3JzLmxlbmd0aCAtIDFdLmNvbG9yO1xyXG4gIH1cclxuXHJcbiAgb25Gb3JtYXQocGVyY2VudDogWE51bWJlcikge1xyXG4gICAgcmV0dXJuIHRoaXMuZm9ybWF0ICYmIHRoaXMuZm9ybWF0KHBlcmNlbnQpO1xyXG4gIH1cclxufVxyXG4iLCI8ZGl2IGNsYXNzPVwieC1wcm9ncmVzc1wiIFtuZ0NsYXNzXT1cImNsYXNzTWFwXCI+XHJcbiAgPGRpdiBjbGFzcz1cIngtcHJvZ3Jlc3MtdHJhY2tcIj5cclxuICAgIDxkaXYgY2xhc3M9XCJ4LXByb2dyZXNzLXJhaWxcIj5cclxuICAgICAgPGRpdlxyXG4gICAgICAgIGNsYXNzPVwieC1wcm9ncmVzcy1iZ1wiXHJcbiAgICAgICAgW3N0eWxlLndpZHRoLiVdPVwicGVyY2VudFwiXHJcbiAgICAgICAgW3N0eWxlLmJhY2tncm91bmQtY29sb3JdPVwiY3VycmVudENvbG9yXCJcclxuICAgICAgICBbc3R5bGUuaGVpZ2h0XT1cImhlaWdodFwiXHJcbiAgICAgICAgW3N0eWxlLmxpbmUtaGVpZ2h0XT1cImhlaWdodFwiXHJcbiAgICAgID5cclxuICAgICAgICA8c3BhbiAqbmdJZj1cImluc2lkZVwiPnt7IHBlcmNlbnQgfX0lPC9zcGFuPlxyXG4gICAgICA8L2Rpdj5cclxuICAgIDwvZGl2PlxyXG4gIDwvZGl2PlxyXG4gIDxzcGFuIGNsYXNzPVwieC1wcm9ncmVzcy10ZXh0XCIgKm5nSWY9XCJpbmZvICYmICFpbnNpZGVcIiBbbmdTd2l0Y2hdPVwic3RhdHVzXCI+XHJcbiAgICA8bmctY29udGFpbmVyICpuZ1N3aXRjaENhc2U9XCInc3VjY2VzcydcIj5cclxuICAgICAgPHgtaWNvbiB0eXBlPVwiZnRvLWNoZWNrLWNpcmNsZVwiPjwveC1pY29uPlxyXG4gICAgPC9uZy1jb250YWluZXI+XHJcbiAgICA8bmctY29udGFpbmVyICpuZ1N3aXRjaENhc2U9XCInZXhjZXB0aW9uJ1wiPlxyXG4gICAgICA8eC1pY29uIHR5cGU9XCJmdG8teC1jaXJjbGVcIj48L3gtaWNvbj5cclxuICAgIDwvbmctY29udGFpbmVyPlxyXG4gICAgPG5nLWNvbnRhaW5lciAqbmdTd2l0Y2hDYXNlPVwiJ3dhcm5pbmcnXCI+XHJcbiAgICAgIDx4LWljb24gdHlwZT1cImZ0by1oZWxwLWNpcmNsZVwiPjwveC1pY29uPlxyXG4gICAgPC9uZy1jb250YWluZXI+XHJcbiAgICA8bmctY29udGFpbmVyICpuZ1N3aXRjaERlZmF1bHQ+XHJcbiAgICAgIDxuZy1jb250YWluZXIgKm5nSWY9XCJmb3JtYXQ7IGVsc2UgZGVmYXVsdFRlbXBcIj57eyBvbkZvcm1hdChwZXJjZW50KSB9fTwvbmctY29udGFpbmVyPlxyXG4gICAgICA8bmctdGVtcGxhdGUgI2RlZmF1bHRUZW1wPnt7IHBlcmNlbnQgfX0lPC9uZy10ZW1wbGF0ZT5cclxuICAgIDwvbmctY29udGFpbmVyPlxyXG4gIDwvc3Bhbj5cclxuPC9kaXY+XHJcbiJdfQ==

package/esm2020/progress/progress.module.mjs

@@ -0,0 +1,21 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { XProgressComponent } from './progress.component';
+import { FormsModule } from '@angular/forms';
+import { XIconModule } from '@ng-nest/ui/icon';
+import { XProgressProperty } from './progress.property';
+import * as i0 from "@angular/core";
+export class XProgressModule {
+}
+/** @nocollapse */ /** @nocollapse */ XProgressModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ XProgressModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressModule, declarations: [XProgressComponent, XProgressProperty], imports: [CommonModule, FormsModule, XIconModule], exports: [XProgressComponent] });
+/** @nocollapse */ /** @nocollapse */ XProgressModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressModule, imports: [[CommonModule, FormsModule, XIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.2", ngImport: i0, type: XProgressModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [XProgressComponent, XProgressProperty],
+                    exports: [XProgressComponent],
+                    imports: [CommonModule, FormsModule, XIconModule]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZ3Jlc3MubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGliL25nLW5lc3QvdWkvcHJvZ3Jlc3MvcHJvZ3Jlc3MubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBQzFELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDL0MsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0scUJBQXFCLENBQUM7O0FBT3hELE1BQU0sT0FBTyxlQUFlOztrSkFBZixlQUFlO21KQUFmLGVBQWUsaUJBSlgsa0JBQWtCLEVBQUUsaUJBQWlCLGFBRTFDLFlBQVksRUFBRSxXQUFXLEVBQUUsV0FBVyxhQUR0QyxrQkFBa0I7bUpBR2pCLGVBQWUsWUFGakIsQ0FBQyxZQUFZLEVBQUUsV0FBVyxFQUFFLFdBQVcsQ0FBQzsyRkFFdEMsZUFBZTtrQkFMM0IsUUFBUTttQkFBQztvQkFDUixZQUFZLEVBQUUsQ0FBQyxrQkFBa0IsRUFBRSxpQkFBaUIsQ0FBQztvQkFDckQsT0FBTyxFQUFFLENBQUMsa0JBQWtCLENBQUM7b0JBQzdCLE9BQU8sRUFBRSxDQUFDLFlBQVksRUFBRSxXQUFXLEVBQUUsV0FBVyxDQUFDO2lCQUNsRCIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XHJcbmltcG9ydCB7IFhQcm9ncmVzc0NvbXBvbmVudCB9IGZyb20gJy4vcHJvZ3Jlc3MuY29tcG9uZW50JztcclxuaW1wb3J0IHsgRm9ybXNNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9mb3Jtcyc7XHJcbmltcG9ydCB7IFhJY29uTW9kdWxlIH0gZnJvbSAnQG5nLW5lc3QvdWkvaWNvbic7XHJcbmltcG9ydCB7IFhQcm9ncmVzc1Byb3BlcnR5IH0gZnJvbSAnLi9wcm9ncmVzcy5wcm9wZXJ0eSc7XHJcblxyXG5ATmdNb2R1bGUoe1xyXG4gIGRlY2xhcmF0aW9uczogW1hQcm9ncmVzc0NvbXBvbmVudCwgWFByb2dyZXNzUHJvcGVydHldLFxyXG4gIGV4cG9ydHM6IFtYUHJvZ3Jlc3NDb21wb25lbnRdLFxyXG4gIGltcG9ydHM6IFtDb21tb25Nb2R1bGUsIEZvcm1zTW9kdWxlLCBYSWNvbk1vZHVsZV1cclxufSlcclxuZXhwb3J0IGNsYXNzIFhQcm9ncmVzc01vZHVsZSB7fVxyXG4iXX0=