ad-custom-lib
Version:
This is an UI custom library based on Adminlte library with purpose for personal use, if you need a full template of Primeng please visit https://github.com/mledour/angular-admin-lte
6,783 lines • 261 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/common'), require('@angular/core'), require('@angular/router'), require('rxjs'), require('@angular/platform-browser'), require('rxjs/operators'), require('@angular/forms')) :
typeof define === 'function' && define.amd ? define('ad-custom-lib', ['exports', '@angular/common', '@angular/core', '@angular/router', 'rxjs', '@angular/platform-browser', 'rxjs/operators', '@angular/forms'], factory) :
(global = global || self, factory(global['ad-custom-lib'] = {}, global.ng.common, global.ng.core, global.ng.router, global.rxjs, global.ng.platformBrowser, global.rxjs.operators, global.ng.forms));
}(this, function (exports, common, core, router, rxjs, platformBrowser, operators, forms) { 'use strict';
/*! *****************************************************************************
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
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function Path() { }
if (false) {
/** @type {?} */
Path.prototype.data;
/** @type {?} */
Path.prototype.params;
/** @type {?} */
Path.prototype.url;
}
/**
* @record
*/
function Paths() { }
/*
*
*/
var RoutingService = /** @class */ (function () {
/**
* @method constructor
* @param router [description]
*/
function RoutingService(router) {
this.router = router;
this.onChange = new rxjs.BehaviorSubject(undefined);
this.events = new rxjs.BehaviorSubject(undefined);
this.init();
}
/**
* [createUrl description]
* @method createUrl
* @param route [description]
* @return [description]
*/
/**
* [createUrl description]
* \@method createUrl
* @private
* @param {?} route [description]
* @return {?} [description]
*/
RoutingService.createUrl = /**
* [createUrl description]
* \@method createUrl
* @private
* @param {?} route [description]
* @return {?} [description]
*/
function (route) {
/** @type {?} */
var url = route.url.map((/**
* @param {?} urlSegment
* @return {?}
*/
function (urlSegment) { return urlSegment.toString(); })).join('/');
return url;
};
/**
* [isChildrenSelfRoute description]
* @method isChildrenSelfRoute
* @param route [description]
* @return [description]
*/
/**
* [isChildrenSelfRoute description]
* \@method isChildrenSelfRoute
* @private
* @param {?} route [description]
* @return {?} [description]
*/
RoutingService.isChildrenSelfRoute = /**
* [isChildrenSelfRoute description]
* \@method isChildrenSelfRoute
* @private
* @param {?} route [description]
* @return {?} [description]
*/
function (route) {
route.routeConfig.children.forEach((/**
* @param {?} child
* @return {?}
*/
function (child) {
if (child.path === '' && (child.component || child.loadChildren)) {
return true;
}
}));
return false;
};
/**
* [createBreadcrumb description]
* @method createBreadcrumb
* @param route [description]
* @param url [description]
* @return [description]
*/
/**
* [createBreadcrumb description]
* \@method createBreadcrumb
* @private
* @param {?} route [description]
* @param {?} url [description]
* @return {?} [description]
*/
RoutingService.createBreadcrumb = /**
* [createBreadcrumb description]
* \@method createBreadcrumb
* @private
* @param {?} route [description]
* @param {?} url [description]
* @return {?} [description]
*/
function (route, url) {
/** @type {?} */
var isUrl = true;
if (route.children.length !== 0 && route.firstChild.routeConfig.path) {
if (url !== '/' && !route.routeConfig.loadChildren && !route.routeConfig.component && !RoutingService.isChildrenSelfRoute(route)) {
isUrl = false;
}
}
return {
data: route.data,
params: route.params,
url: isUrl ? url : null
};
};
/**
* [init description]
* @method init
*/
/**
* [init description]
* \@method init
* @private
* @return {?}
*/
RoutingService.prototype.init = /**
* [init description]
* \@method init
* @private
* @return {?}
*/
function () {
var _this = this;
this.router.events.subscribe((/**
* @param {?} routeEvent
* @return {?}
*/
function (routeEvent) {
// console.log(routeEvent)
// https://github.com/angular/angular/issues/17473: event not fired anymore on load for routed component.
if (routeEvent instanceof router.NavigationEnd) {
_this.events.next(routeEvent);
/** @type {?} */
var route = _this.router.routerState.root.snapshot;
/** @type {?} */
var tmpUrl = '';
/** @type {?} */
var url = '';
/** @type {?} */
var rootRoot = true;
/** @type {?} */
var paths = [];
while (route.children.length) {
route = route.firstChild;
tmpUrl = "/" + RoutingService.createUrl(route);
if (route.outlet !== router.PRIMARY_OUTLET || (!route.routeConfig.path && !rootRoot)) {
continue;
}
rootRoot = false;
if (route.params || route.data) {
for (var key in route.params) {
if (!key) {
continue;
}
if (route.data['title']) {
route.data['title'] = route.data['title'].replace(":" + key, route.params[key]);
route.data['title'] = route.data['title'].replace(":" + key, route.params[key]);
}
if (route.data['breadcrumbs']) {
route.data['breadcrumbs'] = route.data['breadcrumbs'].replace(":" + key, route.params[key]);
}
if (route.data['description']) {
route.data['description'] = route.data['description'].replace(":" + key, route.params[key]);
}
}
}
if (tmpUrl === '/') {
paths.push(RoutingService.createBreadcrumb(route, tmpUrl));
}
else {
url += tmpUrl;
paths.push(RoutingService.createBreadcrumb(route, url));
}
}
_this.onChange.next(paths);
}
}));
};
RoutingService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
RoutingService.ctorParameters = function () { return [
{ type: router.Router }
]; };
return RoutingService;
}());
if (false) {
/** @type {?} */
RoutingService.prototype.onChange;
/** @type {?} */
RoutingService.prototype.events;
/**
* @type {?}
* @private
*/
RoutingService.prototype.router;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BreadcrumbsComponent = /** @class */ (function () {
/**
* @method constructor
* @param routingService [description]
* @param changeDetectorRef [description]
*/
function BreadcrumbsComponent(routingService, changeDetectorRef, router) {
this.routingService = routingService;
this.changeDetectorRef = changeDetectorRef;
this.router = router;
this.homeIcon = 'fa fa-home';
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
BreadcrumbsComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.subscription = this.routingService.onChange.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.breadcrumbs = value;
}));
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
BreadcrumbsComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.subscription.unsubscribe();
};
BreadcrumbsComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-breadcrumbs',
template: "<ol class=\"breadcrumb\">\r\n <li *ngFor=\"let breadcrumb of breadcrumbs; let first = first; let last = last\"\r\n [class.active]=\"last || !breadcrumb.url\">\r\n <a *ngIf=\"breadcrumb.url\" [routerLink]=\"breadcrumb.url\">\r\n <i *ngIf=\"first\" ngClass=\"{{homeIcon}}\"></i>\r\n <ng-template [ngIf]=\"breadcrumb.data.breadcrumbs\">{{breadcrumb.data.breadcrumbs}}</ng-template>\r\n <ng-template [ngIf]=\"!breadcrumb.data.breadcrumbs\">{{breadcrumb.data.title}}</ng-template>\r\n </a>\r\n <ng-template [ngIf]=\"!breadcrumb.url\">\r\n <i *ngIf=\"first\" ngClass=\"{{homeIcon}}\"></i>\r\n <ng-template [ngIf]=\"breadcrumb.data.breadcrumbs\">{{breadcrumb.data.breadcrumbs}}</ng-template>\r\n <ng-template [ngIf]=\"!breadcrumb.data.breadcrumbs\">{{breadcrumb.data.title}}</ng-template>\r\n </ng-template>\r\n </li>\r\n</ol>",
styles: [".breadcrumb{float:right;background:0 0;margin-top:0;margin-bottom:0;font-size:12px;padding:7px 5px;position:absolute;top:15px;right:10px;border-radius:2px}.breadcrumb>li>a{color:#444;text-decoration:none;display:inline-block}.breadcrumb>li .fa,.breadcrumb>li .glyphicon,.breadcrumb>li .ion{margin-right:5px}"]
}] }
];
/** @nocollapse */
BreadcrumbsComponent.ctorParameters = function () { return [
{ type: RoutingService },
{ type: core.ChangeDetectorRef },
{ type: router.Router }
]; };
BreadcrumbsComponent.propDecorators = {
homeIcon: [{ type: core.Input }]
};
return BreadcrumbsComponent;
}());
if (false) {
/** @type {?} */
BreadcrumbsComponent.prototype.breadcrumbs;
/**
* @type {?}
* @private
*/
BreadcrumbsComponent.prototype.subscription;
/** @type {?} */
BreadcrumbsComponent.prototype.homeIcon;
/**
* @type {?}
* @private
*/
BreadcrumbsComponent.prototype.routingService;
/**
* @type {?}
* @private
*/
BreadcrumbsComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
BreadcrumbsComponent.prototype.router;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var BreadcrumbsModule = /** @class */ (function () {
function BreadcrumbsModule() {
}
BreadcrumbsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, router.RouterModule],
exports: [BreadcrumbsComponent],
declarations: [BreadcrumbsComponent]
},] }
];
return BreadcrumbsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* [throttle description]
* \@method throttle
* @param {?} callback [description]
* @param {?} delay [description]
* @return {?} [description]
*/
function throttle(callback, delay) {
var _this = this;
/** @type {?} */
var timeout = null;
return (/**
* @param {...?} args
* @return {?}
*/
function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (!timeout) {
timeout = setTimeout((/**
* @return {?}
*/
function () {
callback.call.apply(callback, __spread([_this], args));
timeout = null;
}), delay);
}
});
}
/**
* [removeSubscriptions description]
* \@method removeSubscriptions
* @param {?} subscriptions
* @return {?}
*/
function removeSubscriptions(subscriptions) {
if (subscriptions) {
subscriptions.forEach((/**
* @param {?} subscription
* @return {?}
*/
function (subscription) {
subscription.unsubscribe();
}));
}
return [];
}
/**
* [removeListeners description]
* \@method removeListeners
* @param {?} listeners
* @return {?}
*/
function removeListeners(listeners) {
if (listeners) {
listeners.forEach((/**
* @param {?} listener
* @return {?}
*/
function (listener) {
listener();
}));
}
return [];
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var FooterService = /** @class */ (function () {
function FooterService() {
}
Object.defineProperty(FooterService.prototype, "offsetHeight", {
/**
* [offsetHeight description]
* @method offsetHeight
* @return [description]
*/
get: /**
* [offsetHeight description]
* \@method offsetHeight
* @return {?} [description]
*/
function () {
return this.elementRef ? this.elementRef.nativeElement.offsetHeight : 0;
},
enumerable: true,
configurable: true
});
FooterService.decorators = [
{ type: core.Injectable }
];
return FooterService;
}());
if (false) {
/** @type {?} */
FooterService.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var HeaderService = /** @class */ (function () {
function HeaderService() {
}
Object.defineProperty(HeaderService.prototype, "offsetHeight", {
/**
* [offsetHeight description]
* @method offsetHeight
* @return [description]
*/
get: /**
* [offsetHeight description]
* \@method offsetHeight
* @return {?} [description]
*/
function () {
return this.elementRef ? this.elementRef.nativeElement.offsetHeight : 0;
},
enumerable: true,
configurable: true
});
HeaderService.decorators = [
{ type: core.Injectable }
];
return HeaderService;
}());
if (false) {
/** @type {?} */
HeaderService.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var /*
*
*/
LayoutStore = /** @class */ (function () {
/**
* @method constructor
* @param layoutConfig [description]
*/
function LayoutStore(layoutConfig) {
this.initialLayoutState = {
isSidebarLeftCollapsed: false,
isSidebarLeftExpandOnOver: false,
isSidebarLeftMouseOver: false,
isSidebarLeftMini: true,
sidebarRightSkin: 'dark',
isSidebarRightCollapsed: true,
isSidebarRightOverContent: true,
layout: 'normal',
sidebarLeftMenu: [],
sidebarLeftMenuActiveUrl: '',
skin: 'blue'
};
if (layoutConfig) {
this.initialLayoutState = Object.assign(this.initialLayoutState, layoutConfig);
}
this._layoutState = new rxjs.BehaviorSubject(this.initialLayoutState);
this.layoutState = this._layoutState.asObservable();
}
Object.defineProperty(LayoutStore.prototype, "windowInnerHeight", {
/**
* [windowInnerHeight description]
* @method windowInnerHeight
* @return [description]
*/
get: /**
* [windowInnerHeight description]
* \@method windowInnerHeight
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('windowInnerHeight'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "windowInnerWidth", {
/**
* [windowInnerWidth description]
* @method windowInnerWidth
* @return [description]
*/
get: /**
* [windowInnerWidth description]
* \@method windowInnerWidth
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('windowInnerWidth'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarLeftCollapsed", {
/**
* [isSidebarLeftCollapsed description]
* @return [description]
*/
get: /**
* [isSidebarLeftCollapsed description]
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarLeftCollapsed'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarLeftExpandOnOver", {
/**
* [isSidebarLeftExpandOnOver description]
* @method isSidebarLeftExpandOnOver
* @return [description]
*/
get: /**
* [isSidebarLeftExpandOnOver description]
* \@method isSidebarLeftExpandOnOver
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarLeftExpandOnOver'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarLeftMouseOver", {
/**
* [isSidebarLeftMouseOver description]
* @method isSidebarLeftMouseOver
* @return [description]
*/
get: /**
* [isSidebarLeftMouseOver description]
* \@method isSidebarLeftMouseOver
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarLeftMouseOver'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarLeftMini", {
/**
* [isSidebarLeftMini description]
* @method isSidebarLeftMini
* @return [description]
*/
get: /**
* [isSidebarLeftMini description]
* \@method isSidebarLeftMini
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarLeftMini'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "sidebarRightSkin", {
/**
* [sidebarRightSkin description]
* @method sidebarRightSkin
* @return [description]
*/
get: /**
* [sidebarRightSkin description]
* \@method sidebarRightSkin
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('sidebarRightSkin'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarRightCollapsed", {
/**
* [isSidebarRightCollapsed description]
* @return [description]
*/
get: /**
* [isSidebarRightCollapsed description]
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarRightCollapsed'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "isSidebarRightOverContent", {
/**
* [isSidebarRightOverContent description]
* @method isSidebarRightOverContent
* @return [description]
*/
get: /**
* [isSidebarRightOverContent description]
* \@method isSidebarRightOverContent
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('isSidebarRightOverContent'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "sidebarLeftMenu", {
/**
* [sidebarLeftMenu description]
* @method sidebarLeftMenu
* @return [description]
*/
get: /**
* [sidebarLeftMenu description]
* \@method sidebarLeftMenu
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('sidebarLeftMenu'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "sidebarLeftMenuActiveUrl", {
/**
* [sidebarLeftMenuActiveUrl description]
* @method sidebarLeftMenuActiveUrl
* @return [description]
*/
get: /**
* [sidebarLeftMenuActiveUrl description]
* \@method sidebarLeftMenuActiveUrl
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('sidebarLeftMenuActiveUrl'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "sidebarLeftElementHeight", {
/**
* [sidebarLeftElementHeight description]
* @method sidebarLeftElementHeight
* @return [description]
*/
get: /**
* [sidebarLeftElementHeight description]
* \@method sidebarLeftElementHeight
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('sidebarLeftElementHeight'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "layout", {
/**
* [layoutType description]
* @method layoutType
* @return [description]
*/
get: /**
* [layoutType description]
* \@method layoutType
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('layout'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "skin", {
/**
* [skin description]
* @method skin
* @return [description]
*/
get: /**
* [skin description]
* \@method skin
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('skin'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
Object.defineProperty(LayoutStore.prototype, "wrapperClasses", {
/**
* [wrapperClasses description]
* @method wrapperClasses
* @return [description]
*/
get: /**
* [wrapperClasses description]
* \@method wrapperClasses
* @return {?} [description]
*/
function () {
return (/** @type {?} */ (this.layoutState.pipe(operators.pluck('wrapperClasses'), operators.distinctUntilChanged())));
},
enumerable: true,
configurable: true
});
/**
* [sidebarLeftCollapsed description]
* @method sidebarLeftCollapsed
* @param value [description]
*/
/**
* [sidebarLeftCollapsed description]
* \@method sidebarLeftCollapsed
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarLeftCollapsed = /**
* [sidebarLeftCollapsed description]
* \@method sidebarLeftCollapsed
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarLeftCollapsed: value }));
};
/**
* [sidebarLeftExpandOnOver description]
* @method sidebarLeftExpandOnOver
* @param value [description]
*/
/**
* [sidebarLeftExpandOnOver description]
* \@method sidebarLeftExpandOnOver
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarLeftExpandOnOver = /**
* [sidebarLeftExpandOnOver description]
* \@method sidebarLeftExpandOnOver
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarLeftExpandOnOver: value }));
};
/**
* [setSidebarLeftElementHeight description]
* @method setSidebarLeftElementHeight
* @param value [description]
*/
/**
* [setSidebarLeftElementHeight description]
* \@method setSidebarLeftElementHeight
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setSidebarLeftElementHeight = /**
* [setSidebarLeftElementHeight description]
* \@method setSidebarLeftElementHeight
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { sidebarLeftElementHeight: value }));
};
/**
* [setSidebarRightSkin description]
* @method setSidebarRightSkin
* @param value [description]
*/
/**
* [setSidebarRightSkin description]
* \@method setSidebarRightSkin
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.setSidebarRightSkin = /**
* [setSidebarRightSkin description]
* \@method setSidebarRightSkin
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { sidebarRightSkin: value }));
};
/**
* [sidebarLeftMouseOver description]
* @method sidebarLeftMouseOver
* @param value [description]
*/
/**
* [sidebarLeftMouseOver description]
* \@method sidebarLeftMouseOver
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarLeftMouseOver = /**
* [sidebarLeftMouseOver description]
* \@method sidebarLeftMouseOver
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarLeftMouseOver: value }));
};
/**
* [sidebarLeftMini description]
* @method sidebarLeftMini
* @param value [description]
*/
/**
* [sidebarLeftMini description]
* \@method sidebarLeftMini
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarLeftMini = /**
* [sidebarLeftMini description]
* \@method sidebarLeftMini
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarLeftMini: value }));
};
/**
* [sidebarRightCollapsed description]
* @method sidebarRightCollapsed
* @param value [description]
*/
/**
* [sidebarRightCollapsed description]
* \@method sidebarRightCollapsed
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarRightCollapsed = /**
* [sidebarRightCollapsed description]
* \@method sidebarRightCollapsed
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarRightCollapsed: value }));
};
/**
* [sidebarRightOverContent description]
* @method sidebarRightOverContent
* @param value [description]
*/
/**
* [sidebarRightOverContent description]
* \@method sidebarRightOverContent
* @param {?=} value [description]
* @return {?}
*/
LayoutStore.prototype.sidebarRightOverContent = /**
* [sidebarRightOverContent description]
* \@method sidebarRightOverContent
* @param {?=} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { isSidebarRightOverContent: value }));
};
/**
* [setSidebarLeftMenu description]
* @method setSidebarLeftMenu
* @param value [description]
*/
/**
* [setSidebarLeftMenu description]
* \@method setSidebarLeftMenu
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setSidebarLeftMenu = /**
* [setSidebarLeftMenu description]
* \@method setSidebarLeftMenu
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { sidebarLeftMenu: value }));
};
/**
* [setSidebarLeftMenuActiveUrl description]
* @method setSidebarLeftMenuActiveUrl
* @param value [description]
*/
/**
* [setSidebarLeftMenuActiveUrl description]
* \@method setSidebarLeftMenuActiveUrl
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setSidebarLeftMenuActiveUrl = /**
* [setSidebarLeftMenuActiveUrl description]
* \@method setSidebarLeftMenuActiveUrl
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { sidebarLeftMenuActiveUrl: value }));
};
/**
* [setLayout description]
* @method setLayout
* @param value [description]
*/
/**
* [setLayout description]
* \@method setLayout
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setLayout = /**
* [setLayout description]
* \@method setLayout
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { layout: value }));
};
/**
* [setSkin description]
* @method setSkin
* @param value [description]
*/
/**
* [setSkin description]
* \@method setSkin
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setSkin = /**
* [setSkin description]
* \@method setSkin
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { skin: value }));
};
/**
* [setWrapperClasses description]
* @method setWrapperClasses
* @param value [description]
*/
/**
* [setWrapperClasses description]
* \@method setWrapperClasses
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setWrapperClasses = /**
* [setWrapperClasses description]
* \@method setWrapperClasses
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { wrapperClasses: value }));
};
/**
* [setWindowInnerHeight description]
* @method setWindowInnerHeight
* @param value [description]
*/
/**
* [setWindowInnerHeight description]
* \@method setWindowInnerHeight
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setWindowInnerHeight = /**
* [setWindowInnerHeight description]
* \@method setWindowInnerHeight
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { windowInnerHeight: value }));
};
/**
* [setWindowInnerWidth description]
* @method setWindowInnerWidth
* @param value [description]
*/
/**
* [setWindowInnerWidth description]
* \@method setWindowInnerWidth
* @param {?} value [description]
* @return {?}
*/
LayoutStore.prototype.setWindowInnerWidth = /**
* [setWindowInnerWidth description]
* \@method setWindowInnerWidth
* @param {?} value [description]
* @return {?}
*/
function (value) {
this._layoutState.next(Object.assign(this._layoutState.value, { windowInnerWidth: value }));
};
return LayoutStore;
}());
if (false) {
/** @type {?} */
LayoutStore.prototype.layoutState;
/**
* @type {?}
* @private
*/
LayoutStore.prototype._layoutState;
/**
* @type {?}
* @private
*/
LayoutStore.prototype.initialLayoutState;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var SidebarRightService = /** @class */ (function () {
function SidebarRightService() {
}
Object.defineProperty(SidebarRightService.prototype, "scrollHeight", {
/**
* [scrollHeight description]
* @method scrollHeight
* @return [description]
*/
get: /**
* [scrollHeight description]
* \@method scrollHeight
* @return {?} [description]
*/
function () {
return this.elementRef ? this.elementRef.nativeElement.scrollHeight : null;
},
enumerable: true,
configurable: true
});
SidebarRightService.decorators = [
{ type: core.Injectable }
];
return SidebarRightService;
}());
if (false) {
/** @type {?} */
SidebarRightService.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ContentComponent = /** @class */ (function () {
/**
* @method constructor
* @param layoutStore
* @param routingService
* @param titleService
* @param elementRef
* @param changeDetectorRef
* @param sidebarRightService
* @param headerService
* @param footerService
* @param router
*/
function ContentComponent(layoutStore, routingService, titleService, elementRef, changeDetectorRef, sidebarRightService, headerService, footerService, router) {
this.layoutStore = layoutStore;
this.routingService = routingService;
this.titleService = titleService;
this.elementRef = elementRef;
this.changeDetectorRef = changeDetectorRef;
this.sidebarRightService = sidebarRightService;
this.headerService = headerService;
this.footerService = footerService;
this.router = router;
this.subscriptions = [];
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
ContentComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.titleTag = this.titleService.getTitle();
this.subscriptions.push(this.routingService.onChange.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
if (value && value[value.length - 1]) {
_this.titleService.setTitle(_this.getTitle(value[value.length - 1].data['title']));
_this.header = value[value.length - 1].data['title'];
_this.description = value[value.length - 1].data['description'];
}
_this.changeDetectorRef.markForCheck();
})));
this.subscriptions.push(this.router.events.subscribe((/**
* @param {?} routeEvent
* @return {?}
*/
function (routeEvent) {
if (routeEvent instanceof router.NavigationStart) {
_this.navigationEnd = false;
}
if (routeEvent instanceof router.NavigationEnd) {
_this.navigationEnd = true;
_this.setContentMinHeight();
}
})));
this.subscriptions.push(this.layoutStore.sidebarLeftElementHeight.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.sidebarLeftHeight = value;
_this.setContentMinHeight();
})));
this.subscriptions.push(this.layoutStore.layout.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.layout = value;
_this.setContentMinHeight();
})));
this.subscriptions.push(this.layoutStore.windowInnerHeight.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.windowInnerHeight = value;
_this.setContentMinHeight();
})));
this.heightStyle = this.windowInnerHeight;
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
ContentComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.subscriptions = removeSubscriptions(this.subscriptions);
};
Object.defineProperty(ContentComponent.prototype, "scrollHeight", {
/**
* [scrollHeight description]
* @method scrollHeight
* @return [description]
*/
get: /**
* [scrollHeight description]
* \@method scrollHeight
* @return {?} [description]
*/
function () {
return this.contentInnerElement.nativeElement.scrollHeight;
},
enumerable: true,
configurable: true
});
/**
* [getTitle description]
* @method getTitle
* @param title [description]
* @return [description]
*/
/**
* [getTitle description]
* \@method getTitle
* @private
* @param {?} title [description]
* @return {?} [description]
*/
ContentComponent.prototype.getTitle = /**
* [getTitle description]
* \@method getTitle
* @private
* @param {?} title [description]
* @return {?} [description]
*/
function (title) {
return title ? title + " - " + this.titleTag : this.titleTag;
};
/**
* [setMinHeight description]
* @method setMinHeight
*/
/**
* [setMinHeight description]
* \@method setMinHeight
* @private
* @return {?}
*/
ContentComponent.prototype.setContentMinHeight = /**
* [setMinHeight description]
* \@method setMinHeight
* @private
* @return {?}
*/
function () {
if (this.navigationEnd) {
/** @type {?} */
var heightStyle = void 0;
/** @type {?} */
var headerFooterOffsetHeight = this.headerService.offsetHeight + this.footerService.offsetHeight;
if (this.layout === 'fixed') {
heightStyle = this.windowInnerHeight - this.footerService.offsetHeight;
}
else {
/** @type {?} */
var sidebarRight = this.sidebarRightService.scrollHeight ?
this.sidebarRightService.scrollHeight - this.headerService.offsetHeight : 0;
heightStyle = Math.max(this.windowInnerHeight - headerFooterOffsetHeight, this.sidebarLeftHeight - this.headerService.offsetHeight, sidebarRight);
}
if (heightStyle && heightStyle !== this.heightStyle) {
if (this.scrollHeight > heightStyle) {
heightStyle = null;
}
this.heightStyle = heightStyle;
this.changeDetectorRef.detectChanges();
}
}
};
ContentComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-content',
template: "<div class=\"content-wrapper\" [style.min-height.px]=\"heightStyle\">\r\n <div #contentInnerElement class=\"content-inner\">\r\n <ng-content select=\"[mk-layout-content-before-header]\"></ng-content>\r\n <!-- <section class=\"content-header\">\r\n <h1 *ngIf=\"header || description\">\r\n {{header}}\r\n <small *ngIf=\"description\">{{description}}</small>\r\n </h1>\r\n <mk-breadcrumbs></mk-breadcrumbs>\r\n </section> -->\r\n <ng-content select=\"[mk-layout-content-after-header]\"></ng-content>\r\n <section class=\"content\">\r\n <ng-content></ng-content>\r\n </section>\r\n </div>\r\n</div>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [":host{display:block}.content-wrapper{position:relative}"]
}] }
];
/** @nocollapse */
ContentComponent.ctorParameters = function () { return [
{ type: LayoutStore },
{ type: RoutingService },
{ type: platformBrowser.Title },
{ type: core.ElementRef },
{ type: core.ChangeDetectorRef },
{ type: SidebarRightService },
{ type: HeaderService },
{ type: FooterService },
{ type: router.Router }
]; };
ContentComponent.propDecorators = {
contentInnerElement: [{ type: core.ViewChild, args: ['contentInnerElement', { static: true },] }]
};
return ContentComponent;
}());
if (false) {
/** @type {?} */
ContentComponent.prototype.description;
/** @type {?} */
ContentComponent.prototype.header;
/** @type {?} */
ContentComponent.prototype.heightStyle;
/** @type {?} */
ContentComponent.prototype.sidebarLeftHeight;
/** @type {?} */
ContentComponent.prototype.windowInnerHeight;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.layout;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.titleTag;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.navigationEnd;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.subscriptions;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.contentInnerElement;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.layoutStore;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.routingService;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.titleService;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.elementRef;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.sidebarRightService;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.headerService;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.footerService;
/**
* @type {?}
* @private
*/
ContentComponent.prototype.router;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ContentModule = /** @class */ (function () {
function ContentModule() {
}
ContentModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, router.RouterModule, BreadcrumbsModule],
exports: [ContentComponent],
declarations: [ContentComponent]
},] }
];
return ContentModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Footer Left
*/
var FooterLeftComponent = /** @class */ (function () {
function FooterLeftComponent() {
}
FooterLeftComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-footer-left',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
FooterLeftComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return FooterLeftComponent;
}());
if (false) {
/** @type {?} */
FooterLeftComponent.prototype.templateRef;
}
/**
* Footer Right
*/
var FooterRightComponent = /** @class */ (function () {
function FooterRightComponent() {
}
FooterRightComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-footer-right',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
FooterRightComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return FooterRightComponent;
}());
if (false) {
/** @type {?} */
FooterRightComponent.prototype.templateRef;
}
var FooterComponent = /** @class */ (function () {
function FooterComponent(elementRef, footerService) {
this.elementRef = elementRef;
this.footerService = footerService;
}
/**
* @return {?}
*/
FooterComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
this.footerService.elementRef = this.elementRef;
};
FooterComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-footer',
template: "<footer class=\"main-footer\">\r\n <div class=\"pull-right hidden-xs\">\r\n <ng-template [ngTemplateOutlet]=\"footerRightComponent?.templateRef\"></ng-template>\r\n </div>\r\n <ng-template [ngTemplateOutlet]=\"footerLeftComponent?.templateRef\"></ng-template>\r\n</footer>",
styles: [":host{display:block}"]
}] }
];
/** @nocollapse */
FooterComponent.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: FooterService }
]; };
FooterComponent.propDecorators = {
footerLeftComponent: [{ type: core.ContentChild, args: [FooterLeftComponent, { static: true },] }],
footerRightComponent: [{ type: core.ContentChild, args: [FooterRightComponent, { static: true },] }]
};
return FooterComponent;
}());
if (false) {
/** @type {?} */
FooterComponent.prototype.footerLeftComponent;
/** @type {?} */
FooterComponent.prototype.footerRightComponent;
/**
* @type {?}
* @private
*/
FooterComponent.prototype.elementRef;
/**
* @type {?}
* @private
*/
FooterComponent.prototype.footerService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var FooterModule = /** @class */ (function () {
function FooterModule() {
}
FooterModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule],
exports: [FooterComponent, FooterLeftComponent, FooterRightComponent],
declarations: [FooterComponent, FooterLeftComponent, FooterRightComponent]
},] }
];
return FooterModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Header Logo
*/
var HeaderLogoComponent = /** @class */ (function () {
function HeaderLogoComponent() {
}
HeaderLogoComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-header-logo',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
HeaderLogoComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return HeaderLogoComponent;
}());
if (false) {
/** @type {?} */
HeaderLogoComponent.prototype.templateRef;
}
/**
* Header Logo Mini
*/
var HeaderLogoMiniComponent = /** @class */ (function () {
function HeaderLogoMiniComponent() {
}
HeaderLogoMiniComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-header-logo-mini',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
HeaderLogoMiniComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return HeaderLogoMiniComponent;
}());
if (false) {
/** @type {?} */
HeaderLogoMiniComponent.prototype.templateRef;
}
/**
* Header
*/
var HeaderComponent = /** @class */ (function () {
/**
* @method constructor
* @param layoutStore [description]
* @param ngZone [description]
* @param renderer2 [description]
* @param elementRef [description]
* @param headerService [description]
*/
function HeaderComponent(layoutStore, ngZone, renderer2, elementRef, headerService) {
this.layoutStore = layoutStore;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.elementRef = elementRef;
this.headerService = headerService;
this.listeners = [];
this.subscriptions = [];
this.isSidebarLeftToggle = true;
this.isSidebarRightToggle = true;
this.logoLink = '/';
}
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
HeaderComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
this.headerService.elementRef = this.headerElement;
if (this.sidebarLeftToggleElement) {
this.subscriptions.push(this.layoutStore.isSidebarLeftCollapsed.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarLeftCollapsed = value;
})));
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.listeners.push(_this.renderer2.listen(_this.sidebarLeftToggleElement.nativeElement, 'click', (/**
* @param {?} event
* @return {?}
*/
function (event) {
event.preventDefault();
_this.layoutStore.sidebarLeftCollapsed(!_this.isSidebarLeftCollapsed);
})));
}));
}
if (this.sidebarRightToggleElement) {
this.subscriptions.push(this.layoutStore.isSidebarRightCollapsed.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarRightCollapsed = value;
})));
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.listeners.push(_this.renderer2.listen(_this.sidebarRightToggleElement.nativeElement, 'click', (/**
* @param {?} event
* @return {?}
*/
function (event) {
event.preventDefault();
_this.layoutStore.sidebarRightCollapsed(!_this.isSidebarRightCollapsed);
})));
}));
}
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
HeaderComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.listeners = removeListeners(this.listeners);
this.subscriptions = removeSubscriptions(this.subscriptions);
};
HeaderComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-header',
template: "<header #headerElement class=\"main-header\">\r\n <a [routerLink]=\"logoLink\" class=\"logo\">\r\n <span class=\"logo-mini\">\r\n <ng-template [ngTemplateOutlet]=\"headerLogoMiniComponent?.templateRef\"></ng-template>\r\n </span>\r\n <span class=\"logo-lg\">\r\n <ng-template [ngTemplateOutlet]=\"headerLogoComponent?.templateRef\"></ng-template>\r\n </span>\r\n </a>\r\n <nav class=\"navbar navbar-static-top\">\r\n <a *ngIf=\"isSidebarLeftToggle\" #sidebarLeftToggleElement href=\"#\" class=\"sidebar-toggle\">\r\n <span class=\"sr-only\">Toggle navigation</span>\r\n <span class=\"icon-bar\"></span>\r\n <span class=\"icon-bar\"></span>\r\n <span class=\"icon-bar\"></span>\r\n </a>\r\n <div *ngIf=\"isSidebarRightToggle\" class=\"sidebar-right-toggle\">\r\n <a #sidebarRightToggleElement href=\"#\"><i class=\"fa fa-gears\"></i></a>\r\n </div>\r\n <ng-content></ng-content>\r\n </nav>\r\n</header>",
styles: [":host{display:block}.sidebar-right-toggle{float:right}.sidebar-right-toggle a{padding:15px;display:block;line-height:20px;cursor:pointer}"]
}] }
];
/** @nocollapse */
HeaderComponent.ctorParameters = function () { return [
{ type: LayoutStore },
{ type: core.NgZone },
{ type: core.Renderer2 },
{ type: core.ElementRef },
{ type: HeaderService }
]; };
HeaderComponent.propDecorators = {
isSidebarLeftToggle: [{ type: core.Input }],
isSidebarRightToggle: [{ type: core.Input }],
logoLink: [{ type: core.Input }],
headerLogoComponent: [{ type: core.ContentChild, args: [HeaderLogoComponent, { static: true },] }],
headerLogoMiniComponent: [{ type: core.ContentChild, args: [HeaderLogoMiniComponent, { static: true },] }],
headerElement: [{ type: core.ViewChild, args: ['headerElement', { static: true },] }],
sidebarLeftToggleElement: [{ type: core.ViewChild, args: ['sidebarLeftToggleElement', { static: false },] }],
sidebarRightToggleElement: [{ type: core.ViewChild, args: ['sidebarRightToggleElement', { static: false },] }]
};
return HeaderComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.isSidebarLeftCollapsed;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.isSidebarRightCollapsed;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.subscriptions;
/** @type {?} */
HeaderComponent.prototype.isSidebarLeftToggle;
/** @type {?} */
HeaderComponent.prototype.isSidebarRightToggle;
/** @type {?} */
HeaderComponent.prototype.logoLink;
/** @type {?} */
HeaderComponent.prototype.headerLogoComponent;
/** @type {?} */
HeaderComponent.prototype.headerLogoMiniComponent;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.headerElement;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.sidebarLeftToggleElement;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.sidebarRightToggleElement;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.layoutStore;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.renderer2;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.elementRef;
/**
* @type {?}
* @private
*/
HeaderComponent.prototype.headerService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var HeaderModule = /** @class */ (function () {
function HeaderModule() {
}
HeaderModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, router.RouterModule],
exports: [HeaderComponent, HeaderLogoComponent, HeaderLogoMiniComponent],
declarations: [HeaderComponent, HeaderLogoComponent, HeaderLogoMiniComponent]
},] }
];
return HeaderModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* [InjectionToken description]
* @type {?}
*/
var LayoutConfigToken = new core.InjectionToken('layoutConfig');
/**
* [layoutStoreFactory description]
* @param {?} layoutConfig
* @return {?}
*/
function layoutStoreFactory(layoutConfig) {
return new LayoutStore(layoutConfig);
}
/**
* [layoutProviders description]
* @param {?} layoutConfig
* @return {?}
*/
function layoutProvider(layoutConfig) {
return [{
provide: LayoutStore,
useFactory: layoutStoreFactory,
deps: [LayoutConfigToken]
}, {
provide: LayoutConfigToken,
useValue: layoutConfig
}
];
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LayoutService = /** @class */ (function () {
/**
* @method constructor
* @param routingService [description]
*/
function LayoutService(router) {
this.router = router;
this.isCustomLayout = new rxjs.BehaviorSubject(true);
this.init();
}
/**
* [init description]
* @method init
* @return [description]
*/
/**
* [init description]
* \@method init
* @private
* @return {?} [description]
*/
LayoutService.prototype.init = /**
* [init description]
* \@method init
* @private
* @return {?} [description]
*/
function () {
var _this = this;
this.router.events.subscribe((/**
* @param {?} event
* @return {?}
*/
function (event) {
if (event instanceof router.ActivationStart) {
_this.customLayout = event.snapshot.data.customLayout;
_this.isCustomLayout.next(!!_this.customLayout);
}
}));
};
LayoutService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
LayoutService.ctorParameters = function () { return [
{ type: router.Router }
]; };
return LayoutService;
}());
if (false) {
/** @type {?} */
LayoutService.prototype.isCustomLayout;
/**
* @type {?}
* @private
*/
LayoutService.prototype.customLayout;
/**
* @type {?}
* @private
*/
LayoutService.prototype.router;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var CollapseAnimationDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
* @param ngZone [description]
* @param renderer2 [description]
*/
function CollapseAnimationDirective(elementRef, ngZone, renderer2) {
this.elementRef = elementRef;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.firstStart = true;
this.collapseAnimationDuration = 350;
this.startEventEmitter = new core.EventEmitter();
this.doneEventEmitter = new core.EventEmitter();
}
Object.defineProperty(CollapseAnimationDirective.prototype, "_isCollapsed", {
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this.lastIsCollapsed = this.isCollapsed;
this.isCollapsed = value;
if (!this.firstStart) {
this.emit('start');
if (value) {
this.collapse();
}
else if (value === false) {
this.unCollapse();
}
}
},
enumerable: true,
configurable: true
});
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
CollapseAnimationDirective.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
if (this.collapseAnimationDuration && this.collapseAnimationDuration !== 350) {
this.renderer2.setStyle(this.elementRef.nativeElement, 'transition-duration', this.collapseAnimationDuration + "ms");
}
if (this.collapseAnimationTiming) {
this.renderer2.setStyle(this.elementRef.nativeElement, 'transition-timing-function', this.collapseAnimationTiming);
}
};
/**
* @method ngAfterContentInit
*/
/**
* \@method ngAfterContentInit
* @return {?}
*/
CollapseAnimationDirective.prototype.ngAfterContentInit = /**
* \@method ngAfterContentInit
* @return {?}
*/
function () {
this.emit('start');
if (this.isCollapsed) {
this.renderer2.setStyle(this.elementRef.nativeElement, 'display', 'none');
this.renderer2.addClass(this.elementRef.nativeElement, 'collapsing');
}
this.emit('done');
this.firstStart = false;
this.subscriptions();
};
/**
* [ngOnDestroy description]
* @method ngOnDestroy
* @return [description]
*/
/**
* [ngOnDestroy description]
* \@method ngOnDestroy
* @return {?} [description]
*/
CollapseAnimationDirective.prototype.ngOnDestroy = /**
* [ngOnDestroy description]
* \@method ngOnDestroy
* @return {?} [description]
*/
function () {
if (this.listener) {
this.listener();
}
};
/**
* [subscriptions description]
* @method subscriptions
*/
/**
* [subscriptions description]
* \@method subscriptions
* @private
* @return {?}
*/
CollapseAnimationDirective.prototype.subscriptions = /**
* [subscriptions description]
* \@method subscriptions
* @private
* @return {?}
*/
function () {
var _this = this;
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.listener = _this.renderer2.listen(_this.elementRef.nativeElement, 'transitionend', (/**
* @return {?}
*/
function () {
if (!_this.isCollapsed) {
_this.renderer2.removeClass(_this.elementRef.nativeElement, 'un-collapse');
_this.renderer2.removeClass(_this.elementRef.nativeElement, 'collapsing');
}
else {
_this.renderer2.setStyle(_this.elementRef.nativeElement, 'display', 'none');
}
requestAnimationFrame((/**
* @return {?}
*/
function () {
_this.renderer2.removeStyle(_this.elementRef.nativeElement, 'height');
_this.emit('done');
_this.transitioning = false;
}));
}));
}));
};
/**
* [unCollapse description]
* @method unCollapse
*/
/**
* [unCollapse description]
* \@method unCollapse
* @private
* @return {?}
*/
CollapseAnimationDirective.prototype.unCollapse = /**
* [unCollapse description]
* \@method unCollapse
* @private
* @return {?}
*/
function () {
this.transitioning = true;
this.renderer2.addClass(this.elementRef.nativeElement, 'un-collapse');
this.renderer2.removeStyle(this.elementRef.nativeElement, 'display');
this.renderer2.setStyle(this.elementRef.nativeElement, 'height', this.elementRef.nativeElement.scrollHeight + "px");
};
/**
* [collapse description]
* @method collapse
*/
/**
* [collapse description]
* \@method collapse
* @private
* @return {?}
*/
CollapseAnimationDirective.prototype.collapse = /**
* [collapse description]
* \@method collapse
* @private
* @return {?}
*/
function () {
var _this = this;
requestAnimationFrame((/**
* @return {?}
*/
function () {
if (!_this.transitioning) {
_this.renderer2.setStyle(_this.elementRef.nativeElement, 'height', _this.elementRef.nativeElement.offsetHeight + "px");
_this.renderer2.addClass(_this.elementRef.nativeElement, 'collapsing');
}
_this.transitioning = true;
requestAnimationFrame((/**
* @return {?}
*/
function () {
_this.renderer2.setStyle(_this.elementRef.nativeElement, 'height', "0px");
}));
}));
};
/**
* @private
* @param {?} phaseName
* @return {?}
*/
CollapseAnimationDirective.prototype.emit = /**
* @private
* @param {?} phaseName
* @return {?}
*/
function (phaseName) {
/** @type {?} */
var event = {
element: this.elementRef.nativeElement,
fromState: this.lastIsCollapsed === undefined ? 'void' : this.lastIsCollapsed ? '1' : '0',
phaseName: phaseName,
toState: this.isCollapsed === undefined ? 'void' : this.isCollapsed ? '1' : '0',
totalTime: this.collapseAnimationDuration,
triggerName: 'mkCollapseAnimation'
};
if (phaseName === 'done') {
this.doneEventEmitter.emit(event);
}
else if (phaseName === 'start') {
this.startEventEmitter.emit(event);
}
};
CollapseAnimationDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkCollapseAnimation]'
},] }
];
/** @nocollapse */
CollapseAnimationDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.NgZone },
{ type: core.Renderer2 }
]; };
CollapseAnimationDirective.propDecorators = {
collapseAnimationDuration: [{ type: core.Input }],
collapseAnimationTiming: [{ type: core.Input }],
_isCollapsed: [{ type: core.Input, args: ['mkCollapseAnimation',] }],
startEventEmitter: [{ type: core.Output, args: ['mkCollapseAnimation.start',] }],
doneEventEmitter: [{ type: core.Output, args: ['mkCollapseAnimation.done',] }]
};
return CollapseAnimationDirective;
}());
if (false) {
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.firstStart;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.isCollapsed;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.lastIsCollapsed;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.transitioning;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.listener;
/** @type {?} */
CollapseAnimationDirective.prototype.collapseAnimationDuration;
/** @type {?} */
CollapseAnimationDirective.prototype.collapseAnimationTiming;
/** @type {?} */
CollapseAnimationDirective.prototype.startEventEmitter;
/** @type {?} */
CollapseAnimationDirective.prototype.doneEventEmitter;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.elementRef;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.ngZone;
/**
* @type {?}
* @private
*/
CollapseAnimationDirective.prototype.renderer2;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AnimationsModule = /** @class */ (function () {
function AnimationsModule() {
}
AnimationsModule.decorators = [
{ type: core.NgModule, args: [{
exports: [CollapseAnimationDirective],
declarations: [CollapseAnimationDirective]
},] }
];
return AnimationsModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var WrapperService = /** @class */ (function () {
function WrapperService() {
}
WrapperService.decorators = [
{ type: core.Injectable }
];
return WrapperService;
}());
if (false) {
/** @type {?} */
WrapperService.prototype.wrapperElementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var SidebarLeftToggleDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
*/
function SidebarLeftToggleDirective(elementRef) {
this.elementRef = elementRef;
}
SidebarLeftToggleDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkMenuToggle]'
},] }
];
/** @nocollapse */
SidebarLeftToggleDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
SidebarLeftToggleDirective.propDecorators = {
item: [{ type: core.Input, args: ['mkMenuToggle',] }]
};
return SidebarLeftToggleDirective;
}());
if (false) {
/** @type {?} */
SidebarLeftToggleDirective.prototype.item;
/** @type {?} */
SidebarLeftToggleDirective.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function Item() { }
if (false) {
/** @type {?} */
Item.prototype.id;
/** @type {?} */
Item.prototype.parentId;
/** @type {?} */
Item.prototype.label;
/** @type {?|undefined} */
Item.prototype.route;
/** @type {?|undefined} */
Item.prototype.iconClasses;
/** @type {?|undefined} */
Item.prototype.children;
/** @type {?|undefined} */
Item.prototype.isActive;
/** @type {?|undefined} */
Item.prototype.isCollapsed;
/** @type {?|undefined} */
Item.prototype.disableCollapse;
}
var SidebarLeftComponent = /** @class */ (function () {
/**
* @method constructor
* @param changeDetectorRef [description]
* @param layoutStore [description]
* @param ngZone [description]
* @param renderer2 [description]
* @param router [description]
* @param routingService [description]
* @param wrapperService [description]
* @param headerService [description]
*/
function SidebarLeftComponent(changeDetectorRef, layoutStore, ngZone, renderer2, router, routingService, wrapperService, headerService, activatedRoute) {
this.changeDetectorRef = changeDetectorRef;
this.layoutStore = layoutStore;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.router = router;
this.routingService = routingService;
this.wrapperService = wrapperService;
this.headerService = headerService;
this.activatedRoute = activatedRoute;
this.collapsedItems = [];
this.activatedItems = [];
this.toggleListeners = [];
this.listeners = [];
this.itemsByIds = {};
this.runningAnimations = 0;
this.subscriptions = [];
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
SidebarLeftComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.subscriptions.push(this.layoutStore.sidebarLeftMenu.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.menu = value;
_this.monkeyPatchMenu(_this.menu);
if (_this.initialized) {
_this.setMenuListeners(_this.activeUrl);
_this.setSidebarListeners();
_this.setMenuTogglesListeners();
}
_this.initialized = true;
})));
this.subscriptions.push(this.layoutStore.sidebarLeftMenuActiveUrl.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.activeUrl = value;
_this.setMenuListeners(value);
})));
this.subscriptions.push(this.routingService.events.subscribe((/**
* @param {?} event
* @return {?}
*/
function (event) {
/** @type {?} */
var url;
if (event instanceof router.NavigationEnd) {
url = event.url;
}
else {
url = _this.router.url;
}
_this.activeUrl = url;
_this.setMenuListeners(url);
// console.log(url)
})));
this.setSidebarListeners();
};
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
SidebarLeftComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
this.setMenuTogglesListeners();
this.checkMenuWithoutChildren();
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
SidebarLeftComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.subscriptions = removeSubscriptions(this.subscriptions);
this.listeners = removeListeners(this.listeners);
this.toggleListeners = removeListeners(this.toggleListeners);
};
/**
* [setSidebarListeners description]
* @method setSidebarListeners
*/
/**
* [setSidebarListeners description]
* \@method setSidebarListeners
* @return {?}
*/
SidebarLeftComponent.prototype.setSidebarListeners = /**
* [setSidebarListeners description]
* \@method setSidebarListeners
* @return {?}
*/
function () {
var _this = this;
this.subscriptions.push(this.layoutStore.layout.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.layout = value;
_this.setSidebarHeight();
})));
this.subscriptions.push(this.layoutStore.windowInnerHeight.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.windowInnerHeight = value;
_this.setSidebarHeight();
})));
this.subscriptions.push(this.layoutStore.sidebarLeftMenu.subscribe((/**
* @return {?}
*/
function () {
_this.changeDetectorRef.detectChanges();
})));
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.listeners.push(_this.renderer2.listen(_this.sidebarElement.nativeElement, 'mouseenter', (/**
* @return {?}
*/
function () {
_this.layoutStore.sidebarLeftMouseOver(true);
})));
_this.listeners.push(_this.renderer2.listen(_this.sidebarElement.nativeElement, 'mouseleave', (/**
* @return {?}
*/
function () {
_this.layoutStore.sidebarLeftMouseOver(false);
})));
}));
this.subscriptions.push(this.layoutStore.windowInnerWidth.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.windowInnerWidth = value;
if (!_this.isSidebarLeftCollapsed && _this.windowInnerWidth <= 767) {
_this.layoutStore.sidebarLeftCollapsed(true);
}
else if (_this.windowInnerWidth > 767 && _this.isSidebarLeftCollapsed && !_this.isSidebarLeftExpandOnOver) {
_this.layoutStore.sidebarLeftCollapsed(false);
}
})));
this.subscriptions.push(this.layoutStore.isSidebarLeftMouseOver.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarLeftMouseOver = value;
if (_this.isSidebarLeftExpandOnOver) {
_this.layoutStore.sidebarLeftCollapsed(!value);
}
})));
this.subscriptions.push(this.layoutStore.isSidebarLeftExpandOnOver.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarLeftExpandOnOver = value;
if (_this.windowInnerWidth > 767 && _this.isSidebarLeftCollapsed !== undefined) {
_this.layoutStore.sidebarLeftCollapsed(value);
}
})));
this.subscriptions.push(this.layoutStore.isSidebarLeftCollapsed.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarLeftCollapsed = value;
if (_this.windowInnerWidth <= 767) {
if (value) {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-open');
}
else {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-open');
}
}
else {
if (_this.isSidebarLeftExpandOnOver && !_this.isSidebarLeftMouseOver && !value) {
_this.layoutStore.sidebarLeftExpandOnOver(false);
}
if (value) {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-collapse');
if (_this.isSidebarLeftExpandOnOver) {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-expanded-on-hover');
}
}
else {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-collapse');
if (_this.isSidebarLeftExpandOnOver) {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-expanded-on-hover');
}
}
}
})));
this.subscriptions.push(this.layoutStore.isSidebarLeftMini.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
if (value) {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-mini');
}
else {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'sidebar-mini');
}
})));
};
/**
* [setMenuListeners description]
* @method setMenuListeners
*/
/**
* [setMenuListeners description]
* \@method setMenuListeners
* @param {?} url
* @return {?}
*/
SidebarLeftComponent.prototype.setMenuListeners = /**
* [setMenuListeners description]
* \@method setMenuListeners
* @param {?} url
* @return {?}
*/
function (url) {
if (url === '/') {
this.activeItems(url);
this.changeDetectorRef.detectChanges();
}
else {
/** @type {?} */
var primaryOutlet = this.router.parseUrl(url).root.children[router.PRIMARY_OUTLET];
if (primaryOutlet) {
// console.log(primaryOutlet)
// this.activeItems('/' + primaryOutlet.toString());
this.activeItems(primaryOutlet.toString());
this.changeDetectorRef.detectChanges();
}
}
if (this.windowInnerWidth <= 767 || this.isSidebarLeftExpandOnOver) {
this.layoutStore.sidebarLeftCollapsed(true);
}
};
/**
* [getIconClasses description]
* @method getIconClasses
* @param item [description]
* @return [description]
*/
/**
* [getIconClasses description]
* \@method getIconClasses
* @param {?} item [description]
* @return {?} [description]
*/
SidebarLeftComponent.prototype.getIconClasses = /**
* [getIconClasses description]
* \@method getIconClasses
* @param {?} item [description]
* @return {?} [description]
*/
function (item) {
if (item.iconClasses || item.iconClasses === '') {
return item.iconClasses;
}
else {
return 'fa fa-dot-circle-o';
}
};
/**
* [visibilityStateStart description]
* @method visibilityStateStart
* @param event [description]
*/
/**
* [visibilityStateStart description]
* \@method visibilityStateStart
* @param {?} event [description]
* @return {?}
*/
SidebarLeftComponent.prototype.visibilityStateStart = /**
* [visibilityStateStart description]
* \@method visibilityStateStart
* @param {?} event [description]
* @return {?}
*/
function (event) {
var _this = this;
this.runningAnimations++;
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
setTimeout((/**
* @return {?}
*/
function () {
_this.runningAnimations--;
if (!_this.runningAnimations) {
_this.layoutStore.setSidebarLeftElementHeight(_this.sidebarElement.nativeElement.offsetHeight);
}
}), event.totalTime);
}));
};
/**
* [uncollapseItemParents description]
* @method uncollapseItemParents
* @param item [description]
* @param isActive [description]
*/
/**
* [uncollapseItemParents description]
* \@method uncollapseItemParents
* @private
* @param {?} item [description]
* @param {?=} isActive [description]
* @return {?}
*/
SidebarLeftComponent.prototype.uncollapseItemParents = /**
* [uncollapseItemParents description]
* \@method uncollapseItemParents
* @private
* @param {?} item [description]
* @param {?=} isActive [description]
* @return {?}
*/
function (item, isActive) {
if (isActive === void 0) { isActive = false; }
if (isActive) {
item.isActive = true;
this.activatedItems.push(item);
}
// console.log(item)
// console.log(isActive)
item.isCollapsed = false;
this.collapsedItems.push(item);
if (item.parentId) {
this.uncollapseItemParents(this.itemsByIds[item.parentId], isActive);
}
};
/**
* [findItemsByUrl description]
* @method findItemsByUrl
* @param url [description]
* @param items [description]
* @param returnItems [description]
* @return [description]
*/
/**
* [findItemsByUrl description]
* \@method findItemsByUrl
* @private
* @param {?} url [description]
* @param {?} items [description]
* @param {?=} returnItems [description]
* @return {?} [description]
*/
SidebarLeftComponent.prototype.findItemsByUrl = /**
* [findItemsByUrl description]
* \@method findItemsByUrl
* @private
* @param {?} url [description]
* @param {?} items [description]
* @param {?=} returnItems [description]
* @return {?} [description]
*/
function (url, items, returnItems) {
var _this = this;
if (returnItems === void 0) { returnItems = []; }
items.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
if (item.route === url) {
returnItems.push(item);
}
else if (item.children) {
_this.findItemsByUrl(url, item.children, returnItems);
}
else if (url.includes(item.route) && item.route != '/') {
returnItems.push(item);
}
}));
return returnItems;
};
/**
* [activeItems description]
* @method activeItems
* @param url [description]
*/
/**
* [activeItems description]
* \@method activeItems
* @private
* @param {?} url [description]
* @return {?}
*/
SidebarLeftComponent.prototype.activeItems = /**
* [activeItems description]
* \@method activeItems
* @private
* @param {?} url [description]
* @return {?}
*/
function (url) {
var _this = this;
this.activatedItems.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
item.isActive = false;
}));
this.activatedItems = [];
this.collapsedItems.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
item.isActive = false;
item.isCollapsed = true;
}));
this.collapsedItems = [];
// console.log(url)
/** @type {?} */
var items = this.findItemsByUrl(url, this.menu);
items.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
item.isActive = true;
_this.uncollapseItemParents(item, true);
_this.activatedItems.push(item);
}));
};
/**
* [monkeyPatchMenu description]
* @method monkeyPatchMenu
* @param items [description]
* @param parentId [description]
*/
/**
* [monkeyPatchMenu description]
* \@method monkeyPatchMenu
* @private
* @param {?} items [description]
* @param {?=} parentId [description]
* @return {?}
*/
SidebarLeftComponent.prototype.monkeyPatchMenu = /**
* [monkeyPatchMenu description]
* \@method monkeyPatchMenu
* @private
* @param {?} items [description]
* @param {?=} parentId [description]
* @return {?}
*/
function (items, parentId) {
var _this = this;
items.forEach((/**
* @param {?} item
* @param {?} index
* @return {?}
*/
function (item, index) {
item.id = parentId ? Number(parentId + '' + (index + 1)) : index + 1;
if (parentId) {
item.parentId = parentId;
}
if (!item.disableCollapse) {
item.isCollapsed = true;
}
item.isActive = false;
if (parentId || item.children) {
_this.itemsByIds[item.id] = item;
}
if (item.children) {
_this.monkeyPatchMenu(item.children, item.id);
}
}));
};
/**
* [setMenuTogglesListeners description]
* @method setMenuTogglesListeners
*/
/**
* [setMenuTogglesListeners description]
* \@method setMenuTogglesListeners
* @private
* @return {?}
*/
SidebarLeftComponent.prototype.setMenuTogglesListeners = /**
* [setMenuTogglesListeners description]
* \@method setMenuTogglesListeners
* @private
* @return {?}
*/
function () {
var _this = this;
this.toggleListeners = removeListeners(this.toggleListeners);
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.sidebarLeftToggleDirectives.forEach((/**
* @param {?} menuToggle
* @return {?}
*/
function (menuToggle) {
_this.toggleListeners.push(_this.renderer2.listen(menuToggle.elementRef.nativeElement, 'click', (/**
* @param {?} event
* @return {?}
*/
function (event) {
event.preventDefault();
if (menuToggle.item.isCollapsed) {
_this.collapsedItems.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
if (!item.disableCollapse) {
item.isCollapsed = true;
}
}));
_this.collapsedItems = [];
_this.uncollapseItemParents(menuToggle.item);
}
else {
menuToggle.item.isCollapsed = !menuToggle.item.isCollapsed;
}
_this.changeDetectorRef.detectChanges();
})));
}));
}));
};
/**
* [checkMenuWithoutChildren description]
* @method checkMenuWithoutChildren
*/
/**
* [checkMenuWithoutChildren description]
* \@method checkMenuWithoutChildren
* @private
* @return {?}
*/
SidebarLeftComponent.prototype.checkMenuWithoutChildren = /**
* [checkMenuWithoutChildren description]
* \@method checkMenuWithoutChildren
* @private
* @return {?}
*/
function () {
var _this = this;
/** @type {?} */
var menuHaveChildren;
this.menu.forEach((/**
* @param {?} item
* @return {?}
*/
function (item) {
if (item.children) {
return menuHaveChildren = true;
}
}));
if (!menuHaveChildren) {
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
setTimeout((/**
* @return {?}
*/
function () {
_this.layoutStore.setSidebarLeftElementHeight(_this.sidebarElement.nativeElement.offsetHeight);
}));
}));
}
};
/**
* [setSidebarHeight description]
* @method setSidebarHeight
*/
/**
* [setSidebarHeight description]
* \@method setSidebarHeight
* @private
* @return {?}
*/
SidebarLeftComponent.prototype.setSidebarHeight = /**
* [setSidebarHeight description]
* \@method setSidebarHeight
* @private
* @return {?}
*/
function () {
if (this.layout === 'fixed') {
/** @type {?} */
var height = this.windowInnerHeight - this.headerService.offsetHeight;
if (height && height !== this.sidebarHeight) {
this.sidebarHeight = height;
this.sidebarOverflow = 'auto';
this.changeDetectorRef.detectChanges();
}
}
else if (this.sidebarHeight) {
this.sidebarOverflow = this.sidebarHeight = null;
this.changeDetectorRef.detectChanges();
}
};
SidebarLeftComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-sidebar-left',
template: "<aside class=\"main-sidebar\">\r\n <section class=\"sidebar\" #sidebarElement [style.height.px]=\"sidebarHeight\" [style.overflow]=\"sidebarOverflow\">\r\n <ng-content></ng-content>\r\n <ul class=\"sidebar-menu\">\r\n <ng-container *ngFor=\"let item of menu\">\r\n <ng-container *ngTemplateOutlet=\"sidebarInner; context: {item: item}\"></ng-container>\r\n </ng-container>\r\n </ul>\r\n </section>\r\n</aside>\r\n\r\n<ng-template #sidebarInner let-item=\"item\">\r\n <li [class.active]=\"item.isActive\" [class.header]=\"item.separator\" [class.menu-open]=\"!item.isCollapsed\">\r\n <span *ngIf=\"item.separator\">{{item.label}}</span>\r\n <a *ngIf=\"!item.separator && item.route\" [routerLink]=\"item.route\">\r\n <i [class]=\"getIconClasses(item)\"></i><span>{{item.label}}</span>\r\n <span *ngIf=\"item.children || item.pullRights\" class=\"pull-right-container\">\r\n <span *ngFor=\"let rightItem of item.pullRights\"\r\n class=\"pull-right {{rightItem.classes}}\">{{rightItem.text}}</span>\r\n <i *ngIf=\"!item.pullRights\" class=\"fa fa-angle-left pull-right\"></i>\r\n </span>\r\n </a>\r\n <a *ngIf=\"!item.separator && !item.route\" href=\"#\" [mkMenuToggle]=\"item\">\r\n <i [class]=\"getIconClasses(item)\"></i><span>{{item.label}}</span>\r\n <span *ngIf=\"item.children || item.pullRights\" class=\"pull-right-container\">\r\n <span *ngFor=\"let rightItem of item.pullRights\"\r\n class=\"pull-right {{rightItem.classes}}\">{{rightItem.text}}</span>\r\n <i *ngIf=\"!item.pullRights\" class=\"fa fa-angle-left pull-right\"></i>\r\n </span>\r\n </a>\r\n <ul *ngIf=\"item.children\" [mkCollapseAnimation]=\"item.isCollapsed\"\r\n (mkCollapseAnimation.start)=\"visibilityStateStart($event)\" class=\"treeview-menu\">\r\n <ng-container *ngFor=\"let item of item.children\">\r\n <ng-container *ngTemplateOutlet=\"sidebarInner; context: {item: item}\"></ng-container>\r\n </ng-container>\r\n </ul>\r\n </li>\r\n</ng-template>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [".treeview-menu.collapse{display:none}.treeview-menu,.treeview-menu.collapse.in{display:block}"]
}] }
];
/** @nocollapse */
SidebarLeftComponent.ctorParameters = function () { return [
{ type: core.ChangeDetectorRef },
{ type: LayoutStore },
{ type: core.NgZone },
{ type: core.Renderer2 },
{ type: router.Router },
{ type: RoutingService },
{ type: WrapperService },
{ type: HeaderService },
{ type: router.ActivatedRoute }
]; };
SidebarLeftComponent.propDecorators = {
sidebarElement: [{ type: core.ViewChild, args: ['sidebarElement', { static: true },] }],
sidebarLeftToggleDirectives: [{ type: core.ViewChildren, args: [SidebarLeftToggleDirective,] }]
};
return SidebarLeftComponent;
}());
if (false) {
/** @type {?} */
SidebarLeftComponent.prototype.menu;
/** @type {?} */
SidebarLeftComponent.prototype.sidebarHeight;
/** @type {?} */
SidebarLeftComponent.prototype.sidebarOverflow;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.layout;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.isSidebarLeftCollapsed;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.isSidebarLeftExpandOnOver;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.isSidebarLeftMouseOver;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.windowInnerWidth;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.windowInnerHeight;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.collapsedItems;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.activatedItems;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.toggleListeners;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.itemsByIds;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.runningAnimations;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.subscriptions;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.activeUrl;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.initialized;
/** @type {?} */
SidebarLeftComponent.prototype.sidebarElement;
/** @type {?} */
SidebarLeftComponent.prototype.sidebarLeftToggleDirectives;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.layoutStore;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.renderer2;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.router;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.routingService;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.wrapperService;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.headerService;
/**
* @type {?}
* @private
*/
SidebarLeftComponent.prototype.activatedRoute;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var SidebarLeftModule = /** @class */ (function () {
function SidebarLeftModule() {
}
SidebarLeftModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, router.RouterModule, AnimationsModule],
exports: [SidebarLeftComponent],
declarations: [SidebarLeftToggleDirective, SidebarLeftComponent]
},] }
];
return SidebarLeftModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var SidebarRightComponent = /** @class */ (function () {
function SidebarRightComponent(elementRef, renderer2, layoutStore, sidebarRightService, wrapperService) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.layoutStore = layoutStore;
this.sidebarRightService = sidebarRightService;
this.wrapperService = wrapperService;
this.listeners = [];
this.subscriptions = [];
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
SidebarRightComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.renderer2.addClass(this.elementRef.nativeElement, 'control-sidebar');
this.subscriptions.push(this.layoutStore.isSidebarRightCollapsed.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarRightCollapsed = value;
if (!value) {
_this.renderer2.addClass(_this.elementRef.nativeElement, 'control-sidebar-open');
if (!_this.isSidebarRightOverContent) {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'control-sidebar-open');
}
}
else {
_this.renderer2.removeClass(_this.elementRef.nativeElement, 'control-sidebar-open');
if (!_this.isSidebarRightOverContent) {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'control-sidebar-open');
}
}
})));
this.subscriptions.push(this.layoutStore.isSidebarRightOverContent.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.isSidebarRightOverContent = value;
if (!_this.isSidebarRightCollapsed) {
if (value) {
_this.renderer2.removeClass(_this.wrapperService.wrapperElementRef.nativeElement, 'control-sidebar-open');
}
else {
_this.renderer2.addClass(_this.wrapperService.wrapperElementRef.nativeElement, 'control-sidebar-open');
}
}
})));
this.subscriptions.push(this.layoutStore.sidebarRightSkin.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
if (_this.skin !== value) {
_this.renderer2.removeClass(_this.elementRef.nativeElement, "control-sidebar-" + _this.skin);
}
_this.skin = value;
_this.renderer2.addClass(_this.elementRef.nativeElement, "control-sidebar-" + value);
})));
};
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
SidebarRightComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
this.sidebarRightService.elementRef = this.sidebarContentElement;
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
SidebarRightComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.listeners = removeListeners(this.listeners);
this.subscriptions = removeSubscriptions(this.subscriptions);
};
SidebarRightComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-sidebar-right',
template: "<div #sidebarContentElement class=\"control-sidebar-content\">\r\n <ng-content></ng-content>\r\n</div>\r\n<div class=\"control-sidebar-bg\"></div>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [":host{display:block;height:100%}.control-sidebar-bg{z-index:-1}/deep/ .tab-content{padding:10px 15px}"]
}] }
];
/** @nocollapse */
SidebarRightComponent.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: LayoutStore },
{ type: SidebarRightService },
{ type: WrapperService }
]; };
SidebarRightComponent.propDecorators = {
sidebarContentElement: [{ type: core.ViewChild, args: ['sidebarContentElement', { static: true },] }]
};
return SidebarRightComponent;
}());
if (false) {
/** @type {?} */
SidebarRightComponent.prototype.layout;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.skin;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.isSidebarRightOverContent;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.isSidebarRightCollapsed;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.subscriptions;
/** @type {?} */
SidebarRightComponent.prototype.sidebarContentElement;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.elementRef;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.renderer2;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.layoutStore;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.sidebarRightService;
/**
* @type {?}
* @private
*/
SidebarRightComponent.prototype.wrapperService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var SidebarRightModule = /** @class */ (function () {
function SidebarRightModule() {
}
SidebarRightModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule],
exports: [SidebarRightComponent],
declarations: [SidebarRightComponent]
},] }
];
return SidebarRightModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var WrapperComponent = /** @class */ (function () {
function WrapperComponent(elementRef, renderer2, layoutStore, wrapperService, ngZone) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.layoutStore = layoutStore;
this.wrapperService = wrapperService;
this.ngZone = ngZone;
this.listeners = [];
this.subscriptions = [];
}
/**
* [ngOnInit description]
* @method ngOnInit
*/
/**
* [ngOnInit description]
* \@method ngOnInit
* @return {?}
*/
WrapperComponent.prototype.ngOnInit = /**
* [ngOnInit description]
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.layoutStore.setWindowInnerHeight(window.innerHeight);
this.layoutStore.setWindowInnerWidth(window.innerWidth);
this.wrapperService.wrapperElementRef = this.elementRef;
this.subscriptions.push(this.layoutStore.wrapperClasses.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
_this.classes = value ? value : null;
})));
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.listeners.push(_this.renderer2.listen('window', 'resize', throttle((/**
* @return {?}
*/
function () {
_this.layoutStore.setWindowInnerHeight(window.innerHeight);
_this.layoutStore.setWindowInnerWidth(window.innerWidth);
}), 250)));
}));
this.subscriptions.push(this.layoutStore.layout.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
value === 'fixed' ? _this.renderer2.addClass(_this.elementRef.nativeElement, 'fixed') :
_this.renderer2.removeClass(_this.elementRef.nativeElement, 'fixed');
value === 'boxed' ? _this.renderer2.addClass(_this.elementRef.nativeElement, 'layout-boxed') :
_this.renderer2.removeClass(_this.elementRef.nativeElement, 'layout-boxed');
})));
this.subscriptions.push(this.layoutStore.skin.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
if (value) {
if (_this.skin && _this.skin !== value) {
_this.renderer2.removeClass(_this.elementRef.nativeElement, "skin-" + _this.skin);
}
_this.skin = value;
_this.renderer2.addClass(_this.elementRef.nativeElement, "skin-" + _this.skin);
}
})));
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
WrapperComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
this.subscriptions = removeSubscriptions(this.subscriptions);
this.listeners = removeListeners(this.listeners);
};
WrapperComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-layout-wrapper',
template: "<div class=\"wrapper overflow\" [ngClass]=\"classes\">\r\n <ng-content></ng-content>\r\n</div>",
styles: [".wrapper.overflow{overflow:hidden}:host{display:block}:host /deep/ .sidebar-right-toggle>a{color:#fff}:host.sidebar-mini.sidebar-collapse /deep/ .treeview-menu.collapsing{height:auto!important}:host /deep/ .sidebar-right-toggle>a:hover{background:rgba(0,0,0,.1)}:host.skin-black /deep/ .sidebar-right-toggle>a,:host.skin-black-light /deep/ .sidebar-right-toggle>a{color:#333;border-right-width:0}:host.skin-black /deep/ .sidebar-right-toggle>a:hover,:host.skin-black-light /deep/ .sidebar-right-toggle>a:hover{background-color:#fff;color:#999}:host.skin-black /deep/ .sidebar-right-toggle>a{border-left:1px solid #eee}:host.skin-black-light /deep/ .sidebar-right-toggle>a{border-left:1px solid #d2d6de}"]
}] }
];
/** @nocollapse */
WrapperComponent.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: LayoutStore },
{ type: WrapperService },
{ type: core.NgZone }
]; };
return WrapperComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.skin;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.subscriptions;
/** @type {?} */
WrapperComponent.prototype.classes;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.elementRef;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.renderer2;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.layoutStore;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.wrapperService;
/**
* @type {?}
* @private
*/
WrapperComponent.prototype.ngZone;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var WrapperModule = /** @class */ (function () {
function WrapperModule() {
}
WrapperModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule],
exports: [WrapperComponent],
declarations: [WrapperComponent]
},] }
];
return WrapperModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* @record
*/
function LayoutState() { }
if (false) {
/** @type {?|undefined} */
LayoutState.prototype.isSidebarLeftCollapsed;
/** @type {?|undefined} */
LayoutState.prototype.isSidebarLeftExpandOnOver;
/** @type {?|undefined} */
LayoutState.prototype.isSidebarLeftMouseOver;
/** @type {?|undefined} */
LayoutState.prototype.isSidebarLeftMini;
/** @type {?|undefined} */
LayoutState.prototype.sidebarRightSkin;
/** @type {?|undefined} */
LayoutState.prototype.isSidebarRightCollapsed;
/** @type {?|undefined} */
LayoutState.prototype.isSidebarRightOverContent;
/** @type {?|undefined} */
LayoutState.prototype.layout;
/** @type {?|undefined} */
LayoutState.prototype.sidebarLeftElementHeight;
/** @type {?|undefined} */
LayoutState.prototype.sidebarRightElementHeight;
/** @type {?|undefined} */
LayoutState.prototype.sidebarLeftMenu;
/** @type {?|undefined} */
LayoutState.prototype.sidebarLeftMenuActiveUrl;
/** @type {?|undefined} */
LayoutState.prototype.skin;
/** @type {?|undefined} */
LayoutState.prototype.windowInnerHeight;
/** @type {?|undefined} */
LayoutState.prototype.windowInnerWidth;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var LayoutModule = /** @class */ (function () {
/**
* @method constructor
* @param parentModule [description]
*/
function LayoutModule(parentModule) {
if (parentModule) {
throw new Error('LayoutModule is already loaded. Import it in the AppModule only!');
}
}
/**
* [forRoot description]
* @method forRoot
* @param layoutConfig [description]
* @return [description]
*/
/**
* [forRoot description]
* \@method forRoot
* @param {?} layoutConfig [description]
* @return {?} [description]
*/
LayoutModule.forRoot = /**
* [forRoot description]
* \@method forRoot
* @param {?} layoutConfig [description]
* @return {?} [description]
*/
function (layoutConfig) {
return {
ngModule: LayoutModule,
providers: __spread(layoutProvider(layoutConfig), [LayoutService])
};
};
LayoutModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, router.RouterModule],
exports: [ContentModule, FooterModule, HeaderModule, SidebarLeftModule, SidebarRightModule, WrapperModule],
providers: [RoutingService, WrapperService, SidebarRightService, HeaderService, FooterService]
},] }
];
/** @nocollapse */
LayoutModule.ctorParameters = function () { return [
{ type: LayoutModule, decorators: [{ type: core.Optional }, { type: core.SkipSelf }] }
]; };
return LayoutModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @type {?} */
var colorsAliases = [
'default',
'primary',
'danger',
'warning',
'info',
'success'
];
/** @type {?} */
var colors = {
'aqua': '#00c0ef',
'aqua-active': '#00a7d0',
'black': '#111111',
'black-active': '#000000',
'blue': '#0073b7',
'blue-active': '#005384',
'fuchsia': '#f012be',
'fuchsia-active': '#db0ead',
'green': '#00a65a',
'green-active': '#008d4c',
'gray': '#d2d6de',
'gray-active': '#b5bbc8',
'gray-light': '#f7f7f7',
'light-blue': '#3c8dbc',
'light-blue-active': '#357ca5',
'lime': '#01ff70',
'lime-active': '#00e765',
'maroon': '#d81b60',
'maroon-active': '#ca195a',
'navy': '#001f3f',
'navy-active': '#001a35',
'olive': '#3d9970',
'olive-active': '#368763',
'orange': '#ff851b',
'orange-active': '#ff7701',
'purple': '#605ca8',
'purple-active': '#555299',
'red': '#dd4b39',
'red-active': '#d33724',
'teal': '#39cccc',
'teal-active': '#30bbbb',
'yellow': '#f39c12',
'yellow-active': '#db8b0b',
};
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var ColorService = /** @class */ (function () {
/**
* @method constructor
* @param renderer2 [description]
* @param elementRef [description]
*/
function ColorService(renderer2, elementRef) {
this.renderer2 = renderer2;
this.elementRef = elementRef;
// this.init();
// console.log(this);
}
/**
* [setBackgroundColor description]
* @method setBackgroundColor
* @param color [description]
* @param condition [description]
* @param property [description]
* @param prefix [description]
*/
/**
* [setBackgroundColor description]
* \@method setBackgroundColor
* @param {?} color [description]
* @param {?} condition [description]
* @param {?} property [description]
* @param {?} prefix [description]
* @return {?}
*/
ColorService.prototype.setBackgroundColor = /**
* [setBackgroundColor description]
* \@method setBackgroundColor
* @param {?} color [description]
* @param {?} condition [description]
* @param {?} property [description]
* @param {?} prefix [description]
* @return {?}
*/
function (color, condition, property, prefix) {
if (color && condition) {
this.resetBackgroundColor();
if (colors[color]) {
this.renderer2.addClass(this.elementRef.nativeElement, 'bg-color');
this.currentBackgroundStyle = { property: property, color: colors[color] };
this.renderer2.setStyle(this.elementRef.nativeElement, property, colors[color]);
}
else {
this.renderer2.removeClass(this.elementRef.nativeElement, 'bg-color');
if (color.indexOf('#') === 0 || color.indexOf('rgb') === 0) {
this.currentBackgroundStyle = { property: property, color: color };
this.renderer2.setStyle(this.elementRef.nativeElement, property, color);
}
else if (colorsAliases.indexOf(color) !== -1) {
this.currentBackgroundClass = prefix ? prefix + "-" + color : color;
this.renderer2.addClass(this.elementRef.nativeElement, this.currentBackgroundClass);
}
}
}
};
/**
* [resetBackgroundColor description]
* @method resetBackgroundColor
*/
/**
* [resetBackgroundColor description]
* \@method resetBackgroundColor
* @return {?}
*/
ColorService.prototype.resetBackgroundColor = /**
* [resetBackgroundColor description]
* \@method resetBackgroundColor
* @return {?}
*/
function () {
if (this.currentBackgroundStyle) {
this.renderer2.removeStyle(this.elementRef.nativeElement, this.currentBackgroundStyle.property, this.currentBackgroundStyle.color);
}
else if (this.currentBackgroundClass) {
this.renderer2.removeClass(this.elementRef.nativeElement, this.currentBackgroundClass);
}
};
/**
* [setFontColor description]
* @method setFontColor
* @param color [description]
*/
/**
* [setFontColor description]
* \@method setFontColor
* @param {?} color [description]
* @return {?}
*/
ColorService.prototype.setFontColor = /**
* [setFontColor description]
* \@method setFontColor
* @param {?} color [description]
* @return {?}
*/
function (color) {
if (color) {
this.resetFontColor();
if (color.startsWith('#') || color.startsWith('rgb')) {
this.currentFontStyle = color;
this.renderer2.setStyle(this.elementRef.nativeElement, 'color', color);
}
else {
this.currentFontClass = "text-" + color;
this.renderer2.addClass(this.elementRef.nativeElement, this.currentFontClass);
}
}
};
/**
* [resetFontColor description]
* @method resetFontColor
* @return [description]
*/
/**
* [resetFontColor description]
* \@method resetFontColor
* @return {?} [description]
*/
ColorService.prototype.resetFontColor = /**
* [resetFontColor description]
* \@method resetFontColor
* @return {?} [description]
*/
function () {
if (this.currentFontStyle) {
this.renderer2.removeStyle(this.elementRef.nativeElement, 'color', this.currentFontStyle);
}
else if (this.currentFontClass) {
this.renderer2.removeClass(this.elementRef.nativeElement, this.currentFontClass);
}
};
ColorService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
ColorService.ctorParameters = function () { return [
{ type: core.Renderer2 },
{ type: core.ElementRef }
]; };
return ColorService;
}());
if (false) {
/**
* @type {?}
* @private
*/
ColorService.prototype.currentBackgroundStyle;
/**
* @type {?}
* @private
*/
ColorService.prototype.currentBackgroundClass;
/**
* @type {?}
* @private
*/
ColorService.prototype.currentFontStyle;
/**
* @type {?}
* @private
*/
ColorService.prototype.currentFontClass;
/**
* @type {?}
* @private
*/
ColorService.prototype.renderer2;
/**
* @type {?}
* @private
*/
ColorService.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var BackgroundColorDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
* @param renderer2 [description]
* @param colorService [description]
*/
function BackgroundColorDirective(elementRef, renderer2, colorService) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.colorService = colorService;
this.condition = true;
}
Object.defineProperty(BackgroundColorDirective.prototype, "color", {
set: /**
* @param {?} color
* @return {?}
*/
function (color) {
this.colorService.setBackgroundColor(color, this.condition, this.property, this.prefix);
},
enumerable: true,
configurable: true
});
BackgroundColorDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkColor]',
providers: [ColorService]
},] }
];
/** @nocollapse */
BackgroundColorDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: ColorService }
]; };
BackgroundColorDirective.propDecorators = {
condition: [{ type: core.Input, args: ['mkColorCondition',] }],
prefix: [{ type: core.Input, args: ['mkColorPrefix',] }],
property: [{ type: core.Input, args: ['mkColorProperty',] }],
color: [{ type: core.Input, args: ['mkColor',] }]
};
return BackgroundColorDirective;
}());
if (false) {
/** @type {?} */
BackgroundColorDirective.prototype.condition;
/** @type {?} */
BackgroundColorDirective.prototype.prefix;
/** @type {?} */
BackgroundColorDirective.prototype.property;
/**
* @type {?}
* @private
*/
BackgroundColorDirective.prototype.elementRef;
/**
* @type {?}
* @private
*/
BackgroundColorDirective.prototype.renderer2;
/**
* @type {?}
* @private
*/
BackgroundColorDirective.prototype.colorService;
}
var ColorDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
* @param renderer2 [description]
* @param colorService [description]
*/
function ColorDirective(elementRef, renderer2, colorService) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.colorService = colorService;
}
Object.defineProperty(ColorDirective.prototype, "color", {
set: /**
* @param {?} color
* @return {?}
*/
function (color) {
this.colorService.setFontColor(color);
},
enumerable: true,
configurable: true
});
ColorDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkFontColor]',
providers: [ColorService]
},] }
];
/** @nocollapse */
ColorDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: ColorService }
]; };
ColorDirective.propDecorators = {
color: [{ type: core.Input, args: ['mkFontColor',] }]
};
return ColorDirective;
}());
if (false) {
/**
* @type {?}
* @private
*/
ColorDirective.prototype.elementRef;
/**
* @type {?}
* @private
*/
ColorDirective.prototype.renderer2;
/**
* @type {?}
* @private
*/
ColorDirective.prototype.colorService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var ColorModule = /** @class */ (function () {
function ColorModule() {
}
ColorModule.decorators = [
{ type: core.NgModule, args: [{
exports: [BackgroundColorDirective, ColorDirective],
declarations: [BackgroundColorDirective, ColorDirective]
},] }
];
return ColorModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var AccordionToggleDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
*/
function AccordionToggleDirective(elementRef) {
this.elementRef = elementRef;
}
AccordionToggleDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkAccordionToggle]'
},] }
];
/** @nocollapse */
AccordionToggleDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
AccordionToggleDirective.propDecorators = {
accordionComponent: [{ type: core.Input, args: ['mkAccordionToggle',] }]
};
return AccordionToggleDirective;
}());
if (false) {
/** @type {?} */
AccordionToggleDirective.prototype.accordionComponent;
/** @type {?} */
AccordionToggleDirective.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var AccordionHeaderComponent = /** @class */ (function () {
function AccordionHeaderComponent() {
}
AccordionHeaderComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-accordion-header',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
AccordionHeaderComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return AccordionHeaderComponent;
}());
if (false) {
/** @type {?} */
AccordionHeaderComponent.prototype.templateRef;
}
/*
*
*/
var AccordionContentComponent = /** @class */ (function () {
function AccordionContentComponent() {
}
AccordionContentComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-accordion-content',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
AccordionContentComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return AccordionContentComponent;
}());
if (false) {
/** @type {?} */
AccordionContentComponent.prototype.templateRef;
}
/*
*
*/
var AccordionComponent = /** @class */ (function () {
function AccordionComponent() {
this.contentStyleClass = 'box-body';
this.headerStyleClass = 'box-header with-border';
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
AccordionComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
this.headerStyleColor = this.headerColor;
if (!this.header && !this.accordionHeaderComponent) {
throw new Error('Attribute "header" OR Component "mk-+accordion-header" is required for component "mk-+accordion"');
}
if (this.accordionContentComponent) {
this.contentTemplateRef = this.accordionContentComponent.templateRef;
}
else {
this.contentTemplateRef = this.templateRef;
}
};
AccordionComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-accordion',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>'
}] }
];
AccordionComponent.propDecorators = {
borderColor: [{ type: core.Input }],
contentColor: [{ type: core.Input }],
contentStyleClass: [{ type: core.Input }],
header: [{ type: core.Input }],
headerColor: [{ type: core.Input }],
headerColorHover: [{ type: core.Input }],
headerStyleClass: [{ type: core.Input }],
accordionHeaderComponent: [{ type: core.ContentChild, args: [AccordionHeaderComponent, { static: true },] }],
accordionContentComponent: [{ type: core.ContentChild, args: [AccordionContentComponent, { static: true },] }],
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return AccordionComponent;
}());
if (false) {
/** @type {?} */
AccordionComponent.prototype.contentTemplateRef;
/** @type {?} */
AccordionComponent.prototype.headerStyleColor;
/** @type {?} */
AccordionComponent.prototype.isCollapsing;
/** @type {?} */
AccordionComponent.prototype.isCollapsed;
/** @type {?} */
AccordionComponent.prototype.index;
/** @type {?} */
AccordionComponent.prototype.borderColor;
/** @type {?} */
AccordionComponent.prototype.contentColor;
/** @type {?} */
AccordionComponent.prototype.contentStyleClass;
/** @type {?} */
AccordionComponent.prototype.header;
/** @type {?} */
AccordionComponent.prototype.headerColor;
/** @type {?} */
AccordionComponent.prototype.headerColorHover;
/** @type {?} */
AccordionComponent.prototype.headerStyleClass;
/** @type {?} */
AccordionComponent.prototype.accordionHeaderComponent;
/** @type {?} */
AccordionComponent.prototype.accordionContentComponent;
/** @type {?} */
AccordionComponent.prototype.templateRef;
}
/*
*
*/
var AccordionGroupComponent = /** @class */ (function () {
/**
* @method constructor
* @param changeDetectorRef [description]
* @param ngZone [description]
* @param renderer2 [description]
*/
function AccordionGroupComponent(changeDetectorRef, ngZone, renderer2) {
this.changeDetectorRef = changeDetectorRef;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.activeIndex = [0];
// @TODO change types for listeners to all files
this.listeners = [];
// @TODO change types for subscriptions to all files
this.subscriptions = [];
this.styleClass = 'box-group';
this.onCollapseStart = new core.EventEmitter();
this.onCollapseDone = new core.EventEmitter();
}
Object.defineProperty(AccordionGroupComponent.prototype, "_activeIndex", {
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this.activeIndex = value instanceof Array ? value : [value];
},
enumerable: true,
configurable: true
});
/**
* [headerMouseLeave description]
* @method headerMouseLeave
* @param accordion [description]
*/
/**
* [headerMouseLeave description]
* \@method headerMouseLeave
* @param {?} accordion [description]
* @return {?}
*/
AccordionGroupComponent.headerMouseLeave = /**
* [headerMouseLeave description]
* \@method headerMouseLeave
* @param {?} accordion [description]
* @return {?}
*/
function (accordion) {
accordion.headerStyleColor = accordion.headerColor;
};
/**
* [headerMouseEnter description]
* @method headerMouseEnter
* @param accordion [description]
*/
/**
* [headerMouseEnter description]
* \@method headerMouseEnter
* @param {?} accordion [description]
* @return {?}
*/
AccordionGroupComponent.headerMouseEnter = /**
* [headerMouseEnter description]
* \@method headerMouseEnter
* @param {?} accordion [description]
* @return {?}
*/
function (accordion) {
if (accordion.headerColorHover) {
accordion.headerStyleColor = accordion.headerColorHover;
}
};
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
AccordionGroupComponent.prototype.ngAfterContentInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
this.setAccordionsIndex();
this.updateAccordionIsCollapsed();
this.subscriptions.push(this.accordionComponents.changes.subscribe((/**
* @return {?}
*/
function () {
_this.setAccordionsIndex();
})));
};
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
AccordionGroupComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
this.setAccordionsToggle();
this.subscriptions.push(this.accordionToggleDirectives.changes.subscribe((/**
* @return {?}
*/
function () {
_this.setAccordionsToggle();
})));
};
/**
* [ngOnChanges description]
* @method ngOnChanges
* @param changes [description]
* @return [description]
*/
/**
* [ngOnChanges description]
* \@method ngOnChanges
* @param {?} changes [description]
* @return {?} [description]
*/
AccordionGroupComponent.prototype.ngOnChanges = /**
* [ngOnChanges description]
* \@method ngOnChanges
* @param {?} changes [description]
* @return {?} [description]
*/
function (changes) {
if (changes._activeIndex.firstChange === false) {
this.updateAccordionIsCollapsed();
}
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
AccordionGroupComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
removeListeners(this.listeners);
removeSubscriptions(this.subscriptions);
};
/**
* [toggleAccordion description]
* @method toggleAccordion
* @param event [description]
* @param toggleIndex [description]
*/
/**
* [toggleAccordion description]
* \@method toggleAccordion
* @param {?} event [description]
* @param {?} toggleIndex [description]
* @return {?}
*/
AccordionGroupComponent.prototype.toggleAccordion = /**
* [toggleAccordion description]
* \@method toggleAccordion
* @param {?} event [description]
* @param {?} toggleIndex [description]
* @return {?}
*/
function (event, toggleIndex) {
event.preventDefault();
/** @type {?} */
var indexOf = this.activeIndex['indexOf'](toggleIndex);
if (indexOf === -1) {
if (this.isMultiple) {
this.activeIndex.push(toggleIndex);
}
else {
this.activeIndex = [toggleIndex];
}
}
else {
if (this.isMultiple) {
this.activeIndex.splice(indexOf, 1);
}
else {
this.activeIndex = [];
}
}
this.updateAccordionIsCollapsed();
};
/**
* [collapseStart description]
* @method collapseStart
* @param event [description]
* @param accordion [description]
*/
/**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @param {?} accordion [description]
* @return {?}
*/
AccordionGroupComponent.prototype.collapseStart = /**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @param {?} accordion [description]
* @return {?}
*/
function (event, accordion) {
accordion.isCollapsing = true;
this.onCollapseStart.emit({ animationEvent: event, index: accordion.index });
};
/**
* [collapseDone description]
* @method collapseDone
* @param event [description]
* @param accordion [description]
*/
/**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @param {?} accordion [description]
* @return {?}
*/
AccordionGroupComponent.prototype.collapseDone = /**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @param {?} accordion [description]
* @return {?}
*/
function (event, accordion) {
accordion.isCollapsing = false;
this.onCollapseDone.emit({ animationEvent: event, index: accordion.index });
};
/**
* [setAccordionsIndex description]
* @method setAccordionsIndex
*/
/**
* [setAccordionsIndex description]
* \@method setAccordionsIndex
* @private
* @return {?}
*/
AccordionGroupComponent.prototype.setAccordionsIndex = /**
* [setAccordionsIndex description]
* \@method setAccordionsIndex
* @private
* @return {?}
*/
function () {
this.accordionComponents.forEach((/**
* @param {?} accordion
* @param {?} index
* @return {?}
*/
function (accordion, index) {
accordion.index = index;
}));
};
/**
* [setAccordionsToggle description]
* @method setAccordionsToggle
*/
/**
* [setAccordionsToggle description]
* \@method setAccordionsToggle
* @private
* @return {?}
*/
AccordionGroupComponent.prototype.setAccordionsToggle = /**
* [setAccordionsToggle description]
* \@method setAccordionsToggle
* @private
* @return {?}
*/
function () {
var _this = this;
this.listeners = removeListeners(this.listeners);
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.accordionToggleDirectives.forEach((/**
* @param {?} accordionToggle
* @return {?}
*/
function (accordionToggle) {
_this.listeners.push(_this.renderer2.listen(accordionToggle.elementRef.nativeElement, 'click', (/**
* @param {?} event
* @return {?}
*/
function (event) {
_this.toggleAccordion(event, accordionToggle.accordionComponent.index);
_this.changeDetectorRef.detectChanges();
})));
_this.listeners.push(_this.renderer2.listen(accordionToggle.elementRef.nativeElement, 'mouseenter', (/**
* @return {?}
*/
function () {
AccordionGroupComponent.headerMouseEnter(accordionToggle.accordionComponent);
_this.changeDetectorRef.detectChanges();
})));
_this.listeners.push(_this.renderer2.listen(accordionToggle.elementRef.nativeElement, 'mouseleave', (/**
* @return {?}
*/
function () {
AccordionGroupComponent.headerMouseLeave(accordionToggle.accordionComponent);
_this.changeDetectorRef.detectChanges();
})));
}));
}));
};
/**
* [updateAccordionIsCollapsed description]
* @method updateAccordionIsCollapsed
*/
/**
* [updateAccordionIsCollapsed description]
* \@method updateAccordionIsCollapsed
* @private
* @return {?}
*/
AccordionGroupComponent.prototype.updateAccordionIsCollapsed = /**
* [updateAccordionIsCollapsed description]
* \@method updateAccordionIsCollapsed
* @private
* @return {?}
*/
function () {
var _this = this;
this.accordionComponents.forEach((/**
* @param {?} accordion
* @param {?} index
* @return {?}
*/
function (accordion, index) {
accordion.isCollapsed = _this.activeIndex.indexOf(index) === -1;
}));
};
AccordionGroupComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-accordion-group',
template: "<div [ngClass]=\"styleClass\">\r\n <div *ngFor=\"let accordion of accordionComponents\" class=\"panel box\" [mkColor]=\"accordion.borderColor\"\r\n mkColorProperty=\"border-top-color\" mkColorPrefix=\"box\">\r\n <div [ngClass]=\"accordion.headerStyleClass\"\r\n [class.no-border]=\"accordion.isCollapsed && !accordion.isCollapsing\">\r\n <h4 class=\"box-title\">\r\n <a [mkAccordionToggle]=\"accordion\" href=\"#\" [mkFontColor]=\"accordion.headerStyleColor\"\r\n [class.collapsed]=\"accordion.isCollapsed\">\r\n {{accordion.header}}\r\n <ng-template *ngIf=\"!accordion.header\"\r\n [ngTemplateOutlet]=\"accordion.accordionHeaderComponent?.templateRef\"></ng-template>\r\n </a>\r\n </h4>\r\n </div>\r\n <div class=\"panel-collapse\" [mkCollapseAnimation]=\"accordion.isCollapsed\"\r\n (mkCollapseAnimation.start)=\"collapseStart($event, accordion)\"\r\n (mkCollapseAnimation.done)=\"collapseDone($event, accordion)\">\r\n <div [ngClass]=\"accordion.contentStyleClass\" [mkFontColor]=\"accordion.contentColor\">\r\n <ng-template [ngTemplateOutlet]=\"accordion.contentTemplateRef\"></ng-template>\r\n </div>\r\n </div>\r\n </div>\r\n</div>"
}] }
];
/** @nocollapse */
AccordionGroupComponent.ctorParameters = function () { return [
{ type: core.ChangeDetectorRef },
{ type: core.NgZone },
{ type: core.Renderer2 }
]; };
AccordionGroupComponent.propDecorators = {
_activeIndex: [{ type: core.Input, args: ['activeIndex',] }],
isMultiple: [{ type: core.Input }],
styleClass: [{ type: core.Input }],
onCollapseStart: [{ type: core.Output }],
onCollapseDone: [{ type: core.Output }],
accordionComponents: [{ type: core.ContentChildren, args: [AccordionComponent,] }],
accordionToggleDirectives: [{ type: core.ViewChildren, args: [AccordionToggleDirective,] }]
};
return AccordionGroupComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.activeIndex;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.subscriptions;
/** @type {?} */
AccordionGroupComponent.prototype.isMultiple;
/** @type {?} */
AccordionGroupComponent.prototype.styleClass;
/** @type {?} */
AccordionGroupComponent.prototype.onCollapseStart;
/** @type {?} */
AccordionGroupComponent.prototype.onCollapseDone;
/** @type {?} */
AccordionGroupComponent.prototype.accordionComponents;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.accordionToggleDirectives;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
AccordionGroupComponent.prototype.renderer2;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AccordionModule = /** @class */ (function () {
function AccordionModule() {
}
AccordionModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, AnimationsModule, ColorModule],
exports: [AccordionHeaderComponent, AccordionContentComponent, AccordionComponent, AccordionGroupComponent],
declarations: [AccordionToggleDirective, AccordionHeaderComponent,
AccordionContentComponent, AccordionComponent, AccordionGroupComponent]
},] }
];
return AccordionModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var AlertComponent = /** @class */ (function () {
/**
* @method constructor
* @param changeDetectorRef [description]
* @param ngZone [description]
* @param renderer2 [description]
* @param viewContainerRef [description]
*/
function AlertComponent(changeDetectorRef, ngZone, renderer2, viewContainerRef) {
this.changeDetectorRef = changeDetectorRef;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.viewContainerRef = viewContainerRef;
this.dismissibleClass = 'alert-dismissible';
this.isDismissible = true;
this.remove = false;
this.type = 'alert';
this.listeners = [];
this.backgroundColor = 'danger';
this.styleClass = '';
this.onCollapseStart = new core.EventEmitter();
this.onCollapseDone = new core.EventEmitter();
}
Object.defineProperty(AlertComponent.prototype, "callout", {
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this.type = value ? 'callout' : 'alert';
},
enumerable: true,
configurable: true
});
Object.defineProperty(AlertComponent.prototype, "_isDismissible", {
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this.isDismissible = value;
if (value) {
this.dismissibleClass = this.type + "-dismissible";
}
else {
this.dismissibleClass = '';
}
},
enumerable: true,
configurable: true
});
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
AlertComponent.prototype.ngAfterViewInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
var _this = this;
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
if (_this.dismissOnTimeout) {
setTimeout((/**
* @return {?}
*/
function () {
if (!((/** @type {?} */ (_this.changeDetectorRef))).destroyed) {
_this.remove = true;
_this.changeDetectorRef.detectChanges();
}
}), _this.dismissOnTimeout);
}
if (_this.removeButtonElement) {
_this.listeners.push(_this.renderer2.listen(_this.removeButtonElement.nativeElement, 'click', (/**
* @return {?}
*/
function () {
_this.remove = true;
_this.changeDetectorRef.detectChanges();
})));
}
}));
};
/**
* @method ngOnDesroy
*/
/**
* \@method ngOnDesroy
* @return {?}
*/
AlertComponent.prototype.ngOnDestroy = /**
* \@method ngOnDesroy
* @return {?}
*/
function () {
removeListeners(this.listeners);
};
/**
* [collapseStart description]
* @method collapseStart
* @param event [description]
*/
/**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @return {?}
*/
AlertComponent.prototype.collapseStart = /**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @return {?}
*/
function (event) {
this.onCollapseStart.emit(event);
};
/**
* [collapseDone description]
* @method collapseDone
* @param event [description]
*/
/**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @return {?}
*/
AlertComponent.prototype.collapseDone = /**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @return {?}
*/
function (event) {
if (event.toState === '1') {
this.listeners = removeListeners(this.listeners);
this.removed = true;
this.viewContainerRef.clear();
this.changeDetectorRef.detectChanges();
}
this.onCollapseDone.emit(event);
};
AlertComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-alert',
template: "<div *ngIf=\"!removed\" [mkCollapseAnimation]=\"remove\" (mkCollapseAnimation.start)=\"collapseStart($event)\"\r\n (mkCollapseAnimation.done)=\"collapseDone($event)\">\r\n <div [mkColor]=\"backgroundColor\" mkColorProperty=\"background-color\" [mkColorPrefix]=\"type\" [mkFontColor]=\"color\"\r\n [ngClass]=\"[styleClass, dismissibleClass, type]\">\r\n <button *ngIf=\"isDismissible\" type=\"button\" class=\"close\" #removeButtonElement>×</button>\r\n <ng-content></ng-content>\r\n </div>\r\n</div>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [".callout-dismissable,.callout-dismissible{padding-right:35px}.callout-dismissable .close,.callout-dismissible .close{position:relative;top:-2px;right:-21px;color:inherit}.callout .close{color:#000;opacity:.2}.callout .icon{margin-right:10px}"]
}] }
];
/** @nocollapse */
AlertComponent.ctorParameters = function () { return [
{ type: core.ChangeDetectorRef },
{ type: core.NgZone },
{ type: core.Renderer2 },
{ type: core.ViewContainerRef }
]; };
AlertComponent.propDecorators = {
backgroundColor: [{ type: core.Input }],
callout: [{ type: core.Input }],
color: [{ type: core.Input }],
dismissOnTimeout: [{ type: core.Input }],
_isDismissible: [{ type: core.Input, args: ['isDismissible',] }],
styleClass: [{ type: core.Input }],
onCollapseStart: [{ type: core.Output }],
onCollapseDone: [{ type: core.Output }],
removeButtonElement: [{ type: core.ViewChild, args: ['removeButtonElement', { static: true },] }],
containerElementRef: [{ type: core.ViewChild, args: ['containerElementRef', { static: true, read: core.ViewContainerRef },] }]
};
return AlertComponent;
}());
if (false) {
/** @type {?} */
AlertComponent.prototype.dismissibleClass;
/** @type {?} */
AlertComponent.prototype.isDismissible;
/** @type {?} */
AlertComponent.prototype.remove;
/** @type {?} */
AlertComponent.prototype.removed;
/** @type {?} */
AlertComponent.prototype.type;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.listeners;
/** @type {?} */
AlertComponent.prototype.backgroundColor;
/** @type {?} */
AlertComponent.prototype.color;
/** @type {?} */
AlertComponent.prototype.dismissOnTimeout;
/** @type {?} */
AlertComponent.prototype.styleClass;
/** @type {?} */
AlertComponent.prototype.onCollapseStart;
/** @type {?} */
AlertComponent.prototype.onCollapseDone;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.removeButtonElement;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.containerElementRef;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.renderer2;
/**
* @type {?}
* @private
*/
AlertComponent.prototype.viewContainerRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AlertModule = /** @class */ (function () {
function AlertModule() {
}
AlertModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, AnimationsModule, ColorModule],
exports: [AlertComponent],
declarations: [AlertComponent]
},] }
];
return AlertModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxContentDirective = /** @class */ (function () {
function BoxContentDirective() {
}
BoxContentDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-content'
},] }
];
return BoxContentDirective;
}());
/*
*
*/
var BoxFooterDirective = /** @class */ (function () {
function BoxFooterDirective() {
}
BoxFooterDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-footer'
},] }
];
return BoxFooterDirective;
}());
/*
*
*/
var BoxToolsDirective = /** @class */ (function () {
function BoxToolsDirective() {
}
BoxToolsDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-tools'
},] }
];
return BoxToolsDirective;
}());
/*
*
*/
var BoxHeaderDirective = /** @class */ (function () {
function BoxHeaderDirective() {
}
BoxHeaderDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-header'
},] }
];
return BoxHeaderDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxComponent = /** @class */ (function () {
/**
* @method constructor
* @param changeDetectorRef [description]
* @param ngZone [description]
* @param renderer2 [description]
*/
function BoxComponent(changeDetectorRef, ngZone, renderer2) {
this.changeDetectorRef = changeDetectorRef;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.remove = false;
this.listeners = [];
this.boxColor = 'default';
this.buttonsStyleClass = 'btn btn-box-tool';
this.contentStyleClass = 'box-content-wrapper';
this.footerStyleClass = 'box-footer';
this.headerBorder = true;
this.headerStyleClass = 'box-header';
this.isCollapsable = true;
this.isCollapsed = false;
this.isRemovable = true;
this.isSolid = false;
this.loadingStyleClass = 'fa fa-refresh fa-spin';
this.styleClass = 'box';
this.onCollapseDone = new core.EventEmitter();
this.onCollapseStart = new core.EventEmitter();
}
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
BoxComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
if (_this.toggleButtonElement) {
_this.listeners.push(_this.renderer2.listen(_this.toggleButtonElement.nativeElement, 'click', (/**
* @return {?}
*/
function () {
_this.isCollapsed = !_this.isCollapsed;
_this.changeDetectorRef.detectChanges();
})));
}
if (_this.removeButtonElement) {
_this.listeners.push(_this.renderer2.listen(_this.removeButtonElement.nativeElement, 'click', (/**
* @return {?}
*/
function () {
_this.remove = true;
_this.changeDetectorRef.detectChanges();
})));
}
}));
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
BoxComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
removeListeners(this.listeners);
};
/**
* [removedDone description]
* @method removedDone
* @param event [description]
*/
/**
* [removedDone description]
* \@method removedDone
* @param {?} event [description]
* @return {?}
*/
BoxComponent.prototype.removedDone = /**
* [removedDone description]
* \@method removedDone
* @param {?} event [description]
* @return {?}
*/
function (event) {
if (event.toState === '1') {
this.removed = true;
}
};
/**
* [collapseStart description]
* @method collapseStart
* @param event [description]
*/
/**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @return {?}
*/
BoxComponent.prototype.collapseStart = /**
* [collapseStart description]
* \@method collapseStart
* @param {?} event [description]
* @return {?}
*/
function (event) {
if (event.fromState !== 'void') {
this.isCollaping = true;
this.onCollapseStart.emit(event);
}
};
/**
* [collapseDone description]
* @method collapseDone
* @param event [description]
*/
/**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @return {?}
*/
BoxComponent.prototype.collapseDone = /**
* [collapseDone description]
* \@method collapseDone
* @param {?} event [description]
* @return {?}
*/
function (event) {
if (event.fromState !== 'void') {
this.isCollaping = false;
this.onCollapseDone.emit(event);
}
};
BoxComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-box',
template: "<div *ngIf=\"!removed\" [mkColor]=\"boxColor\" mkColorProperty=\"border-color\" mkColorPrefix=\"box\" [ngClass]=\"styleClass\"\r\n [class.collapsed-box]=\"isCollapsed && !isCollaping\" [class.box-solid]=\"isSolid\" [mkCollapseAnimation]=\"remove\"\r\n (mkCollapseAnimation.done)=\"removedDone($event)\">\r\n <div *ngIf=\"header || boxHeaderDirective\" [ngClass]=\"headerStyleClass\" [mkColor]=\"boxColor\"\r\n [mkColorCondition]=\"isSolid\" mkColorProperty=\"background-color\" [class.with-border]=\"headerBorder\">\r\n <h3 class=\"box-title\" [mkFontColor]=\"headerColor\">\r\n {{header}}\r\n <ng-content select=\"mk-box-header\"></ng-content>\r\n </h3>\r\n <div class=\"box-tools pull-right\">\r\n <ng-content select=\"mk-box-tools\"></ng-content>\r\n <button *ngIf=\"isCollapsable\" type=\"button\" [ngClass]=\"buttonsStyleClass\" #toggleButtonElement>\r\n <i class=\"fa\" [ngClass]=\"{'fa-plus': isCollapsed, 'fa-minus': !isCollapsed}\"></i>\r\n </button>\r\n <button *ngIf=\"isRemovable\" type=\"button\" [ngClass]=\"buttonsStyleClass\" #removeButtonElement>\r\n <i class=\"fa fa-times\"></i>\r\n </button>\r\n </div>\r\n </div>\r\n <div [ngClass]=\"contentStyleClass\" [mkFontColor]=\"contentColor\" [mkCollapseAnimation]=\"isCollapsed\"\r\n (mkCollapseAnimation.start)=\"collapseStart($event)\" (mkCollapseAnimation.done)=\"collapseDone($event)\">\r\n <div class=\"box-body\">\r\n <ng-container\r\n *ngIf=\"boxHeaderDirective || boxContentDirective || boxFooterDirective || boxToolsDirective; else noDirective\">\r\n <ng-content select=\"mk-box-content\"></ng-content>\r\n </ng-container>\r\n <ng-template #noDirective>\r\n <ng-content></ng-content>\r\n </ng-template>\r\n </div>\r\n <div *ngIf=\"footer || boxFooterDirective\" [ngClass]=\"footerStyleClass\" [mkFontColor]=\"footerColor\">\r\n {{footer}}\r\n <ng-content select=\"mk-box-footer\"></ng-content>\r\n </div>\r\n </div>\r\n <div *ngIf=\"isLoading\" class=\"overlay\">\r\n <i [ngClass]=\"loadingStyleClass\" [mkFontColor]=\"loadingColor\"></i>\r\n </div>\r\n</div>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [".box.collapsed-box .box-body,.box.collapsed-box .box-footer{display:inherit}.box-solid{border:1px solid}.box-body{background-color:#fff}.box.box-solid.bg-color>.box-header{color:#fff}"]
}] }
];
/** @nocollapse */
BoxComponent.ctorParameters = function () { return [
{ type: core.ChangeDetectorRef },
{ type: core.NgZone },
{ type: core.Renderer2 }
]; };
BoxComponent.propDecorators = {
boxColor: [{ type: core.Input }],
buttonsStyleClass: [{ type: core.Input }],
contentStyleClass: [{ type: core.Input }],
contentColor: [{ type: core.Input }],
footer: [{ type: core.Input }],
footerColor: [{ type: core.Input }],
footerStyleClass: [{ type: core.Input }],
header: [{ type: core.Input }],
headerBorder: [{ type: core.Input }],
headerColor: [{ type: core.Input }],
headerStyleClass: [{ type: core.Input }],
isCollapsable: [{ type: core.Input }],
isCollapsed: [{ type: core.Input }],
isLoading: [{ type: core.Input }],
isRemovable: [{ type: core.Input }],
isSolid: [{ type: core.Input }],
loadingColor: [{ type: core.Input }],
loadingStyleClass: [{ type: core.Input }],
styleClass: [{ type: core.Input }],
onCollapseDone: [{ type: core.Output }],
onCollapseStart: [{ type: core.Output }],
boxHeaderDirective: [{ type: core.ContentChild, args: [BoxHeaderDirective, { static: true },] }],
boxFooterDirective: [{ type: core.ContentChild, args: [BoxFooterDirective, { static: true },] }],
boxContentDirective: [{ type: core.ContentChild, args: [BoxContentDirective, { static: true },] }],
boxToolsDirective: [{ type: core.ContentChild, args: [BoxToolsDirective, { static: true },] }],
toggleButtonElement: [{ type: core.ViewChild, args: ['toggleButtonElement', { static: true },] }],
removeButtonElement: [{ type: core.ViewChild, args: ['removeButtonElement', { static: true },] }]
};
return BoxComponent;
}());
if (false) {
/** @type {?} */
BoxComponent.prototype.isCollaping;
/** @type {?} */
BoxComponent.prototype.remove;
/** @type {?} */
BoxComponent.prototype.removed;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.listeners;
/** @type {?} */
BoxComponent.prototype.boxColor;
/** @type {?} */
BoxComponent.prototype.buttonsStyleClass;
/** @type {?} */
BoxComponent.prototype.contentStyleClass;
/** @type {?} */
BoxComponent.prototype.contentColor;
/** @type {?} */
BoxComponent.prototype.footer;
/** @type {?} */
BoxComponent.prototype.footerColor;
/** @type {?} */
BoxComponent.prototype.footerStyleClass;
/** @type {?} */
BoxComponent.prototype.header;
/** @type {?} */
BoxComponent.prototype.headerBorder;
/** @type {?} */
BoxComponent.prototype.headerColor;
/** @type {?} */
BoxComponent.prototype.headerStyleClass;
/** @type {?} */
BoxComponent.prototype.isCollapsable;
/** @type {?} */
BoxComponent.prototype.isCollapsed;
/** @type {?} */
BoxComponent.prototype.isLoading;
/** @type {?} */
BoxComponent.prototype.isRemovable;
/** @type {?} */
BoxComponent.prototype.isSolid;
/** @type {?} */
BoxComponent.prototype.loadingColor;
/** @type {?} */
BoxComponent.prototype.loadingStyleClass;
/** @type {?} */
BoxComponent.prototype.styleClass;
/** @type {?} */
BoxComponent.prototype.onCollapseDone;
/** @type {?} */
BoxComponent.prototype.onCollapseStart;
/** @type {?} */
BoxComponent.prototype.boxHeaderDirective;
/** @type {?} */
BoxComponent.prototype.boxFooterDirective;
/** @type {?} */
BoxComponent.prototype.boxContentDirective;
/** @type {?} */
BoxComponent.prototype.boxToolsDirective;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.toggleButtonElement;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.removeButtonElement;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
BoxComponent.prototype.renderer2;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var BoxModule = /** @class */ (function () {
function BoxModule() {
}
BoxModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, AnimationsModule, ColorModule],
exports: [BoxComponent, BoxHeaderDirective, BoxContentDirective, BoxFooterDirective,
BoxToolsDirective],
declarations: [BoxComponent, BoxHeaderDirective, BoxContentDirective, BoxFooterDirective, BoxToolsDirective]
},] }
];
return BoxModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxInfoContentDirective = /** @class */ (function () {
function BoxInfoContentDirective() {
}
BoxInfoContentDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-info-content'
},] }
];
return BoxInfoContentDirective;
}());
/*
*
*/
var BoxInfoFooterDirective = /** @class */ (function () {
function BoxInfoFooterDirective() {
}
BoxInfoFooterDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-info-footer'
},] }
];
return BoxInfoFooterDirective;
}());
/*
*
*/
var BoxInfoHeaderDirective = /** @class */ (function () {
function BoxInfoHeaderDirective() {
}
BoxInfoHeaderDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-info-header'
},] }
];
return BoxInfoHeaderDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxInfoComponent = /** @class */ (function () {
function BoxInfoComponent() {
this.contentStyleClass = 'info-box-number';
this.footerStyleClass = 'progress-description';
this.headerStyleClass = 'info-box-text';
this.iconColor = '#fff';
this.iconStyleClass = 'ion ion-bag';
this.styleClass = 'info-box';
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
BoxInfoComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
if (!this.backgroundColor) {
this.progressBarBg = this.iconBackgroundColor;
}
};
BoxInfoComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-box-info',
template: "<div [ngClass]=\"styleClass\" [mkColor]=\"backgroundColor\" mkColorProperty=\"background-color\">\r\n <span class=\"info-box-icon\" [mkColor]=\"iconBackgroundColor\" mkColorProperty=\"background-color\">\r\n <i [ngClass]=\"iconStyleClass\" [mkFontColor]=\"iconColor\"></i>\r\n </span>\r\n <div class=\"info-box-content\">\r\n <span *ngIf=\"header || boxInfoHeaderDirective\" [ngClass]=\"headerStyleClass\" [mkFontColor]=\"headerColor\">\r\n {{header}}\r\n <ng-content select=\"mk-box-header\"></ng-content>\r\n </span>\r\n <span [ngClass]=\"contentStyleClass\" [mkFontColor]=\"contentColor\">\r\n <ng-container\r\n *ngIf=\"boxInfoHeaderDirective || boxInfoContentDirective || boxInfoFooterDirective; else noDirective\">\r\n <ng-content select=\"mk-box-content\"></ng-content>\r\n </ng-container>\r\n <ng-template #noDirective>\r\n <ng-content></ng-content>\r\n </ng-template>\r\n </span>\r\n <div *ngIf=\"progressWidth\" class=\"progress\">\r\n <div class=\"progress-bar\" [mkColor]=\"progressBarBg\" mkColorProperty=\"background-color\"\r\n [style.width.%]=\"progressWidth\"></div>\r\n </div>\r\n <span *ngIf=\"footer || boxInfoFooterDirective\" [ngClass]=\"footerStyleClass\" [mkFontColor]=\"footerColor\">\r\n {{footer}}\r\n <ng-content select=\"mk-box-footer\"></ng-content>\r\n </span>\r\n </div>\r\n</div>",
styles: [".info-box.bg-color>.info-box-content{color:#fff}"]
}] }
];
BoxInfoComponent.propDecorators = {
backgroundColor: [{ type: core.Input }],
contentStyleClass: [{ type: core.Input }],
contentColor: [{ type: core.Input }],
footer: [{ type: core.Input }],
footerColor: [{ type: core.Input }],
footerStyleClass: [{ type: core.Input }],
header: [{ type: core.Input }],
headerColor: [{ type: core.Input }],
headerStyleClass: [{ type: core.Input }],
iconBackgroundColor: [{ type: core.Input }],
iconColor: [{ type: core.Input }],
iconStyleClass: [{ type: core.Input }],
progressWidth: [{ type: core.Input }],
styleClass: [{ type: core.Input }],
boxInfoHeaderDirective: [{ type: core.ContentChild, args: [BoxInfoHeaderDirective, { static: true },] }],
boxInfoFooterDirective: [{ type: core.ContentChild, args: [BoxInfoFooterDirective, { static: true },] }],
boxInfoContentDirective: [{ type: core.ContentChild, args: [BoxInfoContentDirective, { static: true },] }]
};
return BoxInfoComponent;
}());
if (false) {
/** @type {?} */
BoxInfoComponent.prototype.progressBarBg;
/** @type {?} */
BoxInfoComponent.prototype.backgroundColor;
/** @type {?} */
BoxInfoComponent.prototype.contentStyleClass;
/** @type {?} */
BoxInfoComponent.prototype.contentColor;
/** @type {?} */
BoxInfoComponent.prototype.footer;
/** @type {?} */
BoxInfoComponent.prototype.footerColor;
/** @type {?} */
BoxInfoComponent.prototype.footerStyleClass;
/** @type {?} */
BoxInfoComponent.prototype.header;
/** @type {?} */
BoxInfoComponent.prototype.headerColor;
/** @type {?} */
BoxInfoComponent.prototype.headerStyleClass;
/** @type {?} */
BoxInfoComponent.prototype.iconBackgroundColor;
/** @type {?} */
BoxInfoComponent.prototype.iconColor;
/** @type {?} */
BoxInfoComponent.prototype.iconStyleClass;
/** @type {?} */
BoxInfoComponent.prototype.progressWidth;
/** @type {?} */
BoxInfoComponent.prototype.styleClass;
/** @type {?} */
BoxInfoComponent.prototype.boxInfoHeaderDirective;
/** @type {?} */
BoxInfoComponent.prototype.boxInfoFooterDirective;
/** @type {?} */
BoxInfoComponent.prototype.boxInfoContentDirective;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var BoxInfoModule = /** @class */ (function () {
function BoxInfoModule() {
}
BoxInfoModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, ColorModule],
exports: [BoxInfoComponent, BoxInfoHeaderDirective, BoxInfoContentDirective, BoxInfoFooterDirective],
declarations: [BoxInfoComponent, BoxInfoHeaderDirective, BoxInfoContentDirective, BoxInfoFooterDirective]
},] }
];
return BoxInfoModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxSmallFooterDirective = /** @class */ (function () {
function BoxSmallFooterDirective() {
}
BoxSmallFooterDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-small-footer'
},] }
];
return BoxSmallFooterDirective;
}());
/*
*
*/
var BoxSmallHeaderDirective = /** @class */ (function () {
function BoxSmallHeaderDirective() {
}
BoxSmallHeaderDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-small-header'
},] }
];
return BoxSmallHeaderDirective;
}());
/*
*
*/
var BoxSmallContentDirective = /** @class */ (function () {
function BoxSmallContentDirective() {
}
BoxSmallContentDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-box-small-content'
},] }
];
return BoxSmallContentDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var BoxSmallComponent = /** @class */ (function () {
function BoxSmallComponent() {
this.contentStyleClass = 'small-box-content';
this.footerStyleClass = 'small-box-footer';
this.headerStyleClass = 'small-box-header';
this.iconStyleClass = 'ion ion-bag';
this.styleClass = 'small-box';
}
BoxSmallComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-box-small',
template: "<div [ngClass]=\"styleClass\" [mkColor]=\"backgroundColor\" mkColorProperty=\"background-color\">\r\n <div class=\"inner\">\r\n <h3 *ngIf=\"header || boxSmallHeaderDirective\" [ngClass]=\"headerStyleClass\" [mkFontColor]=\"headerColor\">\r\n {{header}}\r\n <ng-content select=\"mk-box-small-header\"></ng-content>\r\n </h3>\r\n <p [ngClass]=\"contentStyleClass\" [mkFontColor]=\"contentColor\">\r\n <ng-container\r\n *ngIf=\"boxSmallHeaderDirective || boxSmallContentDirective || boxSmallFooterDirective; else noDirective\">\r\n <ng-content select=\"mk-box-small-content\"></ng-content>\r\n </ng-container>\r\n <ng-template #noDirective>\r\n <ng-content></ng-content>\r\n </ng-template>\r\n </p>\r\n </div>\r\n <div *ngIf=\"iconStyleClass\" class=\"icon\">\r\n <i [ngClass]=\"iconStyleClass\" [mkFontColor]=\"iconColor\"></i>\r\n </div>\r\n <span *ngIf=\"footer || boxSmallFooterDirective\" [ngClass]=\"footerStyleClass\" [mkFontColor]=\"footerColor\">\r\n {{footer}}\r\n <ng-content select=\"mk-box-small-footer\"></ng-content>\r\n </span>\r\n</div>",
styles: [".small-box.bg-color{color:#fff}/deep/ .small-box-footer:hover{cursor:pointer}/deep/ .small-box-footer a{color:rgba(255,255,255,.8)}/deep/ .small-box-footer:hover a{color:#fff}"]
}] }
];
BoxSmallComponent.propDecorators = {
backgroundColor: [{ type: core.Input }],
contentColor: [{ type: core.Input }],
contentStyleClass: [{ type: core.Input }],
footer: [{ type: core.Input }],
footerColor: [{ type: core.Input }],
footerStyleClass: [{ type: core.Input }],
header: [{ type: core.Input }],
headerColor: [{ type: core.Input }],
headerStyleClass: [{ type: core.Input }],
iconColor: [{ type: core.Input }],
iconStyleClass: [{ type: core.Input }],
styleClass: [{ type: core.Input }],
boxSmallHeaderDirective: [{ type: core.ContentChild, args: [BoxSmallHeaderDirective, { static: true },] }],
boxSmallFooterDirective: [{ type: core.ContentChild, args: [BoxSmallFooterDirective, { static: true },] }],
boxSmallContentDirective: [{ type: core.ContentChild, args: [BoxSmallContentDirective, { static: true },] }]
};
return BoxSmallComponent;
}());
if (false) {
/** @type {?} */
BoxSmallComponent.prototype.backgroundColor;
/** @type {?} */
BoxSmallComponent.prototype.contentColor;
/** @type {?} */
BoxSmallComponent.prototype.contentStyleClass;
/** @type {?} */
BoxSmallComponent.prototype.footer;
/** @type {?} */
BoxSmallComponent.prototype.footerColor;
/** @type {?} */
BoxSmallComponent.prototype.footerStyleClass;
/** @type {?} */
BoxSmallComponent.prototype.header;
/** @type {?} */
BoxSmallComponent.prototype.headerColor;
/** @type {?} */
BoxSmallComponent.prototype.headerStyleClass;
/** @type {?} */
BoxSmallComponent.prototype.iconColor;
/** @type {?} */
BoxSmallComponent.prototype.iconStyleClass;
/** @type {?} */
BoxSmallComponent.prototype.styleClass;
/** @type {?} */
BoxSmallComponent.prototype.boxSmallHeaderDirective;
/** @type {?} */
BoxSmallComponent.prototype.boxSmallFooterDirective;
/** @type {?} */
BoxSmallComponent.prototype.boxSmallContentDirective;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var BoxSmallModule = /** @class */ (function () {
function BoxSmallModule() {
}
BoxSmallModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, ColorModule],
exports: [BoxSmallComponent, BoxSmallHeaderDirective, BoxSmallContentDirective, BoxSmallFooterDirective],
declarations: [BoxSmallComponent, BoxSmallHeaderDirective, BoxSmallContentDirective, BoxSmallFooterDirective]
},] }
];
return BoxSmallModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var ClassService = /** @class */ (function () {
function ClassService(elementRef, renderer2) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.currentClasses = [];
}
/**
* @param {?} cssClasses
* @return {?}
*/
ClassService.prototype.applyClasses = /**
* @param {?} cssClasses
* @return {?}
*/
function (cssClasses) {
var _this = this;
if (typeof cssClasses === 'string') {
cssClasses = cssClasses.split(' ');
}
// Remove only classes that are not in cssClasses
/** @type {?} */
var classesToRemove = this.currentClasses.filter((/**
* @param {?} x
* @return {?}
*/
function (x) { return cssClasses.indexOf(x) === -1; }));
classesToRemove.forEach((/**
* @param {?} cssClasse
* @return {?}
*/
function (cssClasse) {
if (cssClasse) {
_this.renderer2.removeClass(_this.elementRef.nativeElement, cssClasse);
}
}));
// Add only classes that are not in currentClasses
/** @type {?} */
var classesToAdd = cssClasses.filter((/**
* @param {?} x
* @return {?}
*/
function (x) { return _this.currentClasses.indexOf(x) === -1; }));
classesToAdd.forEach((/**
* @param {?} cssClasse
* @return {?}
*/
function (cssClasse) {
if (cssClasse) {
_this.renderer2.addClass(_this.elementRef.nativeElement, cssClasse);
}
}));
// Update current classes for futur updates
this.currentClasses = __spread(cssClasses);
};
ClassService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
ClassService.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 }
]; };
return ClassService;
}());
if (false) {
/**
* @type {?}
* @private
*/
ClassService.prototype.currentClasses;
/**
* @type {?}
* @private
*/
ClassService.prototype.elementRef;
/**
* @type {?}
* @private
*/
ClassService.prototype.renderer2;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// @TODO onFocus Color
var InputTextDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
* @param renderer2 [description]
* @param ngControl [description]
* @param colorService [description]
* @param classService [description]
*/
function InputTextDirective(elementRef, renderer2, ngControl, colorService, classService) {
this.elementRef = elementRef;
this.renderer2 = renderer2;
this.ngControl = ngControl;
this.colorService = colorService;
this.classService = classService;
this.defaultClass = 'form-control';
this._onKeyUp = new rxjs.Subject();
this.onKeyup = this._onKeyUp.asObservable();
}
Object.defineProperty(InputTextDirective.prototype, "borderColor", {
set: /**
* @param {?} color
* @return {?}
*/
function (color) {
this.colorService.setBackgroundColor(color, true, 'border-color', null);
},
enumerable: true,
configurable: true
});
Object.defineProperty(InputTextDirective.prototype, "class", {
set: /**
* @param {?} className
* @return {?}
*/
function (className) {
this.isSetClass = true;
this.classService.applyClasses(className);
},
enumerable: true,
configurable: true
});
Object.defineProperty(InputTextDirective.prototype, "color", {
set: /**
* @param {?} color
* @return {?}
*/
function (color) {
this.colorService.setFontColor(color);
},
enumerable: true,
configurable: true
});
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
InputTextDirective.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
if (!this.isSetClass) {
this.classService.applyClasses(this.defaultClass);
}
};
/**
* @return {?}
*/
InputTextDirective.prototype.keyUpListener = /**
* @return {?}
*/
function () {
this._onKeyUp.next(this.ngControl);
};
InputTextDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkInputText]',
providers: [ColorService, ClassService]
},] }
];
/** @nocollapse */
InputTextDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: forms.NgControl },
{ type: ColorService },
{ type: ClassService }
]; };
InputTextDirective.propDecorators = {
borderColor: [{ type: core.Input }],
class: [{ type: core.Input }],
color: [{ type: core.Input }],
keyUpListener: [{ type: core.HostListener, args: ['keyup',] }]
};
return InputTextDirective;
}());
if (false) {
/**
* @type {?}
* @private
*/
InputTextDirective.prototype.defaultClass;
/**
* @type {?}
* @private
*/
InputTextDirective.prototype.isSetClass;
/**
* @type {?}
* @private
*/
InputTextDirective.prototype._onKeyUp;
/** @type {?} */
InputTextDirective.prototype.onKeyup;
/** @type {?} */
InputTextDirective.prototype.elementRef;
/** @type {?} */
InputTextDirective.prototype.renderer2;
/**
* @type {?}
* @private
*/
InputTextDirective.prototype.ngControl;
/**
* @type {?}
* @private
*/
InputTextDirective.prototype.colorService;
/**
* @type {?}
* @private
*/
InputTextDirective.prototype.classService;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var InputGroupLabelDirective = /** @class */ (function () {
function InputGroupLabelDirective() {
}
InputGroupLabelDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-input-group-label'
},] }
];
return InputGroupLabelDirective;
}());
/*
*
*/
var InputGroupAddonLeftDirective = /** @class */ (function () {
function InputGroupAddonLeftDirective() {
}
InputGroupAddonLeftDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-input-group-addon-left'
},] }
];
return InputGroupAddonLeftDirective;
}());
/*
*
*/
var InputGroupAddonRightDirective = /** @class */ (function () {
function InputGroupAddonRightDirective() {
}
InputGroupAddonRightDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-input-group-addon-right'
},] }
];
return InputGroupAddonRightDirective;
}());
/*
*
*/
var InputGroupContentDirective = /** @class */ (function () {
function InputGroupContentDirective() {
}
InputGroupContentDirective.decorators = [
{ type: core.Directive, args: [{
/* tslint:disable-next-line:directive-selector */
selector: 'mk-input-group-content'
},] }
];
return InputGroupContentDirective;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var InputGroupComponent = /** @class */ (function () {
function InputGroupComponent() {
this.subscriptions = [];
this.inputColor = 'default';
this.inputErrorColor = 'danger';
this.inputValidColor = 'success';
this.wrapperClasses = 'form-group';
}
/**
* @return {?}
*/
InputGroupComponent.prototype.ngAfterContentInit = /**
* @return {?}
*/
function () {
var _this = this;
this.subscriptions.push(this.inputTextDirective.onKeyup.subscribe((/**
* @param {?} value
* @return {?}
*/
function (value) {
if (value.invalid) {
_this.currentColor = _this.inputErrorColor;
_this.currentFontColor = _this.inputErrorFontColor;
}
else if (!value.invalid) {
_this.currentColor = _this.inputValidColor;
_this.currentFontColor = _this.inputValidFontColor;
}
else {
_this.currentColor = _this.inputColor;
_this.currentFontColor = _this.inputFontColor;
}
})));
};
/**
* @return {?}
*/
InputGroupComponent.prototype.ngOnDestroy = /**
* @return {?}
*/
function () {
removeSubscriptions(this.subscriptions);
};
InputGroupComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-input-group',
template: "<div [ngClass]=\"wrapperClasses\" [mkColor]=\"currentColor || inputColor\" mkColorPrefix=\"has\">\r\n <label *ngIf=\"label || inputGroupLabelDirective\">\r\n {{label}}\r\n <ng-content select=\"mk-input-group-label\"></ng-content>\r\n </label>\r\n <div *ngIf=\"addonLeft || inputGroupAddonLeftDirective || addonRight || inputGroupAddonRightDirective; else noAddon\"\r\n class=\"input-group\">\r\n <span *ngIf=\"addonLeft || inputGroupAddonLeftDirective\" class=\"input-group-addon\">\r\n {{addonLeft}}\r\n <ng-content select=\"mk-input-group-addon-left\"></ng-content>\r\n </span>\r\n <ng-content select=\"mk-input-group-content\"></ng-content>\r\n <span *ngIf=\"addonRight || inputGroupAddonRightDirective\" class=\"input-group-addon\">\r\n {{addonRight}}\r\n <ng-content select=\"mk-input-group-addon-right\"></ng-content>\r\n </span>\r\n </div>\r\n <ng-template #noAddon>\r\n <ng-content select=\"mk-input-group-content\"></ng-content>\r\n </ng-template>\r\n</div>"
}] }
];
InputGroupComponent.propDecorators = {
addonLeft: [{ type: core.Input }],
addonRight: [{ type: core.Input }],
inputColor: [{ type: core.Input }],
inputFontColor: [{ type: core.Input }],
inputErrorColor: [{ type: core.Input }],
inputErrorFontColor: [{ type: core.Input }],
inputValidColor: [{ type: core.Input }],
inputValidFontColor: [{ type: core.Input }],
label: [{ type: core.Input }],
wrapperClasses: [{ type: core.Input }],
inputGroupLabelDirective: [{ type: core.ContentChild, args: [InputGroupLabelDirective, { static: true },] }],
inputGroupAddonLeftDirective: [{ type: core.ContentChild, args: [InputGroupAddonLeftDirective, { static: true },] }],
inputGroupAddonRightDirective: [{ type: core.ContentChild, args: [InputGroupAddonRightDirective, { static: true },] }],
inputGroupContentDirective: [{ type: core.ContentChild, args: [InputGroupContentDirective, { static: true },] }],
inputTextDirective: [{ type: core.ContentChild, args: [InputTextDirective, { static: true },] }]
};
return InputGroupComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
InputGroupComponent.prototype.subscriptions;
/** @type {?} */
InputGroupComponent.prototype.currentColor;
/** @type {?} */
InputGroupComponent.prototype.currentFontColor;
/** @type {?} */
InputGroupComponent.prototype.addonLeft;
/** @type {?} */
InputGroupComponent.prototype.addonRight;
/** @type {?} */
InputGroupComponent.prototype.inputColor;
/** @type {?} */
InputGroupComponent.prototype.inputFontColor;
/** @type {?} */
InputGroupComponent.prototype.inputErrorColor;
/** @type {?} */
InputGroupComponent.prototype.inputErrorFontColor;
/** @type {?} */
InputGroupComponent.prototype.inputValidColor;
/** @type {?} */
InputGroupComponent.prototype.inputValidFontColor;
/** @type {?} */
InputGroupComponent.prototype.label;
/** @type {?} */
InputGroupComponent.prototype.wrapperClasses;
/** @type {?} */
InputGroupComponent.prototype.inputGroupLabelDirective;
/** @type {?} */
InputGroupComponent.prototype.inputGroupAddonLeftDirective;
/** @type {?} */
InputGroupComponent.prototype.inputGroupAddonRightDirective;
/** @type {?} */
InputGroupComponent.prototype.inputGroupContentDirective;
/** @type {?} */
InputGroupComponent.prototype.inputTextDirective;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var InputGroupModule = /** @class */ (function () {
function InputGroupModule() {
}
InputGroupModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
ColorModule,
forms.FormsModule
],
exports: [InputGroupComponent, InputGroupLabelDirective, InputGroupAddonLeftDirective,
InputGroupAddonRightDirective, InputGroupContentDirective],
declarations: [InputGroupComponent, InputGroupLabelDirective, InputGroupAddonLeftDirective,
InputGroupAddonRightDirective, InputGroupContentDirective]
},] }
];
return InputGroupModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var InputTextModule = /** @class */ (function () {
function InputTextModule() {
}
InputTextModule.decorators = [
{ type: core.NgModule, args: [{
imports: [
common.CommonModule,
ColorModule,
forms.FormsModule
],
exports: [InputTextDirective],
declarations: [InputTextDirective]
},] }
];
return InputTextModule;
}());
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/*
*
*/
var TabToggleDirective = /** @class */ (function () {
/**
* @method constructor
* @param elementRef [description]
*/
function TabToggleDirective(elementRef) {
this.elementRef = elementRef;
}
TabToggleDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[mkTabToggle]'
},] }
];
/** @nocollapse */
TabToggleDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
TabToggleDirective.propDecorators = {
tabComponent: [{ type: core.Input, args: ['mkTabToggle',] }]
};
return TabToggleDirective;
}());
if (false) {
/** @type {?} */
TabToggleDirective.prototype.tabComponent;
/** @type {?} */
TabToggleDirective.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
// @TODO Vertical tabs
/*
*
*/
var TabHeaderComponent = /** @class */ (function () {
function TabHeaderComponent() {
}
TabHeaderComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-tab-header',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
TabHeaderComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return TabHeaderComponent;
}());
if (false) {
/** @type {?} */
TabHeaderComponent.prototype.templateRef;
}
/*
*
*/
var TabContentComponent = /** @class */ (function () {
function TabContentComponent() {
}
TabContentComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-tab-content',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
TabContentComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return TabContentComponent;
}());
if (false) {
/** @type {?} */
TabContentComponent.prototype.templateRef;
}
/*
*
*/
var TabComponent = /** @class */ (function () {
function TabComponent() {
this.isActive = false;
}
/**
* @method ngOnInit
*/
/**
* \@method ngOnInit
* @return {?}
*/
TabComponent.prototype.ngOnInit = /**
* \@method ngOnInit
* @return {?}
*/
function () {
if (this.tabContentComponent) {
this.contentTemplateRef = this.tabContentComponent.templateRef;
}
else {
this.contentTemplateRef = this.templateRef;
}
};
TabComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-tab',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
TabComponent.propDecorators = {
header: [{ type: core.Input }],
isDisabled: [{ type: core.Input }],
tabColor: [{ type: core.Input }],
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }],
tabHeaderComponent: [{ type: core.ContentChild, args: [TabHeaderComponent, { static: true },] }],
tabContentComponent: [{ type: core.ContentChild, args: [TabContentComponent, { static: true },] }]
};
return TabComponent;
}());
if (false) {
/** @type {?} */
TabComponent.prototype.index;
/** @type {?} */
TabComponent.prototype.isActive;
/**
* @type {?}
* @private
*/
TabComponent.prototype.contentTemplateRef;
/** @type {?} */
TabComponent.prototype.header;
/** @type {?} */
TabComponent.prototype.isDisabled;
/** @type {?} */
TabComponent.prototype.tabColor;
/** @type {?} */
TabComponent.prototype.templateRef;
/** @type {?} */
TabComponent.prototype.tabHeaderComponent;
/** @type {?} */
TabComponent.prototype.tabContentComponent;
}
/*
*
*/
var TabsHeaderComponent = /** @class */ (function () {
function TabsHeaderComponent() {
}
TabsHeaderComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-tabs-header',
template: '<ng-template #templateRef><ng-content></ng-content></ng-template>',
changeDetection: core.ChangeDetectionStrategy.OnPush
}] }
];
TabsHeaderComponent.propDecorators = {
templateRef: [{ type: core.ViewChild, args: ['templateRef', { static: true },] }]
};
return TabsHeaderComponent;
}());
if (false) {
/** @type {?} */
TabsHeaderComponent.prototype.templateRef;
}
/*
*
*/
var TabsComponent = /** @class */ (function () {
/**
* @method constructor
* @param changeDetectorRef [description]
* @param ngZone [description]
* @param renderer2 [description]
*/
function TabsComponent(changeDetectorRef, ngZone, renderer2) {
this.changeDetectorRef = changeDetectorRef;
this.ngZone = ngZone;
this.renderer2 = renderer2;
this.listeners = [];
this.subscriptions = [];
this.headerStyleClass = 'header pull-left';
this.navStyleClass = 'nav nav-tabs';
this.contentStyleClass = 'tab-content';
this.styleClass = 'nav-tabs-custom';
this.onClose = new core.EventEmitter();
this.onOpen = new core.EventEmitter();
}
Object.defineProperty(TabsComponent.prototype, "activeTabIndex", {
set: /**
* @param {?} index
* @return {?}
*/
function (index) {
this.activatedTabIndex = index;
this.changeDetectorRef.detectChanges();
},
enumerable: true,
configurable: true
});
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
TabsComponent.prototype.ngAfterContentInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
// Set tab index on load.
this.setTabIndex();
// Update tab index if tabs is updated.
this.subscriptions.push(this.tabs.changes.subscribe((/**
* @return {?}
*/
function () {
_this.setTabIndex();
})));
// Open tab on load.
this.openTabIndex();
};
/**
* @method ngAfterViewInit
*/
/**
* \@method ngAfterViewInit
* @return {?}
*/
TabsComponent.prototype.ngAfterViewInit = /**
* \@method ngAfterViewInit
* @return {?}
*/
function () {
var _this = this;
// Set tab toggles on load.
this.setTabsToggle();
// Update tab toggles if tabs is updated.
this.subscriptions.push(this.tabToggleDirectives.changes.subscribe((/**
* @return {?}
*/
function () {
_this.setTabsToggle();
})));
};
/**
* @method ngOnChanges
* @param changes [description]
*/
/**
* \@method ngOnChanges
* @param {?} changes [description]
* @return {?}
*/
TabsComponent.prototype.ngOnChanges = /**
* \@method ngOnChanges
* @param {?} changes [description]
* @return {?}
*/
function (changes) {
if (changes.activeTabIndex) {
this.openTabIndex();
}
};
/**
* @method ngOnDestroy
*/
/**
* \@method ngOnDestroy
* @return {?}
*/
TabsComponent.prototype.ngOnDestroy = /**
* \@method ngOnDestroy
* @return {?}
*/
function () {
removeListeners(this.listeners);
removeSubscriptions(this.subscriptions);
};
/**
* [toggleTab description]
* @method toggleTab
*/
/**
* [toggleTab description]
* \@method toggleTab
* @return {?}
*/
TabsComponent.prototype.openTabIndex = /**
* [toggleTab description]
* \@method toggleTab
* @return {?}
*/
function () {
var _this = this;
if (this.tabs) {
this.tabs.forEach((/**
* @param {?} tab
* @return {?}
*/
function (tab) {
if (_this.activatedTabIndex === tab.index || (_this.activatedTabIndex === undefined && tab.index === 0)) {
tab.isActive = true;
_this.onOpen.emit({ index: tab.index });
_this.changeDetectorRef.detectChanges();
}
else if (tab.isActive) {
tab.isActive = false;
_this.onClose.emit({ index: tab.index });
_this.changeDetectorRef.detectChanges();
}
}));
}
};
/**
* [openTab description]
* @method openTab
* @param event [description]
* @param tabToOpen [description]
*/
/**
* [openTab description]
* \@method openTab
* @param {?} event [description]
* @param {?} tabToOpen [description]
* @return {?}
*/
TabsComponent.prototype.openTab = /**
* [openTab description]
* \@method openTab
* @param {?} event [description]
* @param {?} tabToOpen [description]
* @return {?}
*/
function (event, tabToOpen) {
var _this = this;
event.preventDefault();
tabToOpen.isActive = true;
this.onOpen.emit({ event: event, index: tabToOpen.index });
this.tabs.forEach((/**
* @param {?} tab
* @return {?}
*/
function (tab) {
if (tab.isActive && tabToOpen !== tab) {
tab.isActive = false;
_this.onClose.emit({ event: event, index: tab.index });
}
}));
};
/**
* [setTabIndex description]
* @method setTabIndex
*/
/**
* [setTabIndex description]
* \@method setTabIndex
* @private
* @return {?}
*/
TabsComponent.prototype.setTabIndex = /**
* [setTabIndex description]
* \@method setTabIndex
* @private
* @return {?}
*/
function () {
this.tabs.forEach((/**
* @param {?} tab
* @param {?} index
* @return {?}
*/
function (tab, index) {
tab.index = index;
}));
this.changeDetectorRef.detectChanges();
};
/**
* [setTabsToggle description]
* @method setTabsToggle
*/
/**
* [setTabsToggle description]
* \@method setTabsToggle
* @private
* @return {?}
*/
TabsComponent.prototype.setTabsToggle = /**
* [setTabsToggle description]
* \@method setTabsToggle
* @private
* @return {?}
*/
function () {
var _this = this;
this.listeners = removeListeners(this.listeners);
this.ngZone.runOutsideAngular((/**
* @return {?}
*/
function () {
_this.tabToggleDirectives.forEach((/**
* @param {?} tabToggle
* @return {?}
*/
function (tabToggle) {
_this.listeners.push(_this.renderer2.listen(tabToggle.elementRef.nativeElement, 'click', (/**
* @param {?} event
* @return {?}
*/
function (event) {
_this.openTab(event, tabToggle.tabComponent);
_this.changeDetectorRef.detectChanges();
})));
}));
}));
};
TabsComponent.decorators = [
{ type: core.Component, args: [{
selector: 'mk-tabs',
template: "<div [ngClass]=\"styleClass\">\r\n <ul [ngClass]=\"navStyleClass\" [class.pull-right]=\"header || tabsHeaderComponent\">\r\n <li *ngFor=\"let tab of tabs\" [class.active]=\"tab.isActive\" [mkColor]=\"tab.tabColor || tabsColor\"\r\n mkColorProperty=\"border-top-color\">\r\n <a *ngIf=\"!tab.isDisabled\" [mkTabToggle]=\"tab\" href=\"#\">\r\n {{tab.header}}\r\n <ng-template *ngIf=\"!tab.header\" [ngTemplateOutlet]=\"tab.tabHeaderComponent?.templateRef\"></ng-template>\r\n </a>\r\n <ng-template [ngIf]=\"tab.isDisabled\">\r\n {{tab.header}}\r\n <ng-template *ngIf=\"!tab.header\" [ngTemplateOutlet]=\"tab.tabHeaderComponent.templateRef\"></ng-template>\r\n </ng-template>\r\n </li>\r\n <li *ngIf=\"tabsHeaderComponent || header\" [ngClass]=\"headerStyleClass\">\r\n {{header}}\r\n <ng-template *ngIf=\"!header\" [ngTemplateOutlet]=\"tabsHeaderComponent.templateRef\"></ng-template>\r\n </li>\r\n </ul>\r\n <div [ngClass]=\"contentStyleClass\">\r\n <div *ngFor=\"let tab of tabs\" class=\"tab-pane\" [class.active]=\"tab.isActive\">\r\n <ng-template [ngTemplateOutlet]=\"tab.contentTemplateRef\"></ng-template>\r\n </div>\r\n </div>\r\n</div>",
changeDetection: core.ChangeDetectionStrategy.OnPush,
styles: [".nav-tabs-custom>.nav-tabs>li{border-top-width:0}.nav-tabs-custom>.nav-tabs>li.active{border-top-width:3px}"]
}] }
];
/** @nocollapse */
TabsComponent.ctorParameters = function () { return [
{ type: core.ChangeDetectorRef },
{ type: core.NgZone },
{ type: core.Renderer2 }
]; };
TabsComponent.propDecorators = {
activeTabIndex: [{ type: core.Input }],
header: [{ type: core.Input }],
headerStyleClass: [{ type: core.Input }],
navStyleClass: [{ type: core.Input }],
contentStyleClass: [{ type: core.Input }],
styleClass: [{ type: core.Input }],
tabsColor: [{ type: core.Input }],
onClose: [{ type: core.Output }],
onOpen: [{ type: core.Output }],
tabsHeaderComponent: [{ type: core.ContentChild, args: [TabsHeaderComponent, { static: true },] }],
tabs: [{ type: core.ContentChildren, args: [TabComponent,] }],
tabToggleDirectives: [{ type: core.ViewChildren, args: [TabToggleDirective,] }]
};
return TabsComponent;
}());
if (false) {
/**
* @type {?}
* @private
*/
TabsComponent.prototype.activatedTabIndex;
/**
* @type {?}
* @private
*/
TabsComponent.prototype.listeners;
/**
* @type {?}
* @private
*/
TabsComponent.prototype.subscriptions;
/** @type {?} */
TabsComponent.prototype.header;
/** @type {?} */
TabsComponent.prototype.headerStyleClass;
/** @type {?} */
TabsComponent.prototype.navStyleClass;
/** @type {?} */
TabsComponent.prototype.contentStyleClass;
/** @type {?} */
TabsComponent.prototype.styleClass;
/** @type {?} */
TabsComponent.prototype.tabsColor;
/** @type {?} */
TabsComponent.prototype.onClose;
/** @type {?} */
TabsComponent.prototype.onOpen;
/** @type {?} */
TabsComponent.prototype.tabsHeaderComponent;
/** @type {?} */
TabsComponent.prototype.tabs;
/** @type {?} */
TabsComponent.prototype.tabToggleDirectives;
/**
* @type {?}
* @private
*/
TabsComponent.prototype.changeDetectorRef;
/**
* @type {?}
* @private
*/
TabsComponent.prototype.ngZone;
/**
* @type {?}
* @private
*/
TabsComponent.prototype.renderer2;
}
/**
* @fileoverview added by tsickle
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var TabsModule = /** @class */ (function () {
function TabsModule() {
}
TabsModule.decorators = [
{ type: core.NgModule, args: [{
imports: [common.CommonModule, ColorModule],
exports: [TabsComponent, TabsHeaderComponent, TabComponent, TabHeaderComponent, TabContentComponent],
declarations: [TabToggleDirective, TabsComponent, TabsHeaderComponent, TabComponent, TabHeaderComponent, TabContentComponent]
},] }
];
return TabsModule;
}());
exports.AccordionModule = AccordionModule;
exports.AlertModule = AlertModule;
exports.BoxInfoModule = BoxInfoModule;
exports.BoxModule = BoxModule;
exports.BoxSmallModule = BoxSmallModule;
exports.BreadcrumbsModule = BreadcrumbsModule;
exports.InputGroupModule = InputGroupModule;
exports.InputTextModule = InputTextModule;
exports.LayoutModule = LayoutModule;
exports.LayoutService = LayoutService;
exports.LayoutStore = LayoutStore;
exports.TabsModule = TabsModule;
exports.ɵa = ContentModule;
exports.ɵb = BreadcrumbsComponent;
exports.ɵba = layoutStoreFactory;
exports.ɵbb = layoutProvider;
exports.ɵbc = ColorModule;
exports.ɵbd = BackgroundColorDirective;
exports.ɵbe = ColorDirective;
exports.ɵbf = ColorService;
exports.ɵbg = AccordionHeaderComponent;
exports.ɵbh = AccordionContentComponent;
exports.ɵbi = AccordionComponent;
exports.ɵbj = AccordionGroupComponent;
exports.ɵbk = AccordionToggleDirective;
exports.ɵbl = AlertComponent;
exports.ɵbm = BoxComponent;
exports.ɵbn = BoxContentDirective;
exports.ɵbo = BoxFooterDirective;
exports.ɵbp = BoxToolsDirective;
exports.ɵbq = BoxHeaderDirective;
exports.ɵbr = BoxInfoComponent;
exports.ɵbs = BoxInfoContentDirective;
exports.ɵbt = BoxInfoFooterDirective;
exports.ɵbu = BoxInfoHeaderDirective;
exports.ɵbv = BoxSmallComponent;
exports.ɵbw = BoxSmallFooterDirective;
exports.ɵbx = BoxSmallHeaderDirective;
exports.ɵby = BoxSmallContentDirective;
exports.ɵbz = InputGroupComponent;
exports.ɵc = RoutingService;
exports.ɵca = InputGroupLabelDirective;
exports.ɵcb = InputGroupAddonLeftDirective;
exports.ɵcc = InputGroupAddonRightDirective;
exports.ɵcd = InputGroupContentDirective;
exports.ɵce = InputTextDirective;
exports.ɵcf = ClassService;
exports.ɵcg = TabHeaderComponent;
exports.ɵch = TabContentComponent;
exports.ɵci = TabComponent;
exports.ɵcj = TabsHeaderComponent;
exports.ɵck = TabsComponent;
exports.ɵcl = TabToggleDirective;
exports.ɵd = ContentComponent;
exports.ɵe = SidebarRightService;
exports.ɵf = HeaderService;
exports.ɵg = FooterService;
exports.ɵh = FooterModule;
exports.ɵi = FooterLeftComponent;
exports.ɵj = FooterRightComponent;
exports.ɵk = FooterComponent;
exports.ɵl = HeaderModule;
exports.ɵm = HeaderLogoComponent;
exports.ɵn = HeaderLogoMiniComponent;
exports.ɵo = HeaderComponent;
exports.ɵp = SidebarLeftModule;
exports.ɵq = AnimationsModule;
exports.ɵr = CollapseAnimationDirective;
exports.ɵs = SidebarLeftComponent;
exports.ɵt = SidebarLeftToggleDirective;
exports.ɵu = WrapperService;
exports.ɵv = SidebarRightModule;
exports.ɵw = SidebarRightComponent;
exports.ɵx = WrapperModule;
exports.ɵy = WrapperComponent;
exports.ɵz = LayoutConfigToken;
Object.defineProperty(exports, '__esModule', { value: true });
}));
//# sourceMappingURL=ad-custom-lib.umd.js.map