@uex/web-extensions
Version:
Uex extensions for Angular 6+ web projects
1,319 lines (1,289 loc) • 1.77 MB
JavaScript
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('lodash'), require('@angular/common'), require('@angular/common/http'), require('@angular/animations'), require('css-element-queries'), require('rxjs/operators'), require('@angular/forms'), require('moment'), require('text-mask-addons/dist/createNumberMask.js'), require('text-mask-core/dist/textMaskCore'), require('ngx-color-picker'), require('ngx-pipes'), require('angular2-text-mask'), require('@angular/platform-browser'), require('@angular/cdk/coercion'), require('@angular/cdk/platform'), require('@angular/platform-browser/animations'), require('popper.js'), require('cropperjs'), require('quill'), require('@angular/router'), require('ngx-device-detector'), require('@uex/ngx-qrscanner')) :
typeof define === 'function' && define.amd ? define('@uex/web-extensions', ['exports', '@angular/core', 'lodash', '@angular/common', '@angular/common/http', '@angular/animations', 'css-element-queries', 'rxjs/operators', '@angular/forms', 'moment', 'text-mask-addons/dist/createNumberMask.js', 'text-mask-core/dist/textMaskCore', 'ngx-color-picker', 'ngx-pipes', 'angular2-text-mask', '@angular/platform-browser', '@angular/cdk/coercion', '@angular/cdk/platform', '@angular/platform-browser/animations', 'popper.js', 'cropperjs', 'quill', '@angular/router', 'ngx-device-detector', '@uex/ngx-qrscanner'], factory) :
(global = global || self, factory((global.uex = global.uex || {}, global.uex['web-extensions'] = {}), global.ng.core, global._, global.ng.common, global.ng.common.http, global.ng.animations, global.cssElementQueries, global.rxjs.operators, global.ng.forms, global.moment, global.createNumberMask, global.textMaskCore, global.ngxColorPicker, global.ngxPipes, global.angular2TextMask, global.ng.platformBrowser, global.ng.cdk.coercion, global.ng.cdk.platform, global.ng.platformBrowser.animations, global.PopperJS, global.Cropper, global.Quill, global.ng.router, global.ngxDeviceDetector, global.ngxQrscanner));
}(this, (function (exports, core, lodash, common, http, animations, cssElementQueries, operators, forms, _moment, createNumberMask, textMaskCore, ngxColorPicker, ngxPipes, angular2TextMask, platformBrowser, coercion, platform, animations$1, PopperJS, Cropper, Quill, router, ngxDeviceDetector, ngxQrscanner) { 'use strict';
createNumberMask = createNumberMask && createNumberMask.hasOwnProperty('default') ? createNumberMask['default'] : createNumberMask;
PopperJS = PopperJS && PopperJS.hasOwnProperty('default') ? PopperJS['default'] : PopperJS;
Cropper = Cropper && Cropper.hasOwnProperty('default') ? Cropper['default'] : Cropper;
Quill = Quill && Quill.hasOwnProperty('default') ? Quill['default'] : Quill;
/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.
See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */
/* global Reflect, Promise */
var extendStatics = function(d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return extendStatics(d, b);
};
function __extends(d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
}
var __assign = function() {
__assign = Object.assign || function __assign(t) {
for (var s, i = 1, n = arguments.length; i < n; i++) {
s = arguments[i];
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
}
return t;
};
return __assign.apply(this, arguments);
};
function __rest(s, e) {
var t = {};
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
t[p] = s[p];
if (s != null && typeof Object.getOwnPropertySymbols === "function")
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
t[p[i]] = s[p[i]];
}
return t;
}
function __decorate(decorators, target, key, desc) {
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
}
function __param(paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
}
function __metadata(metadataKey, metadataValue) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
}
function __awaiter(thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
}
function __generator(thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (_) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
}
function __exportStar(m, exports) {
for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
}
function __values(o) {
var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
if (m) return m.call(o);
return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
}
function __read(o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
}
function __spread() {
for (var ar = [], i = 0; i < arguments.length; i++)
ar = ar.concat(__read(arguments[i]));
return ar;
}
function __spreadArrays() {
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
for (var r = Array(s), k = 0, i = 0; i < il; i++)
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
r[k] = a[j];
return r;
};
function __await(v) {
return this instanceof __await ? (this.v = v, this) : new __await(v);
}
function __asyncGenerator(thisArg, _arguments, generator) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var g = generator.apply(thisArg, _arguments || []), i, q = [];
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
function fulfill(value) { resume("next", value); }
function reject(value) { resume("throw", value); }
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
}
function __asyncDelegator(o) {
var i, p;
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
}
function __asyncValues(o) {
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
var m = o[Symbol.asyncIterator], i;
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
}
function __makeTemplateObject(cooked, raw) {
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
return cooked;
};
function __importStar(mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
result.default = mod;
return result;
}
function __importDefault(mod) {
return (mod && mod.__esModule) ? mod : { default: mod };
}
/**
* @fileoverview added by tsickle
* Generated from: lib/modules/button/button.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {number} */
var ButtonTheme = {
MATERIAL: 1,
BOOTSTRAP: 2,
};
ButtonTheme[ButtonTheme.MATERIAL] = 'MATERIAL';
ButtonTheme[ButtonTheme.BOOTSTRAP] = 'BOOTSTRAP';
/**
* @fileoverview added by tsickle
* Generated from: lib/modules/template/template.enum.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/** @enum {number} */
var TemplateTheme = {
DEFAULT: 1,
DARK: 2,
LIGHT: 3,
BLUE: 4,
};
TemplateTheme[TemplateTheme.DEFAULT] = 'DEFAULT';
TemplateTheme[TemplateTheme.DARK] = 'DARK';
TemplateTheme[TemplateTheme.LIGHT] = 'LIGHT';
TemplateTheme[TemplateTheme.BLUE] = 'BLUE';
/** @enum {number} */
var TemplateSize = {
RESPONSIVE: 1,
SMALL: 2,
MEDIUM: 3,
};
TemplateSize[TemplateSize.RESPONSIVE] = 'RESPONSIVE';
TemplateSize[TemplateSize.SMALL] = 'SMALL';
TemplateSize[TemplateSize.MEDIUM] = 'MEDIUM';
/**
* @fileoverview added by tsickle
* Generated from: lib/config.service.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
var AppConfig = /** @class */ (function () {
function AppConfig() {
}
return AppConfig;
}());
if (false) {
/** @type {?} */
AppConfig.prototype.button;
/** @type {?} */
AppConfig.prototype.layout;
/** @type {?} */
AppConfig.prototype.template;
}
var ConfigService = /** @class */ (function () {
function ConfigService(config) {
this.config = config;
this.DEFAULT_BUTTON_CONFIG = {
theme: ButtonTheme.MATERIAL
};
this.DEFAULT_LAYOUT_CONFIG = {
relative: false,
color: {
primary: "#F0F0F0"
}
};
this.DEFAULT_TEMPLATE_CONFIG = {
theme: TemplateTheme.DEFAULT,
header: true,
layout: {
header: true,
sidebar: true
},
background: {
color: "#CCCCCC"
}
};
this._setDefautValues();
}
Object.defineProperty(ConfigService.prototype, "button", {
get: /**
* @return {?}
*/
function () {
return this.config && this.config.button ? this.config.button : {};
},
enumerable: true,
configurable: true
});
Object.defineProperty(ConfigService.prototype, "layout", {
get: /**
* @return {?}
*/
function () {
return this.config && this.config.layout ? this.config.layout : {};
},
enumerable: true,
configurable: true
});
Object.defineProperty(ConfigService.prototype, "template", {
get: /**
* @return {?}
*/
function () {
return this.config && this.config.template ? this.config.template : {};
},
enumerable: true,
configurable: true
});
/**
* @private
* @return {?}
*/
ConfigService.prototype._setDefautValues = /**
* @private
* @return {?}
*/
function () {
var _this = this;
if (!this.button.theme) {
this.config.button = this.DEFAULT_BUTTON_CONFIG;
}
if (!this.layout.color) {
this.config.layout = this.DEFAULT_LAYOUT_CONFIG;
}
lodash.forEach(this.template, (/**
* @param {?} config
* @param {?} type
* @return {?}
*/
function (config, type) {
/** @type {?} */
var default_config = _this.DEFAULT_TEMPLATE_CONFIG;
if (config &&
config.background &&
(config.background.image || config.background.color)) {
delete default_config.background.color;
}
_this.config.template[type] = lodash.merge({}, default_config, config);
}));
};
ConfigService.decorators = [
{ type: core.Injectable }
];
/** @nocollapse */
ConfigService.ctorParameters = function () { return [
{ type: AppConfig, decorators: [{ type: core.Optional }] }
]; };
return ConfigService;
}());
if (false) {
/**
* @type {?}
* @private
*/
ConfigService.prototype.DEFAULT_BUTTON_CONFIG;
/**
* @type {?}
* @private
*/
ConfigService.prototype.DEFAULT_LAYOUT_CONFIG;
/**
* @type {?}
* @private
*/
ConfigService.prototype.DEFAULT_TEMPLATE_CONFIG;
/**
* @type {?}
* @private
*/
ConfigService.prototype.config;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/modules/button/directives/ripple.directive.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Adiciona o efeito "ripple" ao clicar em um elemento
* @abstract
*/
var RippleDirectiveBase = /** @class */ (function () {
function RippleDirectiveBase(elementRef) {
this.elementRef = elementRef;
/**
* @ignore
*/
this._no_ripple = false;
this._default_ripple_opacity = '0.15';
}
Object.defineProperty(RippleDirectiveBase.prototype, "set_no_ripple", {
set: /**
* @private
* @param {?} no_ripple
* @return {?}
*/
function (no_ripple) {
this.no_ripple = lodash.isString(no_ripple) && no_ripple == '' ? true : (lodash.isBoolean(no_ripple) ? ((/** @type {?} */ (no_ripple))) : true);
},
enumerable: true,
configurable: true
});
Object.defineProperty(RippleDirectiveBase.prototype, "no_ripple", {
get: /**
* @return {?}
*/
function () {
return this._no_ripple;
},
set: /**
* @param {?} value
* @return {?}
*/
function (value) {
this._no_ripple = value;
},
enumerable: true,
configurable: true
});
/**
* @param {?} e
* @return {?}
*/
RippleDirectiveBase.prototype._onClick = /**
* @param {?} e
* @return {?}
*/
function (e) {
if (this.no_ripple) {
return;
}
/** @type {?} */
var targetEl = this.elementRef ? this.elementRef.nativeElement : null;
if (!targetEl) {
return;
}
if (this._animate_timeout) {
clearTimeout(this._animate_timeout);
}
/** @type {?} */
var rippleEl = ((/** @type {?} */ (targetEl.querySelector('.ripple'))));
if (!!rippleEl) {
rippleEl.classList.remove('animate');
}
else {
rippleEl = document.createElement('span');
rippleEl.classList.add('ripple');
targetEl.appendChild(rippleEl);
}
/** @type {?} */
var offset_x = e.offsetX;
/** @type {?} */
var offset_y = e.offsetY;
if (e.target != targetEl) {
/** @type {?} */
var relative_offset = this._relativeOffset((/** @type {?} */ (e.target)), targetEl);
offset_x += relative_offset.left;
offset_y += relative_offset.top;
}
rippleEl.style.width = rippleEl.style.height = Math.max(targetEl.offsetWidth, targetEl.offsetHeight) + 'px';
rippleEl.style.left = (offset_x - rippleEl.offsetWidth / 2) + 'px';
rippleEl.style.top = (offset_y - rippleEl.offsetHeight / 2) + 'px';
// Apply element color and background color to wrapper
/** @type {?} */
var element_style = window.getComputedStyle(targetEl, null);
/** @type {?} */
var color = element_style.color;
/** @type {?} */
var background_contrast_color = this._contrast(this._contrast(color));
rippleEl.style.color = color;
rippleEl.style.background = background_contrast_color;
rippleEl.classList.add('animate');
this._animate_timeout = setTimeout((/**
* @return {?}
*/
function () { return rippleEl.classList.remove('animate'); }), 650);
};
/**
* @private
* @param {?} color
* @param {?=} bw
* @return {?}
*/
RippleDirectiveBase.prototype._contrast = /**
* @private
* @param {?} color
* @param {?=} bw
* @return {?}
*/
function (color, bw) {
if (bw === void 0) { bw = true; }
/** @type {?} */
var colorHex = this._toHexadecimal(color);
if (!/(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i.test(colorHex)) {
return '#FFFFFF';
}
if (colorHex.length === 4) {
colorHex = colorHex.replace(/^#(.)(.)(.)/i, '#$1$1$2$2$3$3');
}
/** @type {?} */
var r = parseInt(colorHex.substr(1, 2), 16);
/** @type {?} */
var g = parseInt(colorHex.substr(3, 2), 16);
/** @type {?} */
var b = parseInt(colorHex.substr(5, 2), 16);
if (bw) {
// https://github.com/lffg/yiq/blob/master/index.js
/** @type {?} */
var yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
return this._toRGBA(yiq >= 128 ? '#000000' : '#FFFFFF');
}
return this._toRGBA("#" + this._padZero(r) + this._padZero(g) + this._padZero(b));
};
/**
* @private
* @param {?} color
* @param {?=} allow_alpha
* @return {?}
*/
RippleDirectiveBase.prototype._toHexadecimal = /**
* @private
* @param {?} color
* @param {?=} allow_alpha
* @return {?}
*/
function (color, allow_alpha) {
if (allow_alpha === void 0) { allow_alpha = false; }
if (!color || (color && color.indexOf('(') == -1)) {
return color;
}
/** @type {?} */
var parts = color.replace(/(rgba|rgb)/g, '').replace(/[\(\)]/g, '').split(',').map((/**
* @param {?} part
* @return {?}
*/
function (part) { return lodash.trim(part); }));
/** @type {?} */
var r = this._padZero(parseInt(parts[0], 10).toString(16));
/** @type {?} */
var g = this._padZero(parseInt(parts[1], 10).toString(16));
/** @type {?} */
var b = this._padZero(parseInt(parts[2], 10).toString(16));
if (parts[3] && allow_alpha) {
/** @type {?} */
var a = parseFloat(parseFloat(parts[3].substring(0, parts[3].length - 1)).toFixed(2));
return "#" + r + g + b + this._padZero((a * 255).toString(16).substring(0, 2));
}
return "#" + r + g + b;
};
/**
* @private
* @param {?} color
* @param {?=} opacity
* @return {?}
*/
RippleDirectiveBase.prototype._toRGBA = /**
* @private
* @param {?} color
* @param {?=} opacity
* @return {?}
*/
function (color, opacity) {
if (opacity === void 0) { opacity = this._default_ripple_opacity; }
/** @type {?} */
var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(color);
return result ? "rgba(" + parseInt(result[1], 16) + ", " + parseInt(result[2], 16) + ", " + parseInt(result[3], 16) + ", " + opacity + ")" : color;
};
/**
* @private
* @param {?} str
* @param {?=} len
* @return {?}
*/
RippleDirectiveBase.prototype._padZero = /**
* @private
* @param {?} str
* @param {?=} len
* @return {?}
*/
function (str, len) {
if (len === void 0) { len = 2; }
if (lodash.isNumber(str)) {
str = str.toString();
}
/** @type {?} */
var zeros = new Array(len).join('0');
return (zeros + str).slice(-len);
};
/**
* @private
* @param {?} child_element
* @param {?} parent_element
* @return {?}
*/
RippleDirectiveBase.prototype._relativeOffset = /**
* @private
* @param {?} child_element
* @param {?} parent_element
* @return {?}
*/
function (child_element, parent_element) {
/** @type {?} */
var offset_parent_element = ((/** @type {?} */ (child_element.offsetParent)));
/** @type {?} */
var parent_rect = offset_parent_element.getBoundingClientRect();
/** @type {?} */
var child_rect = child_element.getBoundingClientRect();
/** @type {?} */
var offset = {
top: child_rect.top - parent_rect.top,
left: child_rect.left - parent_rect.left
}
// Reached top of document
;
// Reached top of document
if (offset_parent_element.tagName === 'BODY') {
return offset;
}
// Parent element contains the 'top' element we want the offset to be relative to
if (child_element.parentElement === parent_element) {
return offset;
}
// Reached the 'top' element we want the offset to be relative to
if (offset_parent_element === parent_element) {
return offset;
}
// Get parent's relative offset
/** @type {?} */
var parent_offset = this._relativeOffset(offset_parent_element, parent_element);
offset.top += parent_offset.top;
offset.left += parent_offset.left;
return offset;
};
RippleDirectiveBase.propDecorators = {
set_no_ripple: [{ type: core.Input, args: ['no-ripple',] }],
_onClick: [{ type: core.HostListener, args: ['mousedown', ['$event'],] }]
};
return RippleDirectiveBase;
}());
if (false) {
/**
* @ignore
* @type {?}
* @protected
*/
RippleDirectiveBase.prototype._no_ripple;
/**
* @type {?}
* @private
*/
RippleDirectiveBase.prototype._default_ripple_opacity;
/**
* @type {?}
* @private
*/
RippleDirectiveBase.prototype._animate_timeout;
/** @type {?} */
RippleDirectiveBase.prototype.elementRef;
}
var RippleDirective = /** @class */ (function (_super) {
__extends(RippleDirective, _super);
function RippleDirective(elementRef) {
var _this = _super.call(this, elementRef) || this;
_this.elementRef = elementRef;
return _this;
}
RippleDirective.decorators = [
{ type: core.Directive, args: [{
selector: '[with-ripple], .with-ripple'
},] }
];
/** @nocollapse */
RippleDirective.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
return RippleDirective;
}(RippleDirectiveBase));
if (false) {
/** @type {?} */
RippleDirective.prototype.elementRef;
}
/**
* @fileoverview added by tsickle
* Generated from: lib/modules/button/button.component.ts
* @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
*/
/**
* Define estilos de botões para elementos. Por razões de acessibilidade, os botões usam um elemento button padrão.
*
* É uma abstração para os [botões do Bootstrap 4]{\@link https://getbootstrap.com/docs/4.1/components/buttons}, com algumas melhorias e estilos personalizados.
*
* Demo: {\@link https://gituex.gitlab.io/extensions/web-extensions#components/button}
*/
var ButtonComponent = /** @class */ (function (_super) {
__extends(ButtonComponent, _super);
/**
* @ignore
*/
function ButtonComponent(elementRef) {
var _this = _super.call(this, elementRef) || this;
_this.elementRef = elementRef;
/**
* Define o atributo "title" de layout que será aplicado ao botão
*/
_this.type = 'button';
_this._color = 'primary';
_this._mode = 'raised';
_this._size = 'default';
_this._rounded = false;
_this._block = false;
_this._icon_only = false;
_this._icon_right = false;
_this._icon_left = false;
_this._classes = [];
_this.is_button = false;
return _this;
}
Object.defineProperty(ButtonComponent.prototype, "_setMode", {
/**
* Define o modo de layout que será aplicado ao botão
*/
set: /**
* Define o modo de layout que será aplicado ao botão
* @private
* @param {?} mode
* @return {?}
*/
function (mode) {
this._mode = mode;
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setColor", {
/**
* Define a cor que será aplicada ao botão
*/
set: /**
* Define a cor que será aplicada ao botão
* @private
* @param {?} color
* @return {?}
*/
function (color) {
this._color = color;
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setSize", {
/**
* Define o tamanho que será aplicado ao botão
*/
set: /**
* Define o tamanho que será aplicado ao botão
* @private
* @param {?} size
* @return {?}
*/
function (size) {
this._size = size;
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setRounded", {
/**
* Define se será aplicada borda arredondada ao botão
*/
set: /**
* Define se será aplicada borda arredondada ao botão
* @private
* @param {?} rounded
* @return {?}
*/
function (rounded) {
this._rounded = this._getAttribute(rounded, true);
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setBlock", {
/**
* Define se será aplicada largura "100%" arredondada ao botão
*/
set: /**
* Define se será aplicada largura "100%" arredondada ao botão
* @private
* @param {?} block
* @return {?}
*/
function (block) {
this._block = this._getAttribute(block, true);
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setIconOnly", {
/**
* Define se o botão deverá se ajustar para receber apenas um icone
*/
set: /**
* Define se o botão deverá se ajustar para receber apenas um icone
* @private
* @param {?} icon_only
* @return {?}
*/
function (icon_only) {
this._icon_only = this._getAttribute(icon_only, true);
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setIconRight", {
/**
* Define se o botão deverá se ajustar para receber um icone a direita
*/
set: /**
* Define se o botão deverá se ajustar para receber um icone a direita
* @private
* @param {?} icon_right
* @return {?}
*/
function (icon_right) {
this._icon_right = this._getAttribute(icon_right, true);
this._updateClasses();
},
enumerable: true,
configurable: true
});
Object.defineProperty(ButtonComponent.prototype, "_setIconLeft", {
/**
* Define se o botão deverá se ajustar para receber um icone a esquerda
*/
set: /**
* Define se o botão deverá se ajustar para receber um icone a esquerda
* @private
* @param {?} icon_left
* @return {?}
*/
function (icon_left) {
this._icon_left = this._getAttribute(icon_left, true);
this._updateClasses();
},
enumerable: true,
configurable: true
});
/**
* @return {?}
*/
ButtonComponent.prototype.ngOnInit = /**
* @return {?}
*/
function () {
this.is_button = this.elementRef.nativeElement.tagName == 'BUTTON';
this._updateClasses();
};
Object.defineProperty(ButtonComponent.prototype, "offsetTop", {
/**
* Distância do elemento para o topo do elemento pai mais próximo posicionado com relative
*/
get: /**
* Distância do elemento para o topo do elemento pai mais próximo posicionado com relative
* @return {?}
*/
function () {
return this.elementRef.nativeElement.offsetTop;
},
enumerable: true,
configurable: true
});
/**
* Dispara o gatilho de focus do botão
*
* @param [has_delay=false] - Adiciona um delay de 300ms para disparar o gatilho depois
*/
/**
* Dispara o gatilho de focus do botão
*
* @param {?=} has_delay
* @return {?}
*/
ButtonComponent.prototype.focus = /**
* Dispara o gatilho de focus do botão
*
* @param {?=} has_delay
* @return {?}
*/
function (has_delay) {
var _this = this;
if (has_delay === void 0) { has_delay = false; }
if (has_delay) {
setTimeout((/**
* @return {?}
*/
function () { return _this._doFocus(); }), 300);
}
else {
this._doFocus();
}
};
/**
* @internal
*/
/**
* \@internal
* @return {?}
*/
ButtonComponent.prototype.hasRipple = /**
* \@internal
* @return {?}
*/
function () {
return !this.no_ripple && !this._isOutline();
};
/**
* @internal
*/
/**
* \@internal
* @return {?}
*/
ButtonComponent.prototype.isDarkRipple = /**
* \@internal
* @return {?}
*/
function () {
return this.hasRipple() && this._isClear();
};
// Modes
// Modes
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isFab =
// Modes
/**
* @private
* @return {?}
*/
function () {
return this._mode == 'fab';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isFabFlat = /**
* @private
* @return {?}
*/
function () {
return this._mode == 'fab-flat';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isClear = /**
* @private
* @return {?}
*/
function () {
return this._mode == 'clear';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isIcon = /**
* @private
* @return {?}
*/
function () {
return this._mode == 'icon';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isOutline = /**
* @private
* @return {?}
*/
function () {
return this._mode == 'outline';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isRaised = /**
* @private
* @return {?}
*/
function () {
return this._mode == 'raised';
};
// Sizes
// Sizes
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isXSmall =
// Sizes
/**
* @private
* @return {?}
*/
function () {
return this._size == 'micro' || this._size == 'xsmall' || this._size == 'xs';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isSmall = /**
* @private
* @return {?}
*/
function () {
return this._size == 'mini' || this._size == 'small' || this._size == 'sm';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isLarge = /**
* @private
* @return {?}
*/
function () {
return this._size == 'large' || this._size == 'lg';
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isXLarge = /**
* @private
* @return {?}
*/
function () {
return this._size == 'xlarge' || this._size == 'xl';
};
// Miscellaneous
// Miscellaneous
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isRounded =
// Miscellaneous
/**
* @private
* @return {?}
*/
function () {
return this._rounded && !this._isIcon() && !this._isFab() && !this._isFabFlat();
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isBlock = /**
* @private
* @return {?}
*/
function () {
return this._block && !this._isIcon() && !this._isFab() && !this._isFabFlat();
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isIconOnly = /**
* @private
* @return {?}
*/
function () {
return this._icon_only && !this._isIcon() && !this._isFab() && !this._isFabFlat();
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isIconRight = /**
* @private
* @return {?}
*/
function () {
return this._icon_right && !this._isIcon() && !this._isFab() && !this._isFabFlat();
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._isIconLeft = /**
* @private
* @return {?}
*/
function () {
return this._icon_left && !this._isIcon() && !this._isFab() && !this._isFabFlat();
};
// Colors
// Colors
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._updateClasses =
// Colors
/**
* @private
* @return {?}
*/
function () {
this._clearClasses();
this._classes.push('btn');
if (this._isFab()) {
this._classes.push('btn-fab');
}
if (this._isFabFlat()) {
this._classes.push('btn-fab-flat');
}
if (this._isClear()) {
this._classes.push('btn-clear');
}
if (this._isIcon()) {
this._classes.push('btn-icon');
}
if (this._isOutline()) {
this._classes.push('btn-outline');
}
if (this._isRaised()) {
this._classes.push('btn-raised');
}
if (this._isRounded()) {
this._classes.push('btn-rounded');
}
if (this._isBlock()) {
this._classes.push('btn-block');
}
if (this._isIconOnly()) {
this._classes.push('btn-icon-only');
}
if (this._isIconRight()) {
this._classes.push('btn-icon-right');
}
if (this._isIconLeft()) {
this._classes.push('btn-icon-left');
}
if (this._isXSmall()) {
this._classes.push('btn-xs');
}
if (this._isSmall()) {
this._classes.push('btn-sm');
}
if (this._isLarge()) {
this._classes.push('btn-lg');
}
if (this._isXLarge()) {
this._classes.push('btn-xl');
}
if (this._color == 'link') {
this._classes.push("btn-" + this._color);
}
else {
this._classes.push("btn-" + (this._isOutline() ? 'outline-' : '') + (this._color || 'default'));
}
this._setClasses();
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._clearClasses = /**
* @private
* @return {?}
*/
function () {
if (this._classes) {
/** @type {?} */
var current_classes_1 = this.elementRef.nativeElement.className.split(' ');
this._classes.forEach((/**
* @param {?} _class
* @return {?}
*/
function (_class) {
/** @type {?} */
var index = current_classes_1.indexOf(_class);
if (index > -1) {
current_classes_1.splice(index, 1);
}
}));
this._classes = [];
this.elementRef.nativeElement.className = current_classes_1.join(' ');
}
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._setClasses = /**
* @private
* @return {?}
*/
function () {
/** @type {?} */
var current_classes = this.elementRef.nativeElement.className.split(' ').filter((/**
* @param {?} i
* @return {?}
*/
function (i) { return !!i; }));
this.elementRef.nativeElement.className = lodash.concat(current_classes, this._classes).join(' ');
};
/**
* @private
* @return {?}
*/
ButtonComponent.prototype._doFocus = /**
* @private
* @return {?}
*/
function () {
this.elementRef.nativeElement.focus();
};
/**
* @private
* @template T
* @param {?} value
* @param {?=} boolean
* @return {?}
*/
ButtonComponent.prototype._getAttribute = /**
* @private
* @template T
* @param {?} value
* @param {?=} boolean
* @return {?}
*/
function (value, boolean) {
if (boolean === void 0) { boolean = false; }
if (boolean) {
return (lodash.isString(value) && value !== 'false') || (lodash.isBoolean(value) && !!value);
}
return !!value ? value : null;
};
ButtonComponent.decorators = [
{ type: core.Component, args: [{
selector: '[uex-button]',
template: "<ng-content></ng-content>\r\n",
host: {
'class': 'uex-button',
'[attr.type]': 'is_button ? type : null',
'[class.with-ripple]': 'hasRipple()',
'[class.ripple-dark]': 'isDarkRipple()'
}
}] }
];
/** @nocollapse */
ButtonComponent.ctorParameters = function () { return [
{ type: core.ElementRef }
]; };
ButtonComponent.propDecorators = {
type: [{ type: core.Input, args: ['type',] }],
_setMode: [{ type: core.Input, args: ['mode',] }],
_setColor: [{ type: core.Input, args: ['color',] }],
_setSize: [{ type: core.Input, args: ['size',] }],
_setRounded: [{ type: core.Input, args: ['rounded',] }],
_setBlock: [{ type: core.Input, args: ['block',] }],
_setIconOnly: [{ type: core.Input, args: ['icon-only',] }],
_setIconRight: [{ type: core.Input, args: ['icon-right',] }],
_setIconLeft: [{ type: core.Input, args: ['icon-left',] }]
};
return ButtonComponent;
}(RippleDirective));
if (false) {
/**
* Define o atributo "title" de layout que será aplicado ao botão
* @type {?}
*/
ButtonComponent.prototype.type;
/**
* @type {?}
* @private
*/
ButtonComponent.prototype._color;
/**
* @type {?}
* @private
*/
ButtonComponent.prototype._mode;
/**
* @type {?}
* @private
*/
ButtonComponent.prototype