@duoduo-oba/ng-devui
Version:
DevUI components based on Angular
1,266 lines (1,226 loc) • 56.8 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('date-fns/is_date'), require('date-fns/parse'), require('date-fns/format'), require('ng-devui/i18n'), require('@angular/core'), require('rxjs'), require('@angular/platform-browser'), require('@angular/common'), require('rxjs/operators'), require('popper.js'), require('@angular/animations')) :
typeof define === 'function' && define.amd ? define('ng-devui/utils', ['exports', 'date-fns/is_date', 'date-fns/parse', 'date-fns/format', 'ng-devui/i18n', '@angular/core', 'rxjs', '@angular/platform-browser', '@angular/common', 'rxjs/operators', 'popper.js', '@angular/animations'], factory) :
(global = global || self, factory((global['ng-devui'] = global['ng-devui'] || {}, global['ng-devui'].utils = {}), global.isDate_, global.dateParse_, global.dateFormat_, global['ng-devui'].i18n, global.ng.core, global.rxjs, global.ng.platformBrowser, global.ng.common, global.rxjs.operators, global.Popper, global.ng.animations));
}(this, (function (exports, isDate_, dateParse_, dateFormat_, i18n, core, rxjs, platformBrowser, common, operators, Popper, animations) { 'use strict';
Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper;
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
/**
* @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 i18n.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 i18n.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 rxjs.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: core.Injectable, args: [{
providedIn: 'root'
},] }
];
/** @nocollapse */ I18nService.ngInjectableDef = core.ɵɵ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: core.Pipe, args: [{ name: 'safe' },] }
];
/** @nocollapse */
SafePipe.ctorParameters = function () { return [
{ type: platformBrowser.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: core.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 core.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 = rxjs.fromEvent(this.el.nativeElement, 'scroll').pipe(operators.debounceTime(300), operators.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: core.Directive, args: [{ selector: '[dLazyLoad]' },] }
];
/** @nocollapse */
LazyLoadDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
LazyLoadDirective.propDecorators = {
enableLazyLoad: [{ type: core.Input }],
loadMore: [{ type: core.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: core.NgModule, args: [{
imports: [common.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 core.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: core.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: core.ElementRef },
{ type: core.Renderer2 },
{ type: core.NgZone },
{ type: core.ChangeDetectorRef }
]; };
PopperComponent.propDecorators = {
open: [{ type: core.Input }],
fluidPopper: [{ type: core.Input }],
appendTo: [{ type: core.Input }],
openChange: [{ type: core.Output }],
popperActivator: [{ type: core.ViewChild, args: ['popperActivator', { static: true },] }],
popperContainer: [{ type: core.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: core.NgModule, args: [{
imports: [common.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 = animations.trigger('fadeInOut', [
animations.state('void', animations.style({ transform: 'perspective(1px) scaleY(0)', opacity: 0, transformOrigin: '0% 0%', display: 'block' })),
animations.state('bottom', animations.style({ transform: 'perspective(1px) scaleY(1)', opacity: 1, transformOrigin: '0% 0%', display: 'block' })),
animations.state('top', animations.style({ transform: 'perspective(1px) scaleY(1)', opacity: 1, transformOrigin: '0% 100%', display: 'block' })),
animations.transition('void => bottom', [
animations.animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
]),
animations.transition('bottom => void', [
animations.animate('200ms cubic-bezier(0.755, 0.05, 0.855, 0.06)')
]),
animations.transition('void => top', [
animations.style({ transform: 'perspective(1px) scaleY(0)', opacity: 0, transformOrigin: '0% 100%', display: 'block' }),
animations.animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
]),
animations.transition('top => void', animations.animate('150ms cubic-bezier(0.755, 0.05, 0.855, 0.06)', animations.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 = [
animations.state('void', animations.style({ transform: 'scale(0)', transformOrigin: '50% 50%' })),
animations.state('in', animations.style({ transform: 'scale(1)', transformOrigin: '50% 50%' })),
animations.transition('void => in', [
animations.animate('200ms cubic-bezier(0.23, 1, 0.32, 1)')
]),
animations.transition('in => void', [
animations.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 = animations.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 = animations.trigger('directionFadeInOut', [
animations.state('void', animations.style({ opacity: 0 })),
animations.state('visible', animations.style({ opacity: 1 })),
animations.state('bottom', animations.style({ opacity: 1 })),
animations.state('top', animations.style({ opacity: 1 })),
animations.state('left', animations.style({ opacity: 1 })),
animations.state('right', animations.style({ opacity: 1 })),
animations.transition('* => bottom', [
animations.style({ transform: 'translateY(-5px)', opacity: 0 }),
animations.animate('.3s cubic-bezier(0.23, 1, 0.32, 1)', animations.style({ transform: 'translateY(0)', opacity: 1 }))
]),