@duoduo-oba/ng-devui/fesm5/ng-devui-utils.js

DevUI components based on Angular

import * as isDate_ from 'date-fns/is_date';
import * as dateParse_ from 'date-fns/parse';
import * as dateFormat_ from 'date-fns/format';
import { I18nFormat } from '@duoduo-oba/ng-devui/i18n';
import { Injectable, ɵɵdefineInjectable, Pipe, NgModule, EventEmitter, Directive, ElementRef, Input, Output, Component, Renderer2, NgZone, ChangeDetectorRef, ViewChild } from '@angular/core';
import { Subject, fromEvent } from 'rxjs';
import { DomSanitizer } from '@angular/platform-browser';
import { CommonModule } from '@angular/common';
import { debounceTime, distinctUntilChanged } from 'rxjs/operators';
import { __values } from 'tslib';
import Popper from 'popper.js';
import { trigger, state, style, transition, animate } from '@angular/animations';

/**
 * @fileoverview added by tsickle
 * Generated from: date-converter.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @record
 */
function DateConverter() { }
if (false) {
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DateConverter.prototype.parse = function (date, pattern, locale) { };
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DateConverter.prototype.format = function (date, pattern, locale) { };
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DateConverter.prototype.formatDateTime = function (date, pattern, locale) { };
}

/**
 * @fileoverview added by tsickle
 * Generated from: date-utils.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var isDate = isDate_;
/** @type {?} */
var dateParse = dateParse_;
/** @type {?} */
var dateFormat = dateFormat_;
/**
 * @param {?} date
 * @return {?}
 */
function isValidDate(date) {
    return isDate(date) && !isNaN(date.getTime());
}
/**
 * @param {?} date
 * @return {?}
 */
function parseDate(date) {
    if (!date) {
        return null;
    }
    if (isDate(date)) {
        return date;
    }
    /** @type {?} */
    var parsedDate = dateParse(date);
    return isValidDate(parsedDate) ? parsedDate : null;
}
/**
 * @param {?} date
 * @param {?=} pattern
 * @return {?}
 */
function formatDate(date, pattern) {
    if (pattern === void 0) { pattern = 'YYYY-MM-DD HH:mm:ss'; }
    return isValidDate(date) ? dateFormat(date, pattern) : '';
}

/**
 * @fileoverview added by tsickle
 * Generated from: default-date-converter.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var DefaultDateConverter = /** @class */ (function () {
    function DefaultDateConverter() {
    }
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DefaultDateConverter.prototype.parse = /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    function (date, pattern, locale) {
        return parseDate(date);
    };
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DefaultDateConverter.prototype.format = /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    function (date, pattern, locale) {
        return I18nFormat.formatDate(date, pattern, locale);
    };
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    DefaultDateConverter.prototype.formatDateTime = /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    function (date, pattern, locale) {
        return I18nFormat.formatDateTimeWithoutGMT(date, pattern, locale);
    };
    return DefaultDateConverter;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: dom-utils.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/**
 * @param {?} elementRef
 * @param {?} windowRef
 * @return {?}
 */
function centerWindowPosition(elementRef, windowRef) {
    if (!elementRef.nativeElement || !elementRef.nativeElement.getBoundingClientRect) {
        return {};
    }
    /** @type {?} */
    var rect = elementRef.nativeElement.getBoundingClientRect();
    /** @type {?} */
    var elmHeight = rect.height;
    /** @type {?} */
    var elmWidth = rect.width;
    /** @type {?} */
    var winHeight = windowRef.innerHeight;
    /** @type {?} */
    var winWidth = windowRef.innerWidth;
    return {
        left: (winWidth - elmWidth) / 2,
        top: (winHeight - elmHeight) / 2
    };
}
/**
 * @param {?=} $event
 * @return {?}
 */
function stopPropagationIfExist($event) {
    if ($event) {
        $event.stopPropagation();
    }
}

/**
 * @fileoverview added by tsickle
 * Generated from: i18n.service.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var I18nService = /** @class */ (function () {
    function I18nService() {
        this.subject = new Subject();
    }
    /**
     * @param {?=} lang
     * @return {?}
     */
    I18nService.prototype.toggleLang = /**
     * @param {?=} lang
     * @return {?}
     */
    function (lang) {
        if (lang === void 0) { lang = 'zhCN'; }
        localStorage.setItem('lang', lang);
        this.subject.next(lang);
        window.location.reload();
    };
    /**
     * @return {?}
     */
    I18nService.prototype.getLangSuffix = /**
     * @return {?}
     */
    function () {
        return localStorage.getItem('lang') === 'enUS' ? 'EN' : 'CN';
    };
    /**
     * @return {?}
     */
    I18nService.prototype.getMessage = /**
     * @return {?}
     */
    function () {
        return this.subject.asObservable();
    };
    I18nService.decorators = [
        { type: Injectable, args: [{
                    providedIn: 'root'
                },] }
    ];
    /** @nocollapse */ I18nService.ngInjectableDef = ɵɵdefineInjectable({ factory: function I18nService_Factory() { return new I18nService(); }, token: I18nService, providedIn: "root" });
    return I18nService;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    I18nService.prototype.subject;
}

/**
 * @fileoverview added by tsickle
 * Generated from: safe.pipe.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var SafePipe = /** @class */ (function () {
    function SafePipe(sanitizer) {
        this.sanitizer = sanitizer;
    }
    /**
     * @param {?} value
     * @param {?} type
     * @return {?}
     */
    SafePipe.prototype.transform = /**
     * @param {?} value
     * @param {?} type
     * @return {?}
     */
    function (value, type) {
        switch (type) {
            case 'html':
                return this.sanitizer.bypassSecurityTrustHtml(value);
            case 'style':
                return this.sanitizer.bypassSecurityTrustStyle(value);
            default:
                throw new Error("Unable to bypass security for invalid type: " + type);
        }
    };
    SafePipe.decorators = [
        { type: Pipe, args: [{ name: 'safe' },] }
    ];
    /** @nocollapse */
    SafePipe.ctorParameters = function () { return [
        { type: DomSanitizer }
    ]; };
    return SafePipe;
}());
if (false) {
    /**
     * @type {?}
     * @private
     */
    SafePipe.prototype.sanitizer;
}

/**
 * @fileoverview added by tsickle
 * Generated from: safe-pipe.module.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var SafePipeModule = /** @class */ (function () {
    function SafePipeModule() {
    }
    SafePipeModule.decorators = [
        { type: NgModule, args: [{
                    declarations: [SafePipe],
                    exports: [SafePipe]
                },] }
    ];
    return SafePipeModule;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: lazy-load/lazy-load.directive.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var LazyLoadDirective = /** @class */ (function () {
    function LazyLoadDirective(el) {
        this.el = el;
        // 启用懒加载，默认不启用
        this.enableLazyLoad = false;
        // 加载更多
        this.loadMore = new EventEmitter();
        // 触发懒加载的距离
        this.loadFactor = 5;
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    LazyLoadDirective.prototype.ngOnChanges = /**
     * @param {?} changes
     * @return {?}
     */
    function (changes) {
        var _this = this;
        if (changes && changes['enableLazyLoad']) {
            if (changes.enableLazyLoad.currentValue) {
                this.scrollSubscription = fromEvent(this.el.nativeElement, 'scroll').pipe(debounceTime(300), distinctUntilChanged()).subscribe((/**
                 * @param {?} event
                 * @return {?}
                 */
                function (event) { return _this.scrollList(event); }));
            }
            else if (this.scrollSubscription) {
                this.scrollSubscription.unsubscribe();
            }
            else {
                return;
            }
        }
    };
    /**
     * @return {?}
     */
    LazyLoadDirective.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        if (this.scrollSubscription) {
            this.scrollSubscription.unsubscribe();
        }
    };
    /**
     * @param {?} event
     * @return {?}
     */
    LazyLoadDirective.prototype.scrollList = /**
     * @param {?} event
     * @return {?}
     */
    function (event) {
        /** @type {?} */
        var targetEl = event.target;
        /** @type {?} */
        var clientHeight = targetEl.clientHeight;
        /** @type {?} */
        var scrollHeight = targetEl.scrollHeight;
        /** @type {?} */
        var scrollTop = targetEl.scrollTop;
        if (scrollTop !== 0 && (scrollTop + clientHeight + this.loadFactor >= scrollHeight)) {
            this.loadMore.emit(event);
        }
    };
    LazyLoadDirective.decorators = [
        { type: Directive, args: [{ selector: '[dLazyLoad]' },] }
    ];
    /** @nocollapse */
    LazyLoadDirective.ctorParameters = function () { return [
        { type: ElementRef }
    ]; };
    LazyLoadDirective.propDecorators = {
        enableLazyLoad: [{ type: Input }],
        loadMore: [{ type: Output }]
    };
    return LazyLoadDirective;
}());
if (false) {
    /** @type {?} */
    LazyLoadDirective.prototype.enableLazyLoad;
    /** @type {?} */
    LazyLoadDirective.prototype.loadMore;
    /** @type {?} */
    LazyLoadDirective.prototype.scrollSubscription;
    /** @type {?} */
    LazyLoadDirective.prototype.loadFactor;
    /**
     * @type {?}
     * @private
     */
    LazyLoadDirective.prototype.el;
}

/**
 * @fileoverview added by tsickle
 * Generated from: lazy-load/lazy-load.module.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var LazyLoadModule = /** @class */ (function () {
    function LazyLoadModule() {
    }
    LazyLoadModule.decorators = [
        { type: NgModule, args: [{
                    imports: [CommonModule],
                    declarations: [LazyLoadDirective],
                    exports: [LazyLoadDirective]
                },] }
    ];
    return LazyLoadModule;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: popper/popper.component.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var PopperComponent = /** @class */ (function () {
    function PopperComponent(el, renderer, ngZone, changeDetectorRef) {
        var _this = this;
        this.el = el;
        this.renderer = renderer;
        this.ngZone = ngZone;
        this.changeDetectorRef = changeDetectorRef;
        this.fluidPopper = true;
        this.appendTo = 'body';
        this.popper = null;
        this._isOpen = false;
        this.directionAnimationTransformOrigin = {
            'top': '0 100%',
            'bottom': '0 0'
        };
        this.openChange = new EventEmitter();
        this.onDocumentClick = (/**
         * @param {?} $event
         * @return {?}
         */
        function ($event) {
            if (!!_this.appendTo && _this.popperContainer.nativeElement !== $event.target &&
                !_this.popperContainer.nativeElement.contains($event.target)) {
                _this.open = false;
            }
            else if (!_this.appendTo && _this.open && !_this.el.nativeElement.contains($event.target)) {
                _this.open = false;
            }
        });
        this.blockEvent = (/**
         * @param {?} $event
         * @return {?}
         */
        function ($event) {
            $event.preventDefault();
            $event.stopPropagation();
        });
    }
    Object.defineProperty(PopperComponent.prototype, "open", {
        get: /**
         * @return {?}
         */
        function () {
            return this._isOpen;
        },
        set: /**
         * @param {?} value
         * @return {?}
         */
        function (value) {
            var _this = this;
            if (this._isOpen === value) {
                return;
            }
            this.animate = true;
            if (!!value) {
                this.show();
            }
            else {
                this.close();
            }
            this._isOpen = value;
            PopperComponent.nextTick((/**
             * @return {?}
             */
            function () {
                _this.openChange.emit(value);
                _this.setBlurListener();
            }));
        },
        enumerable: true,
        configurable: true
    });
    /**
     * @param {?} fn
     * @return {?}
     */
    PopperComponent.nextTick = /**
     * @param {?} fn
     * @return {?}
     */
    function (fn) {
        var _this = this;
        // Force to run fn after current data changed.
        setTimeout((/**
         * @return {?}
         */
        function () { return fn.bind(_this)(); }));
    };
    /**
     * @return {?}
     */
    PopperComponent.prototype.show = /**
     * @return {?}
     */
    function () {
        var e_1, _a;
        // Append to selector or original parent.
        if (!!this.appendTo) {
            if (this.fluidPopper) {
                /** @type {?} */
                var popperWidth = this.popperActivator.nativeElement && this.popperActivator.nativeElement.offsetWidth;
                /** @type {?} */
                var firstEle = this.popperContainer.nativeElement.firstElementChild;
                if (firstEle.classList.contains('devui-search-container')) {
                    try {
                        for (var _b = __values(this.popperContainer.nativeElement.children), _c = _b.next(); !_c.done; _c = _b.next()) {
                            var child = _c.value;
                            child.style.width = popperWidth + "px";
                        }
                    }
                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
                    finally {
                        try {
                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                        }
                        finally { if (e_1) throw e_1.error; }
                    }
                }
                else {
                    firstEle.style.width = popperWidth + "px";
                }
            }
            this.attachPopperContainerToSelector(this.appendTo);
        }
        else {
            this.attachPopperContainerToNode(this.popperParent);
        }
        this.popper = this.createPopper();
        this.renderer.setStyle(this.popperContainer.nativeElement, 'display', 'block');
    };
    /**
     * @private
     * @return {?}
     */
    PopperComponent.prototype.close = /**
     * @private
     * @return {?}
     */
    function () {
        /** @type {?} */
        var popperContainer = this.popperContainer.nativeElement;
        this.setTransition('close');
        // For IE 11/Edge
        if (popperContainer.style.transform.match(/scale3d\(1, 1, 1\)/)) {
            // Replace transform open state with close state
            this.renderer.setStyle(popperContainer, 'transform', popperContainer.style.transform.replace('scale3d(1, 1, 1)', 'scale3d(1, 0, 1)'));
        }
        else {
            // perspective(1px) solves pixel shift caused by webkit transform
            this.renderer.setStyle(popperContainer, 'transform', popperContainer.style.transform + " scale3d(1, 0, 1) perspective(1px)");
        }
        // Set container to transparent
        this.renderer.setStyle(popperContainer, 'opacity', 0);
        // Can't use bind(this) since it calls itself
        /** @type {?} */
        var that = this;
        /** @type {?} */
        var handler = (/**
         * @param {?} e
         * @return {?}
         */
        function (e) {
            if (!that.open && that.popper) {
                // Set final state of container to invisible
                that.renderer.setStyle(popperContainer, 'display', 'none');
                that.animate = false;
                // Remove transition
                that.setTransition();
                that.popper.destroy();
                that.popper = null;
                that.detachPopperContainer();
            }
            e.currentTarget.removeEventListener(e.type, handler);
        });
        this.popperContainer.nativeElement.addEventListener('transitionend', handler);
    };
    /**
     * @return {?}
     */
    PopperComponent.prototype.setBlurListener = /**
     * @return {?}
     */
    function () {
        var _this = this;
        this.ngZone.runOutsideAngular((/**
         * @return {?}
         */
        function () {
            if (_this.open) {
                document.addEventListener('click', _this.onDocumentClick);
                _this.popperContainer.nativeElement.addEventListener('click', _this.blockEvent);
            }
            else {
                document.removeEventListener('click', _this.onDocumentClick);
                _this.popperContainer.nativeElement.removeEventListener('click', _this.blockEvent);
            }
        }));
    };
    /**
     * @private
     * @param {?} data
     * @return {?}
     */
    PopperComponent.prototype.applyTransitionStyle = /**
     * @private
     * @param {?} data
     * @return {?}
     */
    function (data) {
        var _this = this;
        /** @type {?} */
        var optionsContainer = this.popperContainer.nativeElement;
        this.updateContainerTransitionDirection(data.flipped);
        if (this.animate) {
            // perspective(1px) solves pixel shift caused by webkit transform
            this.renderer.setStyle(optionsContainer, 'transform', optionsContainer.style.transform + " scale3d(1, 0, 1) perspective(1px)");
            // Set container init state to transparent as beginning of the transition.
            this.renderer.setStyle(optionsContainer, 'opacity', 0);
            PopperComponent.nextTick((/**
             * @return {?}
             */
            function () {
                _this.setTransition('open');
                /** @type {?} */
                var that = _this;
                /** @type {?} */
                var handler = (/**
                 * @param {?} e
                 * @return {?}
                 */
                function (e) {
                    // remove transition
                    that.setTransition();
                    e.currentTarget.removeEventListener(e.type, handler);
                });
                optionsContainer.addEventListener('transitionend', handler);
                _this.renderer.setStyle(optionsContainer, 'transform', optionsContainer.style.transform.replace('scale3d(1, 0, 1)', 'scale3d(1, 1, 1)'));
                _this.renderer.setStyle(optionsContainer, 'opacity', 1);
                _this.animate = false;
            }));
        }
        else {
            // handle popper re-rendering, incoming transform doesn't have scale info
            this.renderer.setStyle(optionsContainer, 'transform', optionsContainer.style.transform + (this.open ? ' scale3d(1, 1, 1)' : ' scale3d(1, 0, 1)') + ' perspective(1px)');
        }
    };
    /**
     * @private
     * @param {?} flipped
     * @return {?}
     */
    PopperComponent.prototype.updateContainerTransitionDirection = /**
     * @private
     * @param {?} flipped
     * @return {?}
     */
    function (flipped) {
        /** @type {?} */
        var direction = flipped ? 'top' : 'bottom';
        if (this.popperDirection !== direction) {
            this.popperDirection = direction;
            this.setTransitionOrigin();
        }
    };
    /**
     * @private
     * @return {?}
     */
    PopperComponent.prototype.setTransitionOrigin = /**
     * @private
     * @return {?}
     */
    function () {
        if (this.popperContainer.nativeElement) {
            this.renderer.setStyle(this.popperContainer.nativeElement, 'transform-origin', this.directionAnimationTransformOrigin[this.popperDirection]);
        }
    };
    /**
     * @private
     * @return {?}
     */
    PopperComponent.prototype.createPopper = /**
     * @private
     * @return {?}
     */
    function () {
        return new Popper(this.popperActivator.nativeElement, this.popperContainer.nativeElement, (/** @type {?} */ ({
            placement: 'bottom-start',
            modifiers: {
                preventOverflow: {
                    // Do not stick to the window edge
                    escapeWithReference: true,
                },
                applyReactStyle: {
                    enabled: true,
                    // Apply extra transition and transform to popper
                    fn: this.applyTransitionStyle.bind(this),
                },
                offset: {
                    // Set vertical offset 5px
                    offset: '0, 5px'
                }
            },
            positionFixed: !!this.appendTo
        })));
    };
    /**
     * @private
     * @param {?=} command
     * @return {?}
     */
    PopperComponent.prototype.setTransition = /**
     * @private
     * @param {?=} command
     * @return {?}
     */
    function (command) {
        if (command === void 0) { command = null; }
        /** @type {?} */
        var popperContainer = this.popperContainer.nativeElement;
        if (this.animate && command) {
            if (command === 'open') {
                this.renderer.setStyle(popperContainer, 'transition', 'transform .2s cubic-bezier(0.23, 1, 0.32, 1)');
            }
            else if (command === 'close') {
                popperContainer.style.transition = 'all .15s cubic-bezier(0.755, 0.05, 0.855, 0.06)';
            }
        }
        else {
            this.renderer.setStyle(popperContainer, 'transition', null);
        }
    };
    /**
     * @return {?}
     */
    PopperComponent.prototype.update = /**
     * @return {?}
     */
    function () {
        var _this = this;
        PopperComponent.nextTick((/**
         * @return {?}
         */
        function () {
            if (_this.popper) {
                _this.popper.update();
            }
        }));
    };
    /**
     * @return {?}
     */
    PopperComponent.prototype.ngOnDestroy = /**
     * @return {?}
     */
    function () {
        // Close popper
        this.open = false;
    };
    /**
     * @private
     * @return {?}
     */
    PopperComponent.prototype.detachPopperContainer = /**
     * @private
     * @return {?}
     */
    function () {
        // Cache popper's parent and popper node.
        this.popperParent = this.popperContainer.nativeElement.parentNode;
        this.popperNode = this.popperContainer.nativeElement;
        if (this.popperParent && this.popperNode) {
            this.popperParent.removeChild(this.popperNode);
        }
    };
    /**
     * @private
     * @param {?} nodeParent
     * @return {?}
     */
    PopperComponent.prototype.attachPopperContainerToNode = /**
     * @private
     * @param {?} nodeParent
     * @return {?}
     */
    function (nodeParent) {
        if (nodeParent && this.popperNode) {
            this.popperParent = nodeParent;
            this.popperParent.appendChild(this.popperNode);
        }
    };
    /**
     * @private
     * @param {?} targetSelector
     * @return {?}
     */
    PopperComponent.prototype.attachPopperContainerToSelector = /**
     * @private
     * @param {?} targetSelector
     * @return {?}
     */
    function (targetSelector) {
        /** @type {?} */
        var nodeParent = document.querySelector(targetSelector);
        this.attachPopperContainerToNode(nodeParent);
    };
    /**
     * @return {?}
     */
    PopperComponent.prototype.ngAfterViewInit = /**
     * @return {?}
     */
    function () {
        // Detach popper container once view initialized.
        this.detachPopperContainer();
    };
    PopperComponent.decorators = [
        { type: Component, args: [{
                    // tslint:disable-next-line:component-selector
                    selector: 'popper-component',
                    template: "<div class=\"popper\">\r\n  <div class=\"popper-activator\" #popperActivator>\r\n    <ng-content select=\"[popper-activator]\"></ng-content>\r\n  </div>\r\n  <div class=\"popper-container\" #popperContainer [ngClass]=\"{ fluid: fluidPopper && !appendTo }\">\r\n    <ng-content select=\"[popper-prepend]\"></ng-content>\r\n    <div class=\"popper-container-scrollable devui-scrollbar\">\r\n      <ng-content select=\"[popper-container]\"></ng-content>\r\n    </div>\r\n    <ng-content select=\"[popper-append]\"></ng-content>\r\n  </div>\r\n</div>\r\n",
                    styles: [".popper{position:relative;width:100%}.popper .popper-activator{width:100%}.popper-container{display:none;z-index:1051;position:absolute;box-shadow:0 4px 8px 0 rgba(41,48,64,.2);background:#fff;border:none;backface-visibility:hidden;-webkit-backface-visibility:hidden}.popper-container .popper-container-scrollable{max-height:300px;min-height:40px;width:100%;overflow-y:auto;overflow-x:auto}.popper-container.fluid{width:100%}:host{display:block}"]
                }] }
    ];
    /** @nocollapse */
    PopperComponent.ctorParameters = function () { return [
        { type: ElementRef },
        { type: Renderer2 },
        { type: NgZone },
        { type: ChangeDetectorRef }
    ]; };
    PopperComponent.propDecorators = {
        open: [{ type: Input }],
        fluidPopper: [{ type: Input }],
        appendTo: [{ type: Input }],
        openChange: [{ type: Output }],
        popperActivator: [{ type: ViewChild, args: ['popperActivator', { static: true },] }],
        popperContainer: [{ type: ViewChild, args: ['popperContainer', { static: true },] }]
    };
    return PopperComponent;
}());
if (false) {
    /** @type {?} */
    PopperComponent.prototype.fluidPopper;
    /** @type {?} */
    PopperComponent.prototype.appendTo;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.popper;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype._isOpen;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.animate;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.popperDirection;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.directionAnimationTransformOrigin;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.popperNode;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.popperParent;
    /** @type {?} */
    PopperComponent.prototype.openChange;
    /** @type {?} */
    PopperComponent.prototype.popperActivator;
    /** @type {?} */
    PopperComponent.prototype.popperContainer;
    /** @type {?} */
    PopperComponent.prototype.onDocumentClick;
    /**
     * @type {?}
     * @private
     */
    PopperComponent.prototype.blockEvent;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.el;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.renderer;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.ngZone;
    /**
     * @type {?}
     * @protected
     */
    PopperComponent.prototype.changeDetectorRef;
}

/**
 * @fileoverview added by tsickle
 * Generated from: popper/popper.module.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var PopperModule = /** @class */ (function () {
    function PopperModule() {
    }
    PopperModule.decorators = [
        { type: NgModule, args: [{
                    imports: [CommonModule],
                    declarations: [PopperComponent],
                    exports: [PopperComponent]
                },] }
    ];
    return PopperModule;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: cdk-overlay-config.type.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var AppendToBodyDirectionsConfig = {
    'rightDown': {
        originX: 'start',
        originY: 'bottom',
        overlayX: 'start',
        overlayY: 'top'
    },
    'rightUp': {
        originX: 'start',
        originY: 'top',
        overlayX: 'start',
        overlayY: 'bottom'
    },
    'leftUp': {
        originX: 'end',
        originY: 'top',
        overlayX: 'end',
        overlayY: 'bottom'
    },
    'leftDown': {
        originX: 'end',
        originY: 'bottom',
        overlayX: 'end',
        overlayY: 'top'
    },
    'centerDown': {
        originX: 'center',
        originY: 'bottom',
        overlayX: 'center',
        overlayY: 'top'
    },
    'centerUp': {
        originX: 'center',
        originY: 'top',
        overlayX: 'center',
        overlayY: 'bottom'
    }
};

/**
 * @fileoverview added by tsickle
 * Generated from: animations/fadeInOut.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var fadeInOut = trigger('fadeInOut', [
    state('void', style({ transform: 'perspective(1px) scaleY(0)', opacity: 0, transformOrigin: '0% 0%', display: 'block' })),
    state('bottom', style({ transform: 'perspective(1px) scaleY(1)', opacity: 1, transformOrigin: '0% 0%', display: 'block' })),
    state('top', style({ transform: 'perspective(1px) scaleY(1)', opacity: 1, transformOrigin: '0% 100%', display: 'block' })),
    transition('void => bottom', [
        animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
    ]),
    transition('bottom => void', [
        animate('200ms cubic-bezier(0.755, 0.05, 0.855, 0.06)')
    ]),
    transition('void => top', [
        style({ transform: 'perspective(1px) scaleY(0)', opacity: 0, transformOrigin: '0% 100%', display: 'block' }),
        animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
    ]),
    transition('top => void', animate('150ms cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'perspective(1px) scaleY(0)', opacity: 0, transformOrigin: '0% 100%', display: 'block' })))
]);

/**
 * @fileoverview added by tsickle
 * Generated from: animations/popInOut.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var isIE = window.navigator.userAgent.indexOf('MSIE ') > -1 ||
    window.navigator.userAgent.indexOf('Trident') > -1;
/** @type {?} */
var ANIMATION = [
    state('void', style({ transform: 'scale(0)', transformOrigin: '50% 50%' })),
    state('in', style({ transform: 'scale(1)', transformOrigin: '50% 50%' })),
    transition('void => in', [
        animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
    ]),
    transition('in => void', [
        animate('200ms cubic-bezier(0.755, 0.05, 0.855, 0.06)')
    ]),
];
if (isIE) {
    ANIMATION.splice(2, 2); // remove last two animation transitions
}
/** @type {?} */
var popInOut = trigger('popInOut', ANIMATION);

/**
 * @fileoverview added by tsickle
 * Generated from: animations/directionFadeInOut.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var directionFadeInOut = trigger('directionFadeInOut', [
    state('void', style({ opacity: 0 })),
    state('visible', style({ opacity: 1 })),
    state('bottom', style({ opacity: 1 })),
    state('top', style({ opacity: 1 })),
    state('left', style({ opacity: 1 })),
    state('right', style({ opacity: 1 })),
    transition('* => bottom', [
        style({ transform: 'translateY(-5px)', opacity: 0 }),
        animate('.3s cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'translateY(0)', opacity: 1 }))
    ]),
    transition('bottom => void', [
        style({ transform: 'translateY(0)', opacity: 1 }),
        animate('.3s cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'translateY(-5px)', opacity: 0 }))
    ]),
    transition('* => top', [
        style({ transform: 'translateY(5px)', opacity: 0 }),
        animate('.3s cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'translateY(0)', opacity: 1 }))
    ]),
    transition('top => void', [
        style({ transform: 'translateY(0)', opacity: 1 }),
        animate('.3s cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'translateY(5px)', opacity: 0 }))
    ]),
    transition('* => left', [
        style({ transform: 'translateX(5px)', opacity: 0 }),
        animate('.3s cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'translateX(0)', opacity: 1 }))
    ]),
    transition('left => void', [
        style({ transform: 'translateX(0)', opacity: 1 }),
        animate('.3s cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'translateX(5px)', opacity: 0 }))
    ]),
    transition('* => right', [
        style({ transform: 'translateX(-5px)', opacity: 0 }),
        animate('.3s cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'translateX(0)', opacity: 1 }))
    ]),
    transition('right => void', [
        style({ transform: 'translateX(0)', opacity: 1 }),
        animate('.3s cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'translateX(-5px)', opacity: 0 }))
    ]),
    transition('void => visible', animate('.15s cubic-bezier(0.0, 0.0, 0.2, 1)')),
    transition('visible => void', animate('.15s cubic-bezier(0.0, 0.0, 0.2, 1)'))
]);

/**
 * @fileoverview added by tsickle
 * Generated from: animations/cornerFadeInOut.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
var cornerFadeInOut = trigger('cornerFadeInOut', [
    transition('void => bottom', [
        style({ transform: 'scale(0.9)', opacity: 0, transformOrigin: '0% 0%', display: 'inline-block' }),
        animate('200ms cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'scale(1)', opacity: 1, transformOrigin: '0% 0%' })),
    ]),
    transition('bottom => void', [
        style({ transform: 'scale(1)', opacity: 1, transformOrigin: '0% 0%', display: 'inline-block' }),
        animate('200ms cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'scale(0.9)', opacity: 0, transformOrigin: '0% 0%' }))
    ]),
    transition('void => top', [
        style({ transform: 'scale(0.9)', opacity: 0, transformOrigin: '0% 100%', display: 'inline-block' }),
        animate('200ms cubic-bezier(0.23, 1, 0.32, 1)', style({ transform: 'scale(1)', opacity: 1, transformOrigin: '0% 100%' })),
    ]),
    transition('top => void', [
        style({ transform: 'scale(1)', opacity: 1, transformOrigin: '0% 100%', display: 'inline-block' }),
        animate('200ms cubic-bezier(0.755, 0.05, 0.855, 0.06)', style({ transform: 'scale(0.9)', opacity: 0, transformOrigin: '0% 100%' }))
    ])
]);

/**
 * @fileoverview added by tsickle
 * Generated from: animations/index.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * Generated from: tree-utils.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
var TreeUtils = /** @class */ (function () {
    function TreeUtils() {
    }
    // 动态添加styles
    // 动态添加styles
    /**
     * @param {?} el
     * @param {?} styles
     * @return {?}
     */
    TreeUtils.addElStyles = 
    // 动态添加styles
    /**
     * @param {?} el
     * @param {?} styles
     * @return {?}
     */
    function (el, styles) {
        if (styles instanceof Object) {
            var _loop_1 = function (s) {
                if (styles.hasOwnProperty(s)) {
                    if (Array.isArray(styles[s])) {
                        // 用于支持兼容渐退
                        styles[s].forEach((/**
                         * @param {?} val
                         * @return {?}
                         */
                        function (val) {
                            el.style[s] = val;
                        }));
                    }
                    else {
                        el.style[s] = styles[s];
                    }
                }
            };
            for (var s in styles) {
                _loop_1(s);
            }
        }
    };
    return TreeUtils;
}());

/**
 * @fileoverview added by tsickle
 * Generated from: public-api.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

/**
 * @fileoverview added by tsickle
 * Generated from: ng-devui-utils.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */

export { AppendToBodyDirectionsConfig, DefaultDateConverter, I18nService, LazyLoadDirective, LazyLoadModule, PopperComponent, PopperModule, SafePipe, SafePipeModule, TreeUtils, centerWindowPosition, cornerFadeInOut, directionFadeInOut, fadeInOut, formatDate, isValidDate, parseDate, popInOut, stopPropagationIfExist };
//# sourceMappingURL=ng-devui-utils.js.map