@neocomplexx/ngx-neo-directives-mat
Version:
1,497 lines • 70.2 kB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('rxjs'), require('rxjs/operators'), require('@angular/forms'), require('@angular/material/tabs')) :
typeof define === 'function' && define.amd ? define('@neocomplexx/ngx-neo-directives-mat', ['exports', '@angular/core', 'rxjs', 'rxjs/operators', '@angular/forms', '@angular/material/tabs'], factory) :
(global = global || self, factory((global.neocomplexx = global.neocomplexx || {}, global.neocomplexx['ngx-neo-directives-mat'] = {}), global.ng.core, global.rxjs, global.rxjs.operators, global.ng.forms, global.ng.material.tabs));
}(this, (function (exports, core, rxjs, operators, forms, tabs) { 'use strict';
/*! *****************************************************************************
Copyright (c) Microsoft Corporation.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */
/* 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) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(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 __createBinding(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}
function __exportStar(m, exports) {
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
}
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 };
}
function __classPrivateFieldGet(receiver, privateMap) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to get private field on non-instance");
}
return privateMap.get(receiver);
}
function __classPrivateFieldSet(receiver, privateMap, value) {
if (!privateMap.has(receiver)) {
throw new TypeError("attempted to set private field on non-instance");
}
privateMap.set(receiver, value);
return value;
}
var OnReturnDirective = /** @class */ (function () {
function OnReturnDirective(_el) {
this._el = _el;
this.setEnabled = true;
this.el = this._el;
}
OnReturnDirective_1 = OnReturnDirective;
OnReturnDirective.prototype.onKeyDown = function (e) {
if ((e.which === 13 || e.keyCode === 13)) {
e.preventDefault();
OnReturnDirective_1.setNextFocus(this.onReturn, this.setEnabled);
return;
}
};
// tslint:disable-next-line:member-ordering
OnReturnDirective.setNextFocus = function (onReturn, setEnabled) {
if (setEnabled === void 0) { setEnabled = true; }
if (onReturn instanceof Array) {
var termine = false;
var i = 0;
while (!termine && i < onReturn.length) {
var element = onReturn[i];
if (element) {
if (element instanceof HTMLInputElement ||
element instanceof HTMLButtonElement ||
element instanceof HTMLSelectElement ||
element instanceof HTMLSelectElement) {
if (!element.disabled) {
element.focus();
termine = true;
}
}
else {
if (element && element.nativeElement instanceof HTMLInputElement ||
element.nativeElement instanceof HTMLButtonElement ||
element.nativeElement instanceof HTMLSelectElement) {
if (!element.nativeElement.disabled) {
element.nativeElement.focus();
termine = true;
}
}
else {
var input = element['ctrInput'];
if (input) {
input = input['nativeElement'];
if (input && input instanceof HTMLInputElement) {
if (!input.disabled) {
input.focus();
termine = true;
}
}
}
else {
element = document.getElementById(element);
if (element) {
if (element.disabled && setEnabled) {
element.disabled = false;
}
if (!element.disabled) {
element.focus();
termine = true;
}
}
}
}
}
}
i++;
}
}
else if (onReturn) {
var element = onReturn;
if (element instanceof HTMLInputElement || element instanceof HTMLButtonElement || element instanceof HTMLSelectElement) {
if (element.disabled) {
element.disabled = false;
}
element.focus();
}
else {
var input = element['ctrInput'];
if (input) {
input = input['nativeElement'];
if (input && input instanceof HTMLInputElement) {
if (input.disabled) {
input.disabled = false;
}
input.focus();
}
}
else {
element = document.getElementById(onReturn);
if (element) {
if (element.disabled && setEnabled) {
element.disabled = false;
}
element.focus();
}
}
}
}
};
var OnReturnDirective_1;
OnReturnDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], OnReturnDirective.prototype, "onReturn", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], OnReturnDirective.prototype, "setEnabled", void 0);
__decorate([
core.HostListener('keydown', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [Object]),
__metadata("design:returntype", void 0)
], OnReturnDirective.prototype, "onKeyDown", null);
OnReturnDirective = OnReturnDirective_1 = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[onReturn]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], OnReturnDirective);
return OnReturnDirective;
}());
// tslint:disable:indent
var COMMAND_CONFIG = new core.InjectionToken('COMMAND_CONFIG');
var COMMAND_DEFAULT_CONFIG = {
executingCssClass: 'executing',
};
/*
export function provideConfig(config: CommandOptions): any {
return Object.assign({}, COMMAND_DEFAULT_CONFIG, config);
} */
/**
*
* ### Example with options
* ```html
* <button [command]='saveCmd' [commandOptions]='{executingCssClass: 'in-progress'}'>Save</button>
* ```
*/
var CommandDirective = /** @class */ (function () {
function CommandDirective(renderer, element) {
this.renderer = renderer;
this.element = element;
this.stopPropagation = false;
// @HostBinding('disabled') isDisabled: boolean;
this.setEnabled = true;
this.config = COMMAND_DEFAULT_CONFIG;
this.ownDisabledState = false;
this.commandDisabledChanged = false;
}
CommandDirective.prototype.ngOnInit = function () {
var _this = this;
// console.log('[commandDirective::init]');
this.commandOptions = Object.assign({}, this.config, this.commandOptions);
if (!this.command) {
throw new Error('[commandDirective] command should be defined!');
}
else {
this.command.verifyCommandExecutionPipe();
this.command.setNextFocus(this.commandNextFocus);
this.command.setEnabledValue(this.setEnabled);
}
// if (this.element.nativeElement.localName === 'button') {
// let thisAux = this; // Set up a new observer
// var observer = new MutationObserver(function(mutations) {
// mutations.forEach(function(mutation) {
// // Check the modified attributeName is "disabled"
// if(!thisAux.commandDisabledChanged) {
// if (mutation.attributeName === "disabled") {
// thisAux.ownDisabledState = thisAux.element.nativeElement.disabled;
// }
// } else {
// thisAux.commandDisabledChanged = false;
// }
// });
// });
// // Configure to only listen to attribute changes
// var config = { attributes: true };
// // Start observing myElem
// observer.observe(this.element.nativeElement, config);
// }
this.canExecute$$ = this.command.canExecute$.pipe(operators.tap(function (x) {
if (_this.element.nativeElement.localName === 'button') {
_this.commandDisabledChanged = true;
if (_this.commandValue == _this.command.executingParam) {
_this.element.nativeElement.disabled = !x;
// } else {
// this.element.nativeElement.disabled = !(!this.ownDisabledState && x);
}
}
})).subscribe();
this.isExecuting$$ = this.command.isExecuting$.pipe(operators.tap(function (x) {
// console.log('[commandDirective::isExecuting$]', x);
x ? _this.renderer.addClass(_this.element.nativeElement, _this.commandOptions.executingCssClass) : _this.renderer.removeClass(_this.element.nativeElement, _this.commandOptions.executingCssClass);
})).subscribe();
if (this.isMobileOperatingSystem()) {
this.element.nativeElement.addEventListener('touchstart', function (event) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
event.preventDefault();
event.stopPropagation();
if (this.element.nativeElement.localName === 'input') {
return [2 /*return*/];
}
this.executeCommand();
return [2 /*return*/];
});
}); });
this.element.nativeElement.addEventListener('focusin', function (event) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
event.preventDefault();
event.stopPropagation();
this.executeCommand();
return [2 /*return*/];
});
}); });
}
else {
this.element.nativeElement.addEventListener('keydown', function (event) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
if ((event.which === 13 || event.keyCode === 13)) {
event.preventDefault();
event.stopPropagation();
this.executeCommand();
}
return [2 /*return*/];
});
}); });
this.element.nativeElement.addEventListener('click', function (event) { return __awaiter(_this, void 0, void 0, function () {
return __generator(this, function (_a) {
if (this.element.nativeElement.localName === 'input') {
return [2 /*return*/];
}
event.preventDefault();
if (this.stopPropagation) {
event.stopPropagation();
}
this.executeCommand();
return [2 /*return*/];
});
}); });
}
};
CommandDirective.prototype.executeCommand = function () {
if (!this.element.nativeElement.disabled)
this.command.canExecute = true;
this.command.verifyCommandExecutionPipe();
this.command.execute(this.commandValue);
};
CommandDirective.prototype.ngOnDestroy = function () {
if (this.command) {
this.command.destroy();
}
if (this.canExecute$$) {
this.canExecute$$.unsubscribe();
}
if (this.isExecuting$$) {
this.isExecuting$$.unsubscribe();
}
};
CommandDirective.prototype.isMobileOperatingSystem = function () {
var isMobile = false;
var userAgent = navigator.userAgent || navigator.vendor;
// Windows Phone must come first because its UA also contains "Android"
if (/windows phone/i.test(userAgent)) {
isMobile = true; // "Windows Phone";
}
else if (/android/i.test(userAgent)) {
isMobile = true; // "Android";
}
else if (/iPad|iPhone|iPod/.test(userAgent)) {
// iOS detection from: http://stackoverflow.com/a/9039885/177710
isMobile = true; // "iOS";
}
isMobile = false;
return isMobile; // "unknown";
};
CommandDirective.ctorParameters = function () { return [
{ type: core.Renderer2 },
{ type: core.ElementRef }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "command", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "commandOptions", void 0);
__decorate([
core.Input(),
__metadata("design:type", Boolean)
], CommandDirective.prototype, "commandCanExecute", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "commandValue", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "commandNextFocus", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "stopPropagation", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], CommandDirective.prototype, "setEnabled", void 0);
CommandDirective = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[command]'
}),
__metadata("design:paramtypes", [core.Renderer2,
core.ElementRef])
], CommandDirective);
return CommandDirective;
}());
/**
* Command object used to encapsulate information which is needed to perform an action.
*/
var Command = /** @class */ (function () {
/**
* Creates an instance of Command.
*/
function Command(executeParam, canExecute$, isAsync, delay) {
var _this = this;
this.executeParam = executeParam;
this.isAsync = isAsync;
this.delay = delay;
this.isExecuting = false;
this.isExecuting$ = new rxjs.BehaviorSubject(false);
this.canExecute = true;
this.executionPipe$ = new rxjs.Subject();
this.setEnabled = true;
if (canExecute$) {
this.canExecute$ = rxjs.combineLatest(this.isExecuting$, canExecute$, function (isExecuting, canExecuteResult) {
// console.log('[command::combineLatest$] update!', { isExecuting, canExecuteResult });
_this.isExecuting = isExecuting;
_this.canExecute = !isExecuting && canExecuteResult;
return _this.canExecute;
});
this.canExecute$$ = this.canExecute$.subscribe();
}
else {
this.canExecute$ = this.isExecuting$.pipe(operators.map(function (x) {
var canExecute = !x;
_this.canExecute = canExecute;
return canExecute;
}));
this.isExecuting$$ = this.isExecuting$.pipe(operators.tap(function (x) { return _this.isExecuting = x; }))
.subscribe();
}
this.buildExecutionPipe(executeParam, isAsync, delay);
}
Command.prototype.verifyCommandExecutionPipe = function () {
if (this.executionPipe$.observers.length === 0) {
this.buildExecutionPipe(this.executeParam, this.isAsync, this.delay);
}
};
Command.prototype.execute = function (value) {
this.executingParam = value;
this.executionPipe$.next(value);
};
Command.prototype.executeWithResult = function (value) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
this.executingParam = value;
this.executionPipe$.next(value);
return [4 /*yield*/, this.result];
case 1: return [2 /*return*/, _a.sent()];
}
});
});
};
Command.prototype.destroy = function () {
if (this.executionPipe$$) {
this.executionPipe$$.unsubscribe();
}
if (this.canExecute$$) {
this.canExecute$$.unsubscribe();
}
if (this.isExecuting$$) {
this.isExecuting$$.unsubscribe();
}
if (this.isExecuting$) {
this.isExecuting$.complete();
}
if (this.asyncAction != null) {
this.asyncAction = null;
this.resultAsyncAction = null;
}
};
Command.prototype.buildExecutionPipe = function (executeParm, isAsync, delay) {
var _this = this;
var pipe$ = this.executionPipe$.pipe(operators.filter(function () { return _this.canExecute; }), operators.tap(function () {
_this.isExecuting$.next(true);
if (isAsync && _this.asyncAction != null) {
_this.resultAsyncAction = _this.asyncAction(undefined);
}
}));
pipe$ = isAsync
? pipe$.pipe(operators.switchMap(function (value) {
if (delay && delay > 0) {
if (_this.delaySubscribe) {
_this.delaySubscribe.unsubscribe();
}
var delayTimer = rxjs.timer(delay);
_this.delaySubscribe = delayTimer.subscribe(function (t) { executeParm(value); });
return Promise.resolve(null);
}
else {
var result = executeParm(value);
return Promise.resolve(result);
}
}))
: pipe$.pipe(operators.tap(function (value) { executeParm(value); }));
pipe$ = pipe$.pipe(operators.tap(function () {
// console.log('[command::excutionPipe$] do#2 - set idle');
_this.isExecuting$.next(false);
_this.executingParam = undefined;
if (isAsync && _this.asyncAction != null) {
_this.resultAsyncAction = _this.asyncAction(_this.resultAsyncAction);
}
OnReturnDirective.setNextFocus(_this.elementNextFocus, _this.setEnabled);
}, function (e) {
console.log('[command::excutionPipe$] do#2 error - set idle' + e.toString());
_this.isExecuting$.next(false);
_this.executingParam = undefined;
if (isAsync && _this.asyncAction != null) {
_this.resultAsyncAction = _this.asyncAction(_this.resultAsyncAction);
}
_this.buildExecutionPipe(executeParm, isAsync, delay);
}));
this.executionPipe$$ = pipe$.subscribe();
};
Command.prototype.setNextFocus = function (element) {
this.elementNextFocus = element;
};
Command.prototype.setEnabledValue = function (enabled) {
this.setEnabled = enabled;
};
return Command;
}());
var StringsDirective = /** @class */ (function () {
function StringsDirective(_el) {
this._el = _el;
this.el = this._el;
}
StringsDirective.prototype.onKeyDown = function (e) {
if (e.key === 'Delete' || e.key === 'Tab' || e.key === 'Backspace' || e.key === 'ArrowLeft' ||
e.altKey || e.ctrlKey || e.key === 'Home' || e.key === 'End' || e.key === 'PageDown' || e.key === 'PageUp' ||
e.key === 'ArrowRight' || e.key === 'Control' || e.key === 'Alt' || e.key === 'Shift') {
return;
}
var element = this._el.nativeElement.value;
if (element && element.length >= this.maxLength) {
e.preventDefault();
}
};
StringsDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], StringsDirective.prototype, "maxLength", void 0);
__decorate([
core.HostListener('keydown', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], StringsDirective.prototype, "onKeyDown", null);
StringsDirective = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[maxLength]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], StringsDirective);
return StringsDirective;
}());
var NeoNumbersDirective = /** @class */ (function () {
function NeoNumbersDirective(el, renderer, model) {
this.el = el;
this.renderer = renderer;
this.model = model;
this.allowNullValue = false;
}
NeoNumbersDirective.prototype.ngOnInit = function () {
if (this.allowNullValue === "")
this.allowNullValue = true;
this.regex = new RegExp('^\\d+$');
this.el.nativeElement.type = "number";
};
NeoNumbersDirective.prototype.blockPaste = function (e) {
var _this = this;
var clipboardData = e.clipboardData || window['clipboardData'];
var pastedData = clipboardData.getData('text/plain').split(",").join(".");
var posPoint = pastedData.lastIndexOf('.');
if (posPoint > -1) {
pastedData = pastedData.substring(0, posPoint).split(".").join("");
}
var onlyNumbers = Array.from(pastedData).map(function (x) { return _this.isOnlyNumber(x); }).reduce(function (prev, el) { return prev && el; }, true);
var isCorrect = this.regex.test(pastedData);
if (isCorrect && this.el.nativeElement.max && pastedData.length > this.el.nativeElement.max.length)
pastedData = pastedData.substr(0, this.el.nativeElement.max.length);
setTimeout(function () {
if (onlyNumbers && isCorrect) {
_this.el.nativeElement.value = pastedData;
}
else {
_this.el.nativeElement.value = '0';
}
}, 10);
};
NeoNumbersDirective.prototype.onfocus = function () {
if (this.el.nativeElement.value == "0") {
this.el.nativeElement.value = null;
}
};
NeoNumbersDirective.prototype.onBlur = function () {
var current = this.el.nativeElement.value;
if (current == "") {
if (this.allowNullValue) {
this.el.nativeElement.value = null;
this.model.control.setValue(null);
}
else {
this.el.nativeElement.value = "0";
this.model.control.setValue(0);
}
}
else {
this.el.nativeElement.type = "text";
this.el.nativeElement.type = "number";
if (this.el.nativeElement.max && this.el.nativeElement.valueAsNumber > +this.el.nativeElement.max) {
this.el.nativeElement.value = this.el.nativeElement.max;
this.model.control.setValue(this.el.nativeElement.valueAsNumber);
}
}
};
NeoNumbersDirective.prototype.onKeyUp = function (event) {
console.log(event);
var current = this.el.nativeElement.value;
current = current.split("-").join("");
var posPoint = current.indexOf('.');
if (posPoint > -1) {
current = current.substring(0, posPoint);
this.el.nativeElement.value = current;
}
if (this.isSpecial(event) || current == "") {
if (event.keyCode == 8 || current != "") {
this.prev = current;
}
return;
}
if (!this.isOnlyNumber(event)) {
event.preventDefault();
event.stopPropagation();
return false;
}
if (this.el.nativeElement.max && this.el.nativeElement.valueAsNumber > +this.el.nativeElement.max) {
this.el.nativeElement.value = current.substring(0, current.length - 1);
}
};
NeoNumbersDirective.prototype.onKeyDown = function (event) {
if (this.isSpecial(event)) {
return;
}
if (!this.isOnlyNumber(event)) {
event.preventDefault();
event.stopPropagation();
return false;
}
var current = this.el.nativeElement.value;
this.prev = current;
};
NeoNumbersDirective.prototype.isSpecial = function (e) {
return e.key === 'Delete' || (e.key === 'Tab' || e.keyCode == 9) || (e.key === 'Backspace' || e.keyCode == 8) || e.key === 'ArrowLeft' ||
e.altKey || e.ctrlKey || e.key === 'Home' || e.key === 'End' || e.key === 'PageDown' || e.key === 'PageUp' ||
e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'ArrowRight' || e.key === 'Control' || e.key === 'Alt' || e.key === 'Shift' ||
(e.keyIdentifier == 'Down' || e.keyIdentifier == 'Up' || e.keyIdentifier == 'Left' || e.keyIdentifier == 'Right');
};
NeoNumbersDirective.prototype.isOnlyNumber = function (e) {
if (e instanceof KeyboardEvent) {
return ((e.key >= '0' && e.key <= '9') || (e.keyCode >= 48 && e.keyCode <= 57) || (e.keyCode >= 96 && e.keyCode <= 105));
}
else {
return (e >= '0' && e <= '9');
}
};
NeoNumbersDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: forms.NgModel }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], NeoNumbersDirective.prototype, "isNumber", void 0);
__decorate([
core.Input('allowNullValue'),
__metadata("design:type", Object)
], NeoNumbersDirective.prototype, "allowNullValue", void 0);
__decorate([
core.HostListener('paste', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [ClipboardEvent]),
__metadata("design:returntype", void 0)
], NeoNumbersDirective.prototype, "blockPaste", null);
__decorate([
core.HostListener('focus'),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoNumbersDirective.prototype, "onfocus", null);
__decorate([
core.HostListener('blur'),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoNumbersDirective.prototype, "onBlur", null);
__decorate([
core.HostListener('keyup', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoNumbersDirective.prototype, "onKeyUp", null);
__decorate([
core.HostListener('keydown', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoNumbersDirective.prototype, "onKeyDown", null);
NeoNumbersDirective = __decorate([
core.Directive({
selector: '[isNumber]'
}),
__metadata("design:paramtypes", [core.ElementRef, core.Renderer2, forms.NgModel])
], NeoNumbersDirective);
return NeoNumbersDirective;
}());
var NeoAutofocusDirective = /** @class */ (function () {
function NeoAutofocusDirective(el) {
this.el = el;
}
NeoAutofocusDirective.prototype.ngOnInit = function () {
};
NeoAutofocusDirective.prototype.ngAfterViewInit = function () {
var _this = this;
this.subscription = rxjs.timer(100).subscribe(function () {
if (_this.neoAutofocus) {
_this.setFocus();
}
_this.subscription.unsubscribe();
});
};
NeoAutofocusDirective.prototype.setFocus = function () {
if (this.el) {
if (this.el instanceof HTMLInputElement ||
this.el instanceof HTMLButtonElement ||
this.el instanceof HTMLSelectElement ||
this.el instanceof HTMLSelectElement) {
if (!this.el.disabled) {
this.el.focus();
}
}
else {
if (this.el && this.el.nativeElement instanceof HTMLInputElement ||
this.el.nativeElement instanceof HTMLButtonElement ||
this.el.nativeElement instanceof HTMLSelectElement) {
if (!this.el.nativeElement.disabled) {
this.el.nativeElement.focus();
}
}
else {
var input = this.el['ctrInput'];
if (input) {
input = input['nativeElement'];
if (input && input instanceof HTMLInputElement) {
if (!input.disabled) {
input.focus();
}
}
}
}
}
}
};
NeoAutofocusDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input('neoAutofocus'),
__metadata("design:type", Boolean)
], NeoAutofocusDirective.prototype, "neoAutofocus", void 0);
NeoAutofocusDirective = __decorate([
core.Directive({
selector: '[neoAutofocus]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], NeoAutofocusDirective);
return NeoAutofocusDirective;
}());
var NeoChangeCommandDirective = /** @class */ (function () {
function NeoChangeCommandDirective(element) {
this.element = element;
}
NeoChangeCommandDirective.prototype.onInputChange = function (event) {
var value = this.element.nativeElement.value;
if (!this._lastValue || this._lastValue !== value) {
this._lastValue = value;
this.changeCommand.execute(value);
}
};
NeoChangeCommandDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], NeoChangeCommandDirective.prototype, "changeCommand", void 0);
__decorate([
core.HostListener('keyup', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoChangeCommandDirective.prototype, "onInputChange", null);
NeoChangeCommandDirective = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[changeCommand]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], NeoChangeCommandDirective);
return NeoChangeCommandDirective;
}());
var NeoDecimalNumbersDirective = /** @class */ (function () {
function NeoDecimalNumbersDirective(el, renderer, model) {
this.el = el;
this.renderer = renderer;
this.model = model;
this.allowNullValue = false;
this.decimals = 2;
this.haveDecimalPoint = false;
}
NeoDecimalNumbersDirective.prototype.ngOnInit = function () {
var _a, _b;
if (this.options && !this.options.apply) {
return;
}
this.decimals = (_b = (_a = this.options) === null || _a === void 0 ? void 0 : _a.decimals) !== null && _b !== void 0 ? _b : 2;
if (this.decimals == "")
this.decimals = 2;
if (this.allowNullValue === "")
this.allowNullValue = true;
this.el.nativeElement.type = "number";
this.regex = new RegExp('^[0-9]+(\\.[0-9]{0,' + this.decimals + '})?$');
};
NeoDecimalNumbersDirective.prototype.blockPaste = function (e) {
var _this = this;
if (this.options && !this.options.apply) {
return;
}
var clipboardData = e.clipboardData || window['clipboardData'];
var pastedData = clipboardData.getData('text/plain').split(",").join(".");
var posPoint = pastedData.lastIndexOf('.');
if (posPoint > -1) {
pastedData = pastedData.substring(0, posPoint).split(".").join("") + pastedData.substring(posPoint);
posPoint = pastedData.lastIndexOf('.');
if (posPoint + this.decimals < pastedData.length) {
pastedData = pastedData.substring(0, posPoint + this.decimals + 1);
}
}
var onlyNumbers = Array.from(pastedData).map(function (x) { return _this.isNumber(x); }).reduce(function (prev, el) { return prev && el; }, true);
var a = this.regex.test(pastedData);
setTimeout(function () {
if (onlyNumbers && a) {
_this.el.nativeElement.value = pastedData;
}
else {
_this.el.nativeElement.value = '0';
}
}, 10);
};
NeoDecimalNumbersDirective.prototype.onfocus = function () {
if (this.options && !this.options.apply) {
return;
}
if (this.el.nativeElement.value == "0") {
this.el.nativeElement.value = null;
}
};
NeoDecimalNumbersDirective.prototype.onBlur = function () {
if (this.options && !this.options.apply) {
return;
}
var current = this.el.nativeElement.value;
if (current == "") {
if (this.allowNullValue) {
this.el.nativeElement.value = null;
this.model.control.setValue(null);
}
else {
this.el.nativeElement.value = "0";
this.model.control.setValue(0);
}
}
else {
this.el.nativeElement.type = "text";
this.el.nativeElement.type = "number";
if (this.el.nativeElement.max && this.el.nativeElement.valueAsNumber > +this.el.nativeElement.max) {
this.el.nativeElement.value = this.el.nativeElement.max;
this.model.control.setValue(this.el.nativeElement.valueAsNumber);
}
}
};
NeoDecimalNumbersDirective.prototype.onKeyUp = function (event) {
if (this.options && !this.options.apply) {
return;
}
var current = this.el.nativeElement.value;
current = current.split("-").join("");
var posPoint = current.indexOf('.');
if (posPoint > -1) {
this.el.nativeElement.value = current.substring(0, posPoint + 1) + current.substring(posPoint).split(".").join("");
}
if (this.haveDecimalPoint && current == "" && this.prev > "") {
this.haveDecimalPoint = false;
this.el.nativeElement.value = this.prev + (this.prev.endsWith(".0") ? "" : ".0");
this.el.nativeElement.type = "text";
this.el.nativeElement.selectionStart = this.el.nativeElement.value.length - 1;
this.el.nativeElement.selectionEnd = this.el.nativeElement.value.length;
this.el.nativeElement.type = "number";
return;
}
if (this.isSpecial(event) || current == "") {
if (event.keyCode == 8 || current != "") {
this.prev = current;
var dotIndex = current.toString().indexOf('.');
if (dotIndex >= 0)
this.haveDecimalPoint = false;
}
return;
}
if (!this.isNumber(event)) {
event.preventDefault();
event.stopPropagation();
return false;
}
if (current) {
current = current.toString();
var dotIndex = current.indexOf('.');
if ((dotIndex >= 0) && ((current.length - 1) - dotIndex > this.decimals)) {
this.renderer.setProperty(this.el.nativeElement, 'value', current.slice(0, dotIndex + this.decimals + 1));
}
}
else {
this.renderer.setProperty(this.el.nativeElement, 'value', this.prev);
}
};
NeoDecimalNumbersDirective.prototype.onKeyDown = function (event) {
if (this.options && !this.options.apply) {
return;
}
if (this.isSpecial(event)) {
return;
}
if (!this.isNumber(event)) {
event.preventDefault();
event.stopPropagation();
return false;
}
var current = this.el.nativeElement.value;
if (this.isDecimalPoint(event)) {
this.haveDecimalPoint = true;
if (!current.endsWith(".0")) {
this.el.nativeElement.value = current + ".0";
this.el.nativeElement.type = "text";
this.el.nativeElement.selectionStart = this.el.nativeElement.value.length - 1;
this.el.nativeElement.selectionEnd = this.el.nativeElement.value.length;
this.el.nativeElement.type = "number";
}
}
this.prev = current;
};
NeoDecimalNumbersDirective.prototype.isSpecial = function (e) {
return e.key === 'Delete' || (e.key === 'Tab' || e.keyCode == 9) || (e.key === 'Backspace' || e.keyCode == 8) || e.key === 'ArrowLeft' ||
e.altKey || e.ctrlKey || e.key === 'Home' || e.key === 'End' || e.key === 'PageDown' || e.key === 'PageUp' ||
e.key === 'ArrowDown' || e.key === 'ArrowUp' || e.key === 'ArrowRight' || e.key === 'Control' || e.key === 'Alt' || e.key === 'Shift' ||
(e.keyIdentifier == 'Down' || e.keyIdentifier == 'Up');
};
NeoDecimalNumbersDirective.prototype.isNumber = function (e) {
if (e instanceof KeyboardEvent) {
return ((e.key >= '0' && e.key <= '9') || ((e.keyCode >= 48 && e.keyCode <= 57) || (e.keyCode >= 96 && e.keyCode <= 105)) ||
(e.key === '.' || e.key === ',') || (e.keyCode === 188 || e.keyCode === 190 || e.keyCode === 229));
}
else {
return ((e >= '0' && e <= '9') || (e === '.' || e === ','));
}
};
NeoDecimalNumbersDirective.prototype.isDecimalPoint = function (e) {
return (e.key === '.' || e.key === ',') || (e.keyCode === 188 || e.keyCode === 190 || e.keyCode === 229);
};
NeoDecimalNumbersDirective.ctorParameters = function () { return [
{ type: core.ElementRef },
{ type: core.Renderer2 },
{ type: forms.NgModel }
]; };
__decorate([
core.Input('isDecimal'),
__metadata("design:type", Object)
], NeoDecimalNumbersDirective.prototype, "options", void 0);
__decorate([
core.Input('allowNullValue'),
__metadata("design:type", Object)
], NeoDecimalNumbersDirective.prototype, "allowNullValue", void 0);
__decorate([
core.HostListener('paste', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [ClipboardEvent]),
__metadata("design:returntype", void 0)
], NeoDecimalNumbersDirective.prototype, "blockPaste", null);
__decorate([
core.HostListener('focus'),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoDecimalNumbersDirective.prototype, "onfocus", null);
__decorate([
core.HostListener('blur'),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoDecimalNumbersDirective.prototype, "onBlur", null);
__decorate([
core.HostListener('keyup', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoDecimalNumbersDirective.prototype, "onKeyUp", null);
__decorate([
core.HostListener('keydown', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoDecimalNumbersDirective.prototype, "onKeyDown", null);
NeoDecimalNumbersDirective = __decorate([
core.Directive({
selector: '[isDecimal]'
}),
__metadata("design:paramtypes", [core.ElementRef, core.Renderer2, forms.NgModel])
], NeoDecimalNumbersDirective);
return NeoDecimalNumbersDirective;
}());
/**
* Boolean function that check if the keyboard event is not a normal key but a command like key
* Will return boolean if the key is Alt, Shift , Control, Delete, Tab, Backspace, Arrows, Home, End, PageUp and PageDown.
*
* @export
* @param e
*/
function isCommandKey(e) {
return e.key === 'Delete' || e.key === 'Tab' || e.key === 'Backspace' || e.key === 'ArrowLeft' || e.key === 'Left' ||
e.altKey || e.ctrlKey || e.key === 'Home' || e.key === 'End' || e.key === 'PageDown' || e.key === 'PageUp' ||
e.key === 'ArrowRight' || e.key === 'Right' || e.key === 'Control' || e.key === 'Alt' || e.key === 'Shift';
}
var NeoCompositeInputDirective = /** @class */ (function () {
function NeoCompositeInputDirective(el) {
this.el = el;
// Next input to move from the current input
this.previousInput = null;
// Previous input to move from the current input
this.nextInput = null;
}
NeoCompositeInputDirective.prototype.onKeyDown = function (e) {
// If the element is selected and the user presses backspace we must clear the input
if (e.key === 'Backspace' && this.elementIsSelected()) {
return true;
}
// We must move to the previous input if the user presses backspace and he is in the first position of the input
// or if he presses the left key
if (((e.key === 'Backspace') && (this.el.nativeElement.selectionStart === 0) || ((e.key === 'ArrowLeft') || (e.key === 'Left')))) {
if ((this.previousInput) && (this.previousInput instanceof HTMLInputElement) && (!this.previousInput.disabled)) {
this.previousInput.focus();
return false;
}
}
// If he presses the right arrow it must move to the next input
if (e.key === 'ArrowRight' || e.key === 'Right') {
if ((this.nextInput) && (this.nextInput instanceof HTMLInputElement) && (!this.nextInput.disabled)) {
this.nextInput.focus();
return false;
}
}
};
/**
*
* Method called on keyup to check if the pressed key is allow, if it is not it stops the event.
* If the element reached its maximum length on key pressed it must jump to the next input
* @param e
*/
NeoCompositeInputDirective.prototype.onKeyUp = function (e) {
if (isCommandKey(e)) {
return;
}
var value = this.el.nativeElement.value;
if (this.nextInput && (value.length >= this.el.nativeElement.maxLength)) {
this.nextInput.focus();
}
};
/**
* On focus we select the entire value of the input
*/
NeoCompositeInputDirective.prototype.onFocus = function () {
this.el.nativeElement.select();
};
/**
* Method to check if the element is selected
*
*/
NeoCompositeInputDirective.prototype.elementIsSelected = function () {
return this.el.nativeElement.selectionStart === 0 && this.el.nativeElement.selectionEnd !== 0;
};
NeoCompositeInputDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input(),
__metadata("design:type", Object)
], NeoCompositeInputDirective.prototype, "previousInput", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], NeoCompositeInputDirective.prototype, "nextInput", void 0);
__decorate([
core.HostListener('keydown', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoCompositeInputDirective.prototype, "onKeyDown", null);
__decorate([
core.HostListener('keyup', ['$event']),
__metadata("design:type", Function),
__metadata("design:paramtypes", [KeyboardEvent]),
__metadata("design:returntype", void 0)
], NeoCompositeInputDirective.prototype, "onKeyUp", null);
__decorate([
core.HostListener('focus', []),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoCompositeInputDirective.prototype, "onFocus", null);
NeoCompositeInputDirective = __decorate([
core.Directive({
selector: '[compositeInput]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], NeoCompositeInputDirective);
return NeoCompositeInputDirective;
}());
var NeoMatchHeightDirective = /** @class */ (function () {
function NeoMatchHeightDirective(el) {
this.el = el;
}
NeoMatchHeightDirective.prototype.onResize = function () {
this.matchHeight(this.el.nativeElement, this.matchHeightClassName);
};
NeoMatchHeightDirective.prototype.ngAfterViewChecked = function () {
this.matchHeight(this.el.nativeElement, this.matchHeightClassName);
};
NeoMatchHeightDirective.prototype.matchHeight = function (parent, className) {
if (!parent) {
return;
}
// step 1: find all the child elements with the selected class name
var children = parent.getElementsByClassName(className);
if (!children) {
return;
}
// step 1b: reset all children height
Array.from(children).forEach(function (x) {
x.style.height = 'initial';
});
// step 2a: get all the child elements heights
var itemHeights = Array.from(children)
.map(function (x) { return x.getBoundingClientRect().height; });
// step 2b: find out the tallest
var maxHeight = itemHeights.reduce(function (prev, curr) {
return curr > prev ? curr : prev;
}, 0);
// step 3: update all the child elements to the tallest height
Array.from(children)
.forEach(function (x) { return x.style.height = maxHeight + "px"; });
};
NeoMatchHeightDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
__decorate([
core.Input('neoMatchHeight'),
__metadata("design:type", String)
], NeoMatchHeightDirective.prototype, "matchHeightClassName", void 0);
__decorate([
core.HostListener('window:resize'),
__metadata("design:type", Function),
__metadata("design:paramtypes", []),
__metadata("design:returntype", void 0)
], NeoMatchHeightDirective.prototype, "onResize", null);
NeoMatchHeightDirective = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[neoMatchHeight]'
}),
__metadata("design:paramtypes", [core.ElementRef])
], NeoMatchHeightDirective);
return NeoMatchHeightDirective;
}());
/**
* @author slarrieu
*/
var NgbTabSetDirective = /** @class */ (function () {
function NgbTabSetDirective(_el) {
this._el = _el;
this.el = this._el;
this.onTabChanging = false;
}
NgbTabSetDirective.prototype.ngOnInit = function () {
// this.el._handleClick = this.interceptTabChange.bind(this);
var _this = this;
if (this.tabSelectedId) {
this.tabSelectedIdSubscribe = this.tabSelectedId.subscribe(function (tabSelectedId) {
if (tabSelectedId > -1) {
// const previousValue = this.tabSelectedId.value;
if (_this.el.selectedIndex !== tabSelectedId) {
_this.el.selectedIndex = tabSelectedId;
}
}
});
}
};
/* interceptTabChange(tab: MatTab, tabHeader: MatTabHeader, idx: number) {
if (this.onTabChanging) {
return true;
}
this.onTabChanging = true;
let canChange = true;
if (this.tabChangeController) {
canChange = await this.tabChangeController.canChangeTab();
}
this.onTabChanging = false;
return canChange && MatTabGroup.prototype._handleClick.apply(this.el, arguments);
} */
NgbTabSetDirective.prototype.ngOnDestroy = function () {
if (this.tabSelectedIdSubscribe) {
this.tabSelectedIdSubscribe.unsubscribe();
}
};
NgbTabSetDirective.prototype.cambiarTab = function ($event, force) {
if (force === void 0) { force = false; }
var tabSelecting = $event.nextId;
if (force || this.tabSelectedId.value !== tabSelecting) {
this.tabSelectedId.next(tabSelecting);
}
};
NgbTabSetDirective.ctorParameters = function () { return [
{ type: tabs.MatTabGroup }
]; };
__decorate([
core.Input(),
__metadata("design:type", rxjs.BehaviorSubject)
], NgbTabSetDirective.prototype, "tabSelectedId", void 0);
__decorate([
core.Input(),
__metadata("design:type", Object)
], NgbTabSetDirective.prototype, "tabChangeController", void 0);
NgbTabSetDirective = __decorate([
core.Directive({
// tslint:disable-next-line:directive-selector
selector: '[tabSelectedId], [tabChangeController]',
}),
__metadata("design:paramtypes", [tabs.MatTabGroup])
], NgbTabSetDirective);
return NgbTabSetDirective;
}());
var NgxNeoDirectivesModule = /** @class */ (function () {
function NgxNeoDirectivesModule() {
}
NgxNeoDirectivesModule_1 = NgxNeoDirectivesModule;
NgxNeoDirectivesModule.forRoot = function (options) {
if (options === void 0) { options = { executingCssClass: 'executing' }; }
return {
ngModule: NgxNeoDirectivesModule_1,
providers: [
{ provide: COMMAND_CONFIG, useValue: options },
]
};
};
var NgxNeoDirectivesModule_1;
NgxNeoDirectivesModule = NgxNeoDirectivesModule_1 = __decorate([
core.NgModule({
imports: [],
declarations: [
CommandDirective,
OnReturnDirective,
StringsDirective,
NeoNumbersDirective,
NeoAutofocusDirective,
NeoChangeCommandDirective,
NeoDecimalNumbersDirective,
NeoCompositeInputDirective,
NeoMatchHeightDirective,
NgbTabSetDirective
],
exports: [
CommandDirective,
OnReturnDirective,
StringsDirective,
NeoNumbersDirective,
NeoAutofocusDirective,
NeoChangeCommandDirective,
NeoDecimalNumbersDirective,
NeoCompositeInputDirective,
NeoMatchHeightDirective,
NgbTabSetDirective
]
})
], NgxNeoDirectivesModule);
return NgxNeoDirectivesModule;
}());
exports.COMMAND_CONFIG = COMMAND_CONFIG;
exports.COMMAND_DEFAULT_CONFIG = COMMAND_DEFAULT_CONFIG;
exports.Command = Command;
exports.CommandDirective = CommandDirective;
exports.NeoAutofocusDirective = NeoAutofocusDirective;
exports.NeoChangeCommandDirective = NeoChangeCommandDirective;
exports.NeoCompositeInputDirective = NeoCompositeInputDirective;
exports.NeoDecimalNumbersDirective = NeoDecimalNumbersDirective;
exports.NeoMatchHeightDirective = NeoMatchHeightDirective;
exports.NeoNumbersDirective = NeoNumbersDirective;
exports.NgxNeoDirectivesModule = NgxNeoDirectivesModule;
exports.OnReturnDirective = OnReturnDirective;
exports.StringsDirective = StringsDirective;
exports.isCommandKey = isCommandKey;
exports.ɵa = NeoCompositeInputDirective;
exports.ɵb = NgbTabSetDirective;
Object.defineProperty(exports, '__esModule', { value: true });
})));
//# sourceMappingURL=neocomplexx-ngx-neo-directives-mat.umd.js.map