@duoduo-oba/ng-devui/fesm2015/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 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 {?} */
const isDate = isDate_;
/** @type {?} */
const dateParse = dateParse_;
/** @type {?} */
const 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 {?} */
    const parsedDate = dateParse(date);
    return isValidDate(parsedDate) ? parsedDate : null;
}
/**
 * @param {?} date
 * @param {?=} pattern
 * @return {?}
 */
function formatDate(date, 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
 */
class DefaultDateConverter {
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    parse(date, pattern, locale) {
        return parseDate(date);
    }
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    format(date, pattern, locale) {
        return I18nFormat.formatDate(date, pattern, locale);
    }
    /**
     * @param {?} date
     * @param {?=} pattern
     * @param {?=} locale
     * @return {?}
     */
    formatDateTime(date, pattern, locale) {
        return I18nFormat.formatDateTimeWithoutGMT(date, pattern, locale);
    }
}

/**
 * @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 {?} */
    const rect = elementRef.nativeElement.getBoundingClientRect();
    /** @type {?} */
    const elmHeight = rect.height;
    /** @type {?} */
    const elmWidth = rect.width;
    /** @type {?} */
    const winHeight = windowRef.innerHeight;
    /** @type {?} */
    const 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
 */
class I18nService {
    constructor() {
        this.subject = new Subject();
    }
    /**
     * @param {?=} lang
     * @return {?}
     */
    toggleLang(lang = 'zhCN') {
        localStorage.setItem('lang', lang);
        this.subject.next(lang);
        window.location.reload();
    }
    /**
     * @return {?}
     */
    getLangSuffix() {
        return localStorage.getItem('lang') === 'enUS' ? 'EN' : 'CN';
    }
    /**
     * @return {?}
     */
    getMessage() {
        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" });
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
 */
class SafePipe {
    /**
     * @param {?} sanitizer
     */
    constructor(sanitizer) {
        this.sanitizer = sanitizer;
    }
    /**
     * @param {?} value
     * @param {?} type
     * @return {?}
     */
    transform(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 = () => [
    { type: DomSanitizer }
];
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
 */
class SafePipeModule {
}
SafePipeModule.decorators = [
    { type: NgModule, args: [{
                declarations: [SafePipe],
                exports: [SafePipe]
            },] }
];

/**
 * @fileoverview added by tsickle
 * Generated from: lazy-load/lazy-load.directive.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class LazyLoadDirective {
    /**
     * @param {?} el
     */
    constructor(el) {
        this.el = el;
        // 启用懒加载，默认不启用
        this.enableLazyLoad = false;
        // 加载更多
        this.loadMore = new EventEmitter();
        // 触发懒加载的距离
        this.loadFactor = 5;
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        if (changes && changes['enableLazyLoad']) {
            if (changes.enableLazyLoad.currentValue) {
                this.scrollSubscription = fromEvent(this.el.nativeElement, 'scroll').pipe(debounceTime(300), distinctUntilChanged()).subscribe((/**
                 * @param {?} event
                 * @return {?}
                 */
                event => this.scrollList(event)));
            }
            else if (this.scrollSubscription) {
                this.scrollSubscription.unsubscribe();
            }
            else {
                return;
            }
        }
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        if (this.scrollSubscription) {
            this.scrollSubscription.unsubscribe();
        }
    }
    /**
     * @param {?} event
     * @return {?}
     */
    scrollList(event) {
        /** @type {?} */
        const targetEl = event.target;
        /** @type {?} */
        const clientHeight = targetEl.clientHeight;
        /** @type {?} */
        const scrollHeight = targetEl.scrollHeight;
        /** @type {?} */
        const 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 = () => [
    { type: ElementRef }
];
LazyLoadDirective.propDecorators = {
    enableLazyLoad: [{ type: Input }],
    loadMore: [{ type: Output }]
};
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
 */
class LazyLoadModule {
}
LazyLoadModule.decorators = [
    { type: NgModule, args: [{
                imports: [CommonModule],
                declarations: [LazyLoadDirective],
                exports: [LazyLoadDirective]
            },] }
];

/**
 * @fileoverview added by tsickle
 * Generated from: popper/popper.component.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
class PopperComponent {
    /**
     * @param {?} el
     * @param {?} renderer
     * @param {?} ngZone
     * @param {?} changeDetectorRef
     */
    constructor(el, renderer, ngZone, changeDetectorRef) {
        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 {?}
         */
        ($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 {?}
         */
        ($event) => {
            $event.preventDefault();
            $event.stopPropagation();
        });
    }
    /**
     * @return {?}
     */
    get open() {
        return this._isOpen;
    }
    /**
     * @param {?} value
     * @return {?}
     */
    set open(value) {
        if (this._isOpen === value) {
            return;
        }
        this.animate = true;
        if (!!value) {
            this.show();
        }
        else {
            this.close();
        }
        this._isOpen = value;
        PopperComponent.nextTick((/**
         * @return {?}
         */
        () => {
            this.openChange.emit(value);
            this.setBlurListener();
        }));
    }
    /**
     * @param {?} fn
     * @return {?}
     */
    static nextTick(fn) {
        // Force to run fn after current data changed.
        setTimeout((/**
         * @return {?}
         */
        () => fn.bind(this)()));
    }
    /**
     * @return {?}
     */
    show() {
        // Append to selector or original parent.
        if (!!this.appendTo) {
            if (this.fluidPopper) {
                /** @type {?} */
                const popperWidth = this.popperActivator.nativeElement && this.popperActivator.nativeElement.offsetWidth;
                /** @type {?} */
                const firstEle = this.popperContainer.nativeElement.firstElementChild;
                if (firstEle.classList.contains('devui-search-container')) {
                    for (const child of this.popperContainer.nativeElement.children) {
                        child.style.width = `${popperWidth}px`;
                    }
                }
                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 {?}
     */
    close() {
        /** @type {?} */
        const 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 {?} */
        const that = this;
        /** @type {?} */
        const 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 {?}
     */
    setBlurListener() {
        this.ngZone.runOutsideAngular((/**
         * @return {?}
         */
        () => {
            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 {?}
     */
    applyTransitionStyle(data) {
        /** @type {?} */
        const 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 {?}
             */
            () => {
                this.setTransition('open');
                /** @type {?} */
                const that = this;
                /** @type {?} */
                const 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 {?}
     */
    updateContainerTransitionDirection(flipped) {
        /** @type {?} */
        const direction = flipped ? 'top' : 'bottom';
        if (this.popperDirection !== direction) {
            this.popperDirection = direction;
            this.setTransitionOrigin();
        }
    }
    /**
     * @private
     * @return {?}
     */
    setTransitionOrigin() {
        if (this.popperContainer.nativeElement) {
            this.renderer.setStyle(this.popperContainer.nativeElement, 'transform-origin', this.directionAnimationTransformOrigin[this.popperDirection]);
        }
    }
    /**
     * @private
     * @return {?}
     */
    createPopper() {
        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 {?}
     */
    setTransition(command = null) {
        /** @type {?} */
        const 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 {?}
     */
    update() {
        PopperComponent.nextTick((/**
         * @return {?}
         */
        () => {
            if (this.popper) {
                this.popper.update();
            }
        }));
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        // Close popper
        this.open = false;
    }
    /**
     * @private
     * @return {?}
     */
    detachPopperContainer() {
        // 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 {?}
     */
    attachPopperContainerToNode(nodeParent) {
        if (nodeParent && this.popperNode) {
            this.popperParent = nodeParent;
            this.popperParent.appendChild(this.popperNode);
        }
    }
    /**
     * @private
     * @param {?} targetSelector
     * @return {?}
     */
    attachPopperContainerToSelector(targetSelector) {
        /** @type {?} */
        const nodeParent = document.querySelector(targetSelector);
        this.attachPopperContainerToNode(nodeParent);
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        // 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 = () => [
    { 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 },] }]
};
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
 */
class PopperModule {
}
PopperModule.decorators = [
    { type: NgModule, args: [{
                imports: [CommonModule],
                declarations: [PopperComponent],
                exports: [PopperComponent]
            },] }
];

/**
 * @fileoverview added by tsickle
 * Generated from: cdk-overlay-config.type.ts
 * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
/** @type {?} */
const 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 {?} */
const 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 {?} */
const isIE = window.navigator.userAgent.indexOf('MSIE ') > -1 ||
    window.navigator.userAgent.indexOf('Trident') > -1;
/** @type {?} */
const 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 {?} */
const 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 {?} */
const 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 {?} */
const 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
 */
class TreeUtils {
    // 动态添加styles
    /**
     * @param {?} el
     * @param {?} styles
     * @return {?}
     */
    static addElStyles(el, styles) {
        if (styles instanceof Object) {
            for (const s in styles) {
                if (styles.hasOwnProperty(s)) {
                    if (Array.isArray(styles[s])) {
                        // 用于支持兼容渐退
                        styles[s].forEach((/**
                         * @param {?} val
                         * @return {?}
                         */
                        val => {
                            el.style[s] = val;
                        }));
                    }
                    else {
                        el.style[s] = styles[s];
                    }
                }
            }
        }
    }
}

/**
 * @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