├── .babelrc
├── .editorconfig
├── .gitignore
├── .npmignore
├── .travis.yml
├── LICENSE.md
├── README.md
├── dist
    ├── vue-convenia-util.common.js
    └── vue-convenia-util.es.js
├── jest.config.js
├── package.json
├── src
    ├── helpers
    │   ├── date.js
    │   ├── formatters.js
    │   ├── functional.js
    │   ├── get.js
    │   ├── index.js
    │   ├── string.js
    │   └── validators.js
    ├── index.js
    └── mixins
    │   ├── Alignable.js
    │   ├── Loadable.js
    │   ├── MediaQuery.js
    │   ├── ObservableFix.js
    │   ├── Shadowed.js
    │   └── index.js
├── test
    ├── formatters.spec.js
    ├── index.spec.js
    └── validators.spec.js
└── yarn.lock


/.babelrc:
--------------------------------------------------------------------------------
 1 | {
 2 |   "env": {
 3 |     "test": {
 4 |       "presets": ["@babel/preset-env"],
 5 |       "plugins": [
 6 |         "@babel/plugin-syntax-dynamic-import",
 7 |         "@babel/plugin-transform-modules-commonjs"
 8 |       ]
 9 |     }
10 |   }
11 | }


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | # Configurações gerais
 4 | [*]
 5 |   charset = utf-8
 6 |   end_of_line = lf
 7 |   insert_final_newline = true
 8 |   trim_trailing_whitespace = true
 9 | 
10 | # Configurações dos arquivos JavaScript & Vue
11 | [*.{js,json,vue}]
12 |   indent_size = 2
13 |   indent_style = space
14 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Dependências do Node.js
2 | node_modules
3 | 
4 | dist
5 | 


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | # Arquivos de teste
2 | test
3 | 
4 | # Arquivos de configuração do projeto
5 | .editorconfig
6 | .npmignore
7 | 


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 |   - "6"
4 | 
5 | before_install:
6 |   - export TZ=America/Sao_Paulo
7 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Convenia
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Vue Convenia Util
 2 | 
 3 | [![Build Status][badge-0]][link-0]
 4 | [![JavaScript Style Guide][badge-1]][link-1]
 5 | 
 6 | Plugin com validações, formatações e filtros para projetos Vue. Validação e
 7 | formatação de CPF, CNPJ, datas, dinheiro (R$) etc.
 8 | 
 9 | ## Instalação
10 | 
11 | Instale a dependência publicada no NPM.
12 | 
13 | ```shell
14 | yarn add vue-convenia-util
15 | ```
16 | 
17 | ### Instalação global
18 | 
19 | Adiciona todas as funcionalidades descritas no objeto de configuração ao
20 | protótipo do Vue e consequentemente aos componentes.
21 | 
22 | ```js
23 | import Vue from 'vue'
24 | import Util from 'vue-convenia-util'
25 | 
26 | Vue.use(Util, {
27 |   formatters: true,
28 |   formatFilters: true
29 | })
30 | 
31 | new Vue({
32 |   ...
33 | ```
34 | 
35 | ```vue
36 | <template>
37 |   <strong>CPF: {{ user.document | toCPF }}</strong>
38 |   <strong>{{ cash }}</strong>
39 | </template>
40 | 
41 | <script>
42 |   export default {
43 |     data: () => ({ user: { ... } })
44 |     computed: {
45 |       cash() {
46 |         return this.$format.toMoney(this.user.cash)
47 |       }
48 |     }
49 | ```
50 | 
51 | ### Integração com o [`vee-validate`](https://github.com/baianat/vee-validate)
52 | 
53 | O Util disponibiliza a função `integrate` que serve basicamente para o integrar
54 | em outras libs. Com o vee-validade, e por enquanto só com ele mesmo, basta usar
55 | essa função.
56 | 
57 | ```js
58 | import Util from 'vue-convenia-util'
59 | import VeeValidate, { Validator } from 'vee-validate'
60 | 
61 | // Util.integrate(nome da lib, objeto de integração, opções opcionais)
62 | 
63 | Util.integrate('vee-validate', Validator, {
64 |   isEmail: {        // Por padrão apenas o isEmail é a única função que não é
65 |     name: 'email',  // injetada no Validator e essa é a forma de faze-lo.
66 |     getMessage: () => 'Email inválido.'
67 |   }
68 | })
69 | ```
70 | 
71 | <!-- Badges -->
72 | [badge-0]: https://travis-ci.org/convenia/vue-convenia-util.svg?branch=master
73 | [badge-1]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
74 | 
75 | <!-- Links -->
76 | [link-0]: https://travis-ci.org/convenia/vue-convenia-util
77 | [link-1]: https://standardjs.com
78 | 


--------------------------------------------------------------------------------
/dist/vue-convenia-util.common.js:
--------------------------------------------------------------------------------
   1 | 'use strict';
   2 | 
   3 | Object.defineProperty(exports, '__esModule', { value: true });
   4 | 
   5 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
   6 | 
   7 | var dayjs = _interopDefault(require('dayjs-ext'));
   8 | var customParseFormat = _interopDefault(require('dayjs-ext/plugin/customParseFormat'));
   9 | require('dayjs-ext/locale/pt-br');
  10 | var normalize = require('normalize-text');
  11 | var normalize__default = _interopDefault(normalize);
  12 | 
  13 | /**
  14 |  * Obtém o formato da data ou null se não for possível identificar.
  15 |  * @example ```
  16 |  * ('2000-21-12') => ['YYYY-DD-MM', 'YYYY-MM-DD HH:mm:ss']
  17 |  * ('21-12-2000') => ['DD-MM-YYYY', 'DD-MM-YYYY HH:mm:ss']
  18 |  * ('21/12/2000 23:59:18') => ['DD/MM/YYYY', 'DD/MM/YYYY HH:mm:ss']
  19 |  * ('2000/12/21') => null
  20 |  * ```
  21 |  * @param {String} date
  22 |  * @returns {String}
  23 |  */
  24 | var getDateFormat = function (date) {
  25 |   var isValid = is(date, 'String') && date.trim().length >= 10;
  26 |   var format = !isValid ? null
  27 |     : /^\d{4}-\d{2}-\d{2}$/.test(date) ? 'YYYY-MM-DD'
  28 |     : /^\d{2}-\d{2}-\d{4}$/.test(date) ? 'DD-MM-YYYY'
  29 |     : /^\d{2}\/\d{2}\/\d{4}$/.test(date) ? 'DD/MM/YYYY'
  30 |     : null;
  31 | 
  32 |   return format
  33 | };
  34 | 
  35 | /**
  36 |  * Receives a date in US string format or unix timestamp and returns
  37 |  * it in brazillian format.
  38 |  *
  39 |  * @param {String|Number} value - The date to be formatted.
  40 |  * @returns {String} - the formmated date.
  41 |  *
  42 |  */
  43 | var formatDateBR = function (value) {
  44 |   if (!value) { return '' }
  45 | 
  46 |   var date = typeof value === 'string'
  47 |     ? new Date((value + "T00:00:00"))
  48 |     : new Date(value);
  49 | 
  50 |   return date.toLocaleDateString('pt-BR')
  51 | };
  52 | 
  53 | 
  54 | /**
  55 |  * Receives a date in BR string format and returns its US equivalent
  56 |  *
  57 |  * @param {String} value - The date to be formatted.
  58 |  * @returns {String} - the formmated date.
  59 |  *
  60 |  */
  61 | var formatDateUS = function (date) {
  62 |   if (!date) { return '' }
  63 | 
  64 |   return date.substr(0, 10).split('/').reverse().join('-')
  65 | };
  66 | 
  67 | 
  68 | /**
  69 |  * Calculates a person's age given a birthday.
  70 |  *
  71 |  * @param {Date} birthday - A Date instance representing the birthday.
  72 |  * @returns {Number} - The person's age.
  73 |  *
  74 |  */
  75 | var calculateAge = function (birthday) {
  76 |   var ageDifMs = Date.now() - birthday.getTime();
  77 |   var ageDate = new Date(ageDifMs);
  78 | 
  79 |   return Math.abs(ageDate.getUTCFullYear() - 1970);
  80 | };
  81 | 
  82 | /**
  83 |  * Obtém o construtor do valor.
  84 |  * @param {*} value
  85 |  * @returns {String}
  86 |  */
  87 | var getConstructor = function (value) {
  88 |   var string = Object.prototype.toString.call(value);
  89 |   var ref = /\[object (.*?)\]/.exec(string);
  90 |   var constructor = ref[1];
  91 |   return constructor
  92 | };
  93 | 
  94 | /**
  95 |  * Usando um valor inicial, encadeia uma função e retorna seu resultado.
  96 |  * @param {A} initial
  97 |  * @param {function(A):function} callback
  98 |  * @param {Array.<*>} params
  99 |  * @returns {B}
 100 |  * @template A, B
 101 |  */
 102 | var chain = function (initial, callback, params) {
 103 |   var value = params.reduce(function (value, args) {
 104 |     return callback(value).apply(value, [].concat( args ))
 105 |   }, initial);
 106 | 
 107 |   return value
 108 | };
 109 | 
 110 | var DELIMITER = '.';
 111 | 
 112 | /**
 113 |  * Spreads path into fields list.
 114 |  * @param {string} path
 115 |  * @returns {Array.<string>}
 116 |  */
 117 | var getProperties = function (path) { return is(path, 'String') ? path.split(DELIMITER) : []; };
 118 | 
 119 | /**
 120 |  * Deep object.
 121 |  * @typedef {Object.<string, (number|boolean|string|Deep)>} Deep
 122 |  */
 123 | 
 124 | /**
 125 |  * Checks if a propety is reachable.
 126 |  * @param {Deep} object
 127 |  * @param {string} property
 128 |  * @returns {(number|boolean|string|null)}
 129 |  */
 130 | var getValue = function (object, property) {
 131 |   var isReachable = is(object, 'Object') && object.hasOwnProperty(property);
 132 |   var value = isReachable ? object[property] : null;
 133 |   return value
 134 | };
 135 | 
 136 | /**
 137 |  * Get value from object path.
 138 |  * @param {Deep} object
 139 |  * @param {(string|Array.<string>)} path
 140 |  * @returns {(number|boolean|string|null)}
 141 |  */
 142 | var get = function (object, path) {
 143 |   var properties = getProperties(path);
 144 |   var value = properties.reduce(getValue, object);
 145 |   return value
 146 | };
 147 | 
 148 | 
 149 | /**
 150 |  * Get value from first object.
 151 |  * @param {string} name
 152 |  * @param {Deep[]} objects
 153 |  * @param {function(*):boolean} [validate]
 154 |  * @returns {*}
 155 |  */
 156 | var getProperty = function (name, objects, validate) {
 157 |   if ( validate === void 0 ) validate = defaultValidator;
 158 | 
 159 |   var properties = objects.map(function (object) { return get(object, name); });
 160 |   var property = properties.find(function (property) { return validate(property); });
 161 |   return property
 162 | };
 163 | 
 164 | /**
 165 |  * @param {String} value -
 166 |  * @returns {String} -
 167 |  */
 168 | var normalizeString = function (value) {
 169 |   return value.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
 170 | };
 171 | 
 172 | 
 173 | /**
 174 |  * Faz em forma de corrente o replace do texto usando os argumentos
 175 |  * especificados.
 176 |  *
 177 |  * @param {String} text
 178 |  * @param {Array.<*>} args
 179 |  * @returns {String}
 180 |  */
 181 | var replace = function (text, args) { return args
 182 |   .reduce(function (text, ref) {
 183 |     var matcher = ref[0];
 184 |     var replaceBy = ref[1];
 185 | 
 186 |     return text.replace(matcher, replaceBy);
 187 |   }, text); };
 188 | 
 189 | 
 190 | /**
 191 |  * @param {Object} entyty -
 192 |  * @param {Array<string>} props -
 193 |  * @returns {String} -
 194 |  */
 195 | var getEntityQuery = function (entity, props) {
 196 |   var entityObj = entity || {};
 197 |   return props.map(function (prop) {
 198 |     var value = normalizeString(get(entityObj, prop) || '').toLowerCase();
 199 |     return value
 200 |   }).join(' ')
 201 | };
 202 | 
 203 | 
 204 | /**
 205 |  * @param {String} word -
 206 |  * @param {Array<string>} words -
 207 |  * @returns {Booloean} -
 208 |  */
 209 | var matches = function (word, words) { return (word ? words.split(word).length - 1 : 0); };
 210 | 
 211 | 
 212 | /**
 213 |  * @param {Array} list -
 214 |  * @param {String} strings -
 215 |  * @param {Arrat} keys -
 216 |  * @returns {Boolean} -
 217 |  */
 218 | var findBy = function (list, strings, keys) {
 219 |   if ( list === void 0 ) list = [];
 220 |   if ( strings === void 0 ) strings = '';
 221 |   if ( keys === void 0 ) keys = [];
 222 | 
 223 |   var terms = strings.toLowerCase().split(' ');
 224 | 
 225 |   return list.filter(function (el) { return keys.some(function (key) {
 226 |       var text = el[key].toLowerCase();
 227 | 
 228 |       return terms.some(function (term) { return text.includes(term); })
 229 |     }); }
 230 |   )
 231 | };
 232 | 
 233 | dayjs.extend(customParseFormat);
 234 | 
 235 | /**
 236 |  * Check value's constructor name.
 237 |  * @param {*} value
 238 |  * @param {string} constructor
 239 |  * @returns {boolean}
 240 |  */
 241 | 
 242 | var is = function (value, constructor) {
 243 |   return Object.prototype.toString.call(value) === ("[object " + constructor + "]")
 244 | };
 245 | 
 246 | 
 247 | /**
 248 |  * Creates a validator function that checks is value is included in values.
 249 |  * @param {Array} values
 250 |  * @returns {function(*):boolean}
 251 |  */
 252 | var includes = function (values) { return function (value) { return values.includes(value); }; };
 253 | 
 254 | 
 255 | /**
 256 |  * Checks if value is an alignment.
 257 |  */
 258 | var ALIGNMENTS = ['right', 'left', 'center'];
 259 | var isAlignment = includes(ALIGNMENTS);
 260 | 
 261 | 
 262 | /**
 263 |  * Checks if value is a list of objects.
 264 |  * @param {*} value
 265 |  * @returns {boolean}
 266 |  */
 267 | var isContent = function (value) {
 268 |   var isObject = function (value) { return is(value, 'Object'); };
 269 |   var isContent = is(value, 'Array') && value.every(isObject);
 270 |   return isContent
 271 | };
 272 | 
 273 | 
 274 | /**
 275 |  *
 276 |  */
 277 | var isCPF = function (cpf) {
 278 |   var isInvalid = function (cpf, rest, pos) { return rest !== parseInt(cpf.substring(pos, pos + 1)); };
 279 | 
 280 |   var sumDigit = function (cpf, digit) { return 11 - (cpf.substring(0, digit).split('').reduce(function (acc, curr, index) {
 281 |     acc += parseInt(curr) * ((digit + 1) - index);
 282 |     return acc
 283 |   }, 0) % 11); };
 284 | 
 285 |   var getRest = function (sum) { return sum > 9 ? 0 : sum; };
 286 | 
 287 |   if (!is(cpf, 'String')) { return false }
 288 | 
 289 |   cpf = cpf.replace(/[\D]/gi, '');
 290 | 
 291 |   if (!cpf.match(/^\d+$/)) { return false }
 292 | 
 293 |   if (cpf === '00000000000' || cpf.length !== 11) { return false }
 294 | 
 295 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 9)), 9)) { return false }
 296 | 
 297 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 10)), 10)) { return false }
 298 | 
 299 |   return true
 300 | };
 301 | 
 302 | 
 303 | /**
 304 |  * Valida se é uma data com o formato especificado ou, quando não especificado,
 305 |  * valida se é um dos formatos 'DD/MM/YYYY', 'DD-MM-YYYY' e 'YYYY-MM-DD'.
 306 |  *
 307 |  * @example ```
 308 |  * ('3/102/2006') => false
 309 |  * ('31/02/2006') => false
 310 |  * ('21/12/2006') => true
 311 |  * ('21/12/2006', 'YYYY-MM-DD') => false
 312 |  * ```
 313 |  *
 314 |  * @param {String} date
 315 |  * @param {String} [format]
 316 |  * @returns {Boolean}
 317 |  */
 318 | 
 319 | var isDate = function (date, format) {
 320 |   if ( format === void 0 ) format = null;
 321 | 
 322 |   var from = format || getDateFormat(date);
 323 | 
 324 |   // There's a lil' bug in dayjs where dayjs(null).isValid() returns false
 325 |   // but dayjs(undefined).isValid() returns true.
 326 | 
 327 |   var isValid = from
 328 |     ? dayjs(date, { format: from }).isValid()
 329 |     : dayjs(date || null).isValid();
 330 | 
 331 |   return isValid
 332 | };
 333 | 
 334 | 
 335 | /**
 336 |  * Valida se o valor é um CPNJ válido.
 337 |  * @param {String} value
 338 |  * @returns {Boolean}
 339 |  */
 340 | var isCNPJ = function (value) {
 341 |   if (!is(value, 'String')) {
 342 |     return false
 343 |   }
 344 | 
 345 |   var digits = value.replace(/[\D]/gi, '');
 346 | 
 347 |   var dig1 = 0;
 348 |   var dig2 = 0;
 349 | 
 350 |   var validation = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
 351 | 
 352 |   var digito = parseInt(digits.charAt(12) + digits.charAt(13));
 353 | 
 354 |   var getRest = function (dig) { return (((dig % 11) < 2) ? 0 : (11 - (dig % 11))); };
 355 | 
 356 |   validation.map(function (v, i) {
 357 |     dig1 += (i > 0 ? (digits.charAt(i - 1) * v) : 0);
 358 |     dig2 += digits.charAt(i) * v;
 359 |   });
 360 | 
 361 |   dig1 = getRest(dig1);
 362 |   dig2 = getRest(dig2);
 363 | 
 364 |   return (((dig1 * 10) + dig2) === digito)
 365 | };
 366 | 
 367 | 
 368 | /**
 369 |  * Valida, de forma simples*, se o valor é um email válido.
 370 |  * @param {String} value
 371 |  * @returns {Boolean}
 372 |  */
 373 | var isEmail = function (value) {
 374 |   var isValid = is(value, 'String') && /^.+@.+\..+$/.test(value);
 375 |   return isValid
 376 | };
 377 | 
 378 | 
 379 | /**
 380 |  * Checks if value is not null
 381 |  * @param {*} value
 382 |  * @returns {boolean}
 383 |  */
 384 | var defaultValidator = function (value) { return !is(value, 'Null'); };
 385 | 
 386 | 
 387 | var validate = Object.freeze({
 388 | 	is: is,
 389 | 	isAlignment: isAlignment,
 390 | 	isContent: isContent,
 391 | 	isCPF: isCPF,
 392 | 	isDate: isDate,
 393 | 	isCNPJ: isCNPJ,
 394 | 	isEmail: isEmail,
 395 | 	defaultValidator: defaultValidator
 396 | });
 397 | 
 398 | 
 399 | 
 400 | var index$1 = Object.freeze({
 401 | 	getDateFormat: getDateFormat,
 402 | 	formatDateBR: formatDateBR,
 403 | 	formatDateUS: formatDateUS,
 404 | 	calculateAge: calculateAge,
 405 | 	toCPF: toCPF,
 406 | 	toRG: toRG,
 407 | 	toInterval: toInterval,
 408 | 	toEmpty: toEmpty,
 409 | 	toPhone: toPhone,
 410 | 	toClean: toClean,
 411 | 	toSlug: toSlug,
 412 | 	toCEP: toCEP,
 413 | 	toMoney: toMoney,
 414 | 	toMilliseconds: toMilliseconds,
 415 | 	toHours: toHours,
 416 | 	toDays: toDays,
 417 | 	toYears: toYears,
 418 | 	toDate: toDate,
 419 | 	getConstructor: getConstructor,
 420 | 	chain: chain,
 421 | 	get: get,
 422 | 	getProperty: getProperty,
 423 | 	normalizeString: normalizeString,
 424 | 	replace: replace,
 425 | 	getEntityQuery: getEntityQuery,
 426 | 	matches: matches,
 427 | 	findBy: findBy,
 428 | 	is: is,
 429 | 	isAlignment: isAlignment,
 430 | 	isContent: isContent,
 431 | 	isCPF: isCPF,
 432 | 	isDate: isDate,
 433 | 	isCNPJ: isCNPJ,
 434 | 	isEmail: isEmail,
 435 | 	defaultValidator: defaultValidator
 436 | });
 437 | 
 438 | dayjs.extend(customParseFormat);
 439 | dayjs.locale('pt-br');
 440 | 
 441 | 
 442 | /**
 443 |  * Transforma um valor para a formatação de CPF.
 444 |  *
 445 |  * @example ```
 446 |  * ('00000000000') => '000.000.000-00'
 447 |  * ('12345678') => '123.456.78'
 448 |  * ('Abacaxi') => null
 449 |  * ```
 450 |  *
 451 |  * @param {String} cpf
 452 |  * @returns {String}
 453 |  */
 454 | 
 455 | var toCPF = function (cpf) {
 456 |   var isValid = is(cpf, 'String');
 457 |   var formatted = !isValid ? null : replace(cpf, [
 458 |     [/\D/g, ''],
 459 |     [/(\d{3})(\d)/, '$1.$2'],
 460 |     [/(\d{3})(\d)/, '$1.$2'],
 461 |     [/(\d{3})(\d{1,2})$/, '$1-$2']
 462 |   ]);
 463 |   return formatted
 464 | };
 465 | 
 466 | 
 467 | /**
 468 |  * Transforma um valor para a formatação de RG.
 469 |  *
 470 |  * @example ```
 471 |  * ('000000000') => '00.000.000-0'
 472 |  * ('12345678') => '123.456.78'
 473 |  * ('Abacaxi') => null
 474 |  * ```
 475 |  *
 476 |  * @param {String} rg
 477 |  * @returns {String}
 478 |  */
 479 | 
 480 | var toRG = function (rg) {
 481 |   var isValid = is(rg, 'String');
 482 |   var formatted = !isValid ? null : replace(rg.toUpperCase(), [
 483 |     [/[^\d|A|B|X]/g, ''],
 484 |     [/(\d{2})(\d)/, '$1.$2'],
 485 |     [/(\d{3})(\d)/, '$1.$2'],
 486 |     [/(\d{3})([\d|A|B|X]{1})$/, '$1-$2']
 487 |   ]);
 488 |   return formatted
 489 | };
 490 | 
 491 | 
 492 | /**
 493 |  * Usa a formatação de datas para retornar um intervalo.
 494 |  *
 495 |  * @example ```
 496 |  * ({ start: '21-12-2006', end: '31-12-2006' }) => '21/12/2006 a 31/12/2006'
 497 |  * ```
 498 |  *
 499 |  * @param {{ start: String, end: String }} dates
 500 |  * @param {{ from: String, to: String }} [options]
 501 |  * @returns {String}
 502 |  */
 503 | 
 504 | var toInterval = function (dates, options) {
 505 |   if ( options === void 0 ) options = {};
 506 | 
 507 |   var start = dates.start;
 508 |   var end = dates.end;
 509 |   var interval = (toDate(start, options)) + " a " + (toDate(end, options));
 510 |   return interval
 511 | };
 512 | 
 513 | 
 514 | /**
 515 |  * Faz uma verificação simples e coloca o caractere para vazio caso o valor seja
 516 |  * vazio (null, undefined, '').
 517 |  *
 518 |  * @param {*} value
 519 |  * @param {String} char
 520 |  * @returns {String}
 521 |  */
 522 | 
 523 | var toEmpty = function (value, char) {
 524 |   if ( char === void 0 ) char = '-';
 525 | 
 526 |   return value || char;
 527 | };
 528 | 
 529 | 
 530 | /**
 531 |  * Formata um valor para o formato de telefone.
 532 |  *
 533 |  * @param {String} value
 534 |  * @returns {String}
 535 |  */
 536 | 
 537 | var toPhone = function (value) {
 538 |   var isValid = is(value, 'String');
 539 |   var formatted = !isValid ? null : replace(value, [
 540 |     [/\D/g, ''],
 541 |     [/(\d{1,2})/, '($1'],
 542 |     [/(\(\d{2})(\d{1,4})/, '$1) $2'],
 543 |     [/( \d{4})(\d{1,4})/, '$1-$2'],
 544 |     [/( \d{4})(?:-)(\d{1})(\d{4})/, '$1$2-$3']
 545 |   ]);
 546 |   return formatted
 547 | };
 548 | 
 549 | 
 550 | /**
 551 |  * Formata o texto removendo seus acentos.
 552 |  *
 553 |  * @example ```
 554 |  * ('Vítor') => 'Vitor'
 555 |  * ('Olá, tudo bem com você?') => 'Ola, tudo bem com voce?'
 556 |  * ```
 557 |  *
 558 |  * @param {String} value
 559 |  * @returns {String}
 560 |  */
 561 | 
 562 | var toClean = function (value) {
 563 |   var isValid = is(value, 'String');
 564 |   var formatted = !isValid ? null : normalize.normalizeDiacritics(value);
 565 |   return formatted
 566 | };
 567 | 
 568 | 
 569 | /**
 570 |  * Formata um texto o transformando em _kebab-case_.
 571 |  *
 572 |  * @param {String} value
 573 |  * @returns {String}
 574 |  */
 575 | 
 576 | var toSlug = function (value) {
 577 |   if (!is(value, 'String')) { // Short-circuit to handle all non-string values
 578 |     return null               // and return null.
 579 |   }
 580 |   var formatted = replace(normalize__default(value), [
 581 |     [/&/g, '-e-'],
 582 |     [/\W/g, '-'],
 583 |     [/--+/g, '-'],
 584 |     [/(^-+)|(-+$)/, '']
 585 |   ]);
 586 |   return formatted
 587 | };
 588 | 
 589 | 
 590 | /**
 591 |  * Formata um valor para CEP.
 592 |  *
 593 |  * @param {String} value
 594 |  * @returns {Boolean}
 595 |  */
 596 | 
 597 | var toCEP = function (value) {
 598 |   var isValid = is(value, 'String');
 599 |   var formatted = !isValid ? null : replace(value, [
 600 |     [/\D/g, ''],
 601 |     [/(\d{5})(\d{1,3})/, '$1-$2']
 602 |   ]);
 603 |   return formatted
 604 | };
 605 | 
 606 | 
 607 | /**
 608 |  * Formata um valor para a formatação de moeda.
 609 |  *
 610 |  * @example ```
 611 |  * ('1200') => 'R$ 1.200,00'
 612 |  * (15.50) => 'R$ 15,50'
 613 |  * ('Abacaxi') => null
 614 |  * ```
 615 |  *
 616 |  * @param {String} number
 617 |  * @returns {String}
 618 |  */
 619 | 
 620 | var toMoney = function (number) {
 621 |   var isValid = is(number, 'Number') || (is(number, 'String') && !isNaN(number));
 622 |   var formatted = !isValid ? null : 'R$ ' + replace((+number).toFixed(2), [
 623 |     ['.', ','],
 624 |     [/(\d)(?=(\d{3})+(?!\d))/g, '$1.']
 625 |   ]);
 626 |   return formatted
 627 | };
 628 | 
 629 | // Date Formaters
 630 | // --------------
 631 | 
 632 | /**
 633 |  * Converts hours to milliseconds
 634 |  *
 635 |  * @param {Number} value - The time in hours.
 636 |  * @returns {}
 637 |  */
 638 | 
 639 | var toMilliseconds = function (value) {
 640 |   if (Number.isInteger(value)) { return value }
 641 | 
 642 |   var parsedValue = value.replace('hs', '').split(':');
 643 |   var hours = +(parsedValue[0] || 0) * 3600000;
 644 |   var minutes = (parsedValue[1] || '').length < 2
 645 |     ? +(((parsedValue[1] || 0) + "0")) * 60000
 646 |     : +(parsedValue[1] || 0) * 60000;
 647 | 
 648 |   return hours + minutes
 649 | };
 650 | 
 651 | /**
 652 |  * Converts milliseconds to hours
 653 |  *
 654 |  * @param {Number} ms - The time in miliseconds.
 655 |  * @returns {String} - The formmated time in `${hours}:${minutes}`.
 656 |  */
 657 | var toHours = function (ms) {
 658 |   var hours = Math.floor(ms / 3600000);
 659 |   var minutes = Math.floor((ms % 3600000) / 3600000 * 60);
 660 | 
 661 |   return (hours + ":" + (minutes || '00'))
 662 | };
 663 | 
 664 | 
 665 | /**
 666 |  * Formata para o formato de dias.
 667 |  *
 668 |  * @example ```
 669 |  * (2) => '2 dias'
 670 |  * (1) => '1 dia'
 671 |  * (0) => '0 dias'
 672 |  * ```
 673 |  *
 674 |  * @param {Number} quantity
 675 |  * @returns {String}
 676 |  */
 677 | 
 678 | var toDays = function (quantity) {
 679 |   var isValid = is(quantity, 'Number') && Number.isFinite(quantity);
 680 |   var days = (quantity === 1) ? '1 dia' : ((isValid ? ~~(quantity) : 0) + " dias");
 681 |   return days
 682 | };
 683 | 
 684 | 
 685 | /**
 686 |  * Obtém a quantidade de anos a partir da data.
 687 |  *
 688 |  * @example ```
 689 |  * ('21-12-2006') => 10
 690 |  * ('2000-12-21') => 16
 691 |  * ('Abacaxi') => null
 692 |  * ```
 693 |  *
 694 |  * @param {String} date
 695 |  * @returns {Number}
 696 |  */
 697 | 
 698 | var toYears = function (date) {
 699 |   var format = getDateFormat(date);
 700 |   var from = format ? dayjs(date, { format: format }) : null;
 701 |   var diff = from ? dayjs().diff(from, 'years') : null;
 702 |   var years = is(diff, 'Number') && !isNaN(diff) ? diff : null;
 703 | 
 704 |   return years
 705 | };
 706 | 
 707 | 
 708 | /**
 709 |  * Formata uma data 'YYYY-MM-DD' ou 'DD-MM-YYYY' em 'DD/MM/YYYY'. Transforma
 710 |  * a data em 'YYYY-MM-DD' caso o segundo parâmetro seja "true".
 711 |  *
 712 |  * @example ```
 713 |  * ('21-12-2006') => '21/12/2006'
 714 |  * ('2006-12-21') => '21/12/2006'
 715 |  * ('21/12/2006') => '21/12/2006'
 716 |  * ('21/12/2006', true) => '2006-12-21'
 717 |  * ('2006-12-21', true) => '2006-12-21'
 718 |  * ('2006/12/21') => null
 719 |  * ```
 720 |  *
 721 |  * @param {String} date
 722 |  * @param {{ from: String, to: String, UTC: Boolean }} [options]
 723 |  * @returns {String}
 724 |  */
 725 | 
 726 | var toDate = function (date, ref) {
 727 |   if ( ref === void 0 ) ref = {};
 728 |   var to = ref.to; if ( to === void 0 ) to = 'DD/MM/YYYY';
 729 |   var from = ref.from; if ( from === void 0 ) from = getDateFormat(date);
 730 |   var isUTC = ref.UTC; if ( isUTC === void 0 ) isUTC = false;
 731 | 
 732 |   var isValid = isDate(date, from);
 733 |   if (!isValid) { return null }
 734 | 
 735 |   var formatted = isUTC
 736 |     ? dayjs(date, (from ? { format: from } : {})).utc()
 737 |     : dayjs(date, (from ? { format: from } : {}));
 738 | 
 739 |   // const formatted = dayjs(date, { format: from, utc: isUTC })
 740 | 
 741 |   return formatted.format(to)
 742 | };
 743 | 
 744 | 
 745 | var format = Object.freeze({
 746 | 	toCPF: toCPF,
 747 | 	toRG: toRG,
 748 | 	toInterval: toInterval,
 749 | 	toEmpty: toEmpty,
 750 | 	toPhone: toPhone,
 751 | 	toClean: toClean,
 752 | 	toSlug: toSlug,
 753 | 	toCEP: toCEP,
 754 | 	toMoney: toMoney,
 755 | 	toMilliseconds: toMilliseconds,
 756 | 	toHours: toHours,
 757 | 	toDays: toDays,
 758 | 	toYears: toYears,
 759 | 	toDate: toDate
 760 | });
 761 | 
 762 | /**
 763 |  * @param {Object} -
 764 |  */
 765 | var Alignable = function (ref) {
 766 |   if ( ref === void 0 ) ref = {};
 767 |   var cols = ref.cols; if ( cols === void 0 ) cols = 'cols';
 768 | 
 769 |   return ({
 770 |   props: {
 771 |     align: {
 772 |       type: String,
 773 |       default: 'left',
 774 |       validator: isAlignment
 775 |     }
 776 |   },
 777 | 
 778 |   methods: {
 779 |     /**
 780 |      * Get column's alignment.
 781 |      * @param {number} index
 782 |      * @returns {('right'|'left'|'center')}
 783 |      */
 784 |     $getAlignment: function $getAlignment (index) {
 785 |       var col = this[cols][index];
 786 |       var alignment = getProperty('align', [col, this._props], isAlignment);
 787 |       return alignment
 788 |     }
 789 |   }
 790 | });
 791 | };
 792 | 
 793 | function __async(g){return new Promise(function(s,j){function c(a,x){try{var r=g[x?"throw":"next"](a);}catch(e){j(e);return}r.done?s(r.value):Promise.resolve(r.value).then(c,d);}function d(e){c(e,1);}c();})}
 794 | 
 795 | /**
 796 |  * Adiciona o dado isLoading com true, que assim que o componente e montado
 797 |  * e a action e executada ele passa a ser false.
 798 |  *
 799 |  * @param {function(Vue): Promise} action - Action a ser executada, recebe
 800 |  * o contexto do componente como parametro e deve retornar uma Promise.
 801 |  *
 802 |  */
 803 | var Loadable = function (action) { return ({
 804 |   data: function data () { return { isLoading: false } },
 805 | 
 806 |   mounted: function mounted () {return __async(function*(){
 807 |     var loaderFn = action || this.load;
 808 |     var isLoadable = is(loaderFn, 'Function');
 809 | 
 810 |     if (!isLoadable) { return }
 811 | 
 812 |     this.isLoading = true;
 813 |     yield Promise.resolve(loaderFn.call(this));
 814 |     this.isLoading = false;
 815 |   }.call(this))}
 816 | }); };
 817 | 
 818 | /**
 819 |  *
 820 |  */
 821 | var MediaQuery = {
 822 |   data: function data () {
 823 |     return {
 824 |       matchMedia: window.matchMedia('(max-width: 1023px)'),
 825 |       isMobile: false
 826 |     }
 827 |   },
 828 |   methods: {
 829 |     setBreakpoint: function setBreakpoint () {
 830 |       this.isMobile = this.matchMedia && this.matchMedia.matches;
 831 |     }
 832 |   },
 833 |   beforeDestroy: function beforeDestroy () {
 834 |     this.matchMedia.removeListener(this.setBreakpoint);
 835 |   },
 836 |   mounted: function mounted () {
 837 |     this.matchMedia.addListener(this.setBreakpoint);
 838 |     this.setBreakpoint();
 839 |   }
 840 | };
 841 | 
 842 | /**
 843 |  * Resolve o problema das propriedades não inicializadas que não poderiam ser
 844 |  * observadas.
 845 |  * @param {{}} template
 846 |  */
 847 | var ObservableFix = function (template) {
 848 |   if ( template === void 0 ) template = {};
 849 | 
 850 |   return ({
 851 |   props: {
 852 |     data: {
 853 |       type: Object,
 854 |       default: function () { return Object.assign({}, template); }
 855 |     }
 856 |   },
 857 |   data: function data () {
 858 |     return {
 859 |       selected: Object.assign({}, template)
 860 |     }
 861 |   },
 862 |   watch: {
 863 |     data: function data () {
 864 |       this.cloneData();
 865 |     }
 866 |   },
 867 |   methods: {
 868 |     cloneData: function cloneData () {
 869 |       this.selected = Object.assign({}, template, this.data);
 870 |     }
 871 |   },
 872 |   mounted: function mounted () {
 873 |     this.cloneData();
 874 |   }
 875 | });
 876 | };
 877 | 
 878 | /*
 879 |   - 'Shadowed' Vue mixin is suposed to be used together with Sass 'shadowed' sass mixin.
 880 | 
 881 |   - Import the Vue mixin in your component and place a ref="shadowed" in the element
 882 |     that you would like to have a shadowed scroll behavior.
 883 | 
 884 |   - The element must have a wrapper div (father element) for the mixin to work properly.
 885 | 
 886 |   - Place a @include shadowed($shadow-size) in the wrapper element (style section)
 887 | */
 888 | 
 889 | var Shadowed = function (refName) {
 890 |   if ( refName === void 0 ) refName = 'shadowed';
 891 | 
 892 |   return ({
 893 |   data: function data () {
 894 |     return {
 895 |       upperShadow: false,
 896 |       bottomShadow: false
 897 |     }
 898 |   },
 899 | 
 900 |   watch: {
 901 |     upperShadow: function upperShadow (val) {
 902 |       if (val) {
 903 |         this.shadowedElement.classList.add('-upper-shadow');
 904 |       } else {
 905 |         this.shadowedElement.classList.remove('-upper-shadow');
 906 |       }
 907 |     },
 908 |     bottomShadow: function bottomShadow (val) {
 909 |       if (val) {
 910 |         this.shadowedElement.classList.add('-bottom-shadow');
 911 |       } else {
 912 |         this.shadowedElement.classList.remove('-bottom-shadow');
 913 |       }
 914 |     }
 915 |   },
 916 | 
 917 |   computed: {
 918 |     shadowedElement: function shadowedElement () {
 919 |       return this.$refs[refName].hasOwnProperty('$el') ?
 920 |         this.$refs[refName].$el : this.$refs[refName]
 921 |     }
 922 |   },
 923 | 
 924 |   methods: {
 925 |     toggleScrollShadow: function toggleScrollShadow () {
 926 |       var ref = this.shadowedElement;
 927 |       var scrollTop = ref.scrollTop;
 928 |       var scrollHeight = ref.scrollHeight;
 929 |       var clientHeight = ref.clientHeight;
 930 | 
 931 |       this.upperShadow = scrollTop > 0;
 932 |       this.bottomShadow = scrollHeight > (clientHeight + scrollTop);
 933 |     }
 934 |   },
 935 | 
 936 |   beforeUpdate: function beforeUpdate () {
 937 |     this.$nextTick(this.toggleScrollShadow);
 938 |   },
 939 | 
 940 |   mounted: function mounted () {
 941 |     this.$nextTick(this.toggleScrollShadow);
 942 |     window.addEventListener('resize', this.toggleScrollShadow);
 943 |     this.shadowedElement.addEventListener('scroll', this.toggleScrollShadow);
 944 |   },
 945 | 
 946 |   beforeDestroy: function beforeDestroy () {
 947 |     window.removeEventListener('resize', this.toggleScrollShadow);
 948 |     this.shadowedElement.removeEventListener('scroll', this.toggleScrollShadow);
 949 |   }
 950 | });
 951 | };
 952 | 
 953 | 
 954 | 
 955 | var index$2 = Object.freeze({
 956 | 	Alignable: Alignable,
 957 | 	Loadable: Loadable,
 958 | 	MediaQuery: MediaQuery,
 959 | 	ObservableFix: ObservableFix,
 960 | 	Shadowed: Shadowed
 961 | });
 962 | 
 963 | /**
 964 |  * Opções do plugin.
 965 |  * @typedef {Object} Options
 966 |  * @property {Boolean} formatters
 967 |  * @property {Boolean} formatFilters
 968 |  * @property {Boolean} validators
 969 |  */
 970 | 
 971 | /**
 972 |  * Adiciona as funções auxiliares definidas no protótipo do Vue, e
 973 |  * consequentemente aos componentes.
 974 |  * @param {Vue} Vue
 975 |  * @param {Options} options
 976 |  */
 977 | 
 978 | var index = function (Vue, options) {
 979 |   if ( options === void 0 ) options = {};
 980 | 
 981 |   if (options.formatters) {
 982 |     Vue.prototype.$format = format;
 983 |   }
 984 | 
 985 |   if (options.formatFilters) {
 986 |     Object.keys(format).forEach(function (name) {
 987 |       var handler = format[name];
 988 |       Vue.filter(name, handler);
 989 |     });
 990 |   }
 991 | 
 992 |   if (options.validators) {
 993 |     Vue.prototype.$validate = validate;
 994 |   }
 995 | };
 996 | 
 997 | exports['default'] = index;
 998 | exports.validate = validate;
 999 | exports.format = format;
1000 | exports.mixin = index$2;
1001 | exports.helpers = index$1;
1002 | 


--------------------------------------------------------------------------------
/dist/vue-convenia-util.es.js:
--------------------------------------------------------------------------------
  1 | import dayjs from 'dayjs-ext';
  2 | import customParseFormat from 'dayjs-ext/plugin/customParseFormat';
  3 | import 'dayjs-ext/locale/pt-br';
  4 | import normalize, { normalizeDiacritics } from 'normalize-text';
  5 | 
  6 | /**
  7 |  * Obtém o formato da data ou null se não for possível identificar.
  8 |  * @example ```
  9 |  * ('2000-21-12') => ['YYYY-DD-MM', 'YYYY-MM-DD HH:mm:ss']
 10 |  * ('21-12-2000') => ['DD-MM-YYYY', 'DD-MM-YYYY HH:mm:ss']
 11 |  * ('21/12/2000 23:59:18') => ['DD/MM/YYYY', 'DD/MM/YYYY HH:mm:ss']
 12 |  * ('2000/12/21') => null
 13 |  * ```
 14 |  * @param {String} date
 15 |  * @returns {String}
 16 |  */
 17 | var getDateFormat = function (date) {
 18 |   var isValid = is(date, 'String') && date.trim().length >= 10;
 19 |   var format = !isValid ? null
 20 |     : /^\d{4}-\d{2}-\d{2}$/.test(date) ? 'YYYY-MM-DD'
 21 |     : /^\d{2}-\d{2}-\d{4}$/.test(date) ? 'DD-MM-YYYY'
 22 |     : /^\d{2}\/\d{2}\/\d{4}$/.test(date) ? 'DD/MM/YYYY'
 23 |     : null;
 24 | 
 25 |   return format
 26 | };
 27 | 
 28 | /**
 29 |  * Receives a date in US string format or unix timestamp and returns
 30 |  * it in brazillian format.
 31 |  *
 32 |  * @param {String|Number} value - The date to be formatted.
 33 |  * @returns {String} - the formmated date.
 34 |  *
 35 |  */
 36 | var formatDateBR = function (value) {
 37 |   if (!value) { return '' }
 38 | 
 39 |   var date = typeof value === 'string'
 40 |     ? new Date((value + "T00:00:00"))
 41 |     : new Date(value);
 42 | 
 43 |   return date.toLocaleDateString('pt-BR')
 44 | };
 45 | 
 46 | 
 47 | /**
 48 |  * Receives a date in BR string format and returns its US equivalent
 49 |  *
 50 |  * @param {String} value - The date to be formatted.
 51 |  * @returns {String} - the formmated date.
 52 |  *
 53 |  */
 54 | var formatDateUS = function (date) {
 55 |   if (!date) { return '' }
 56 | 
 57 |   return date.substr(0, 10).split('/').reverse().join('-')
 58 | };
 59 | 
 60 | 
 61 | /**
 62 |  * Calculates a person's age given a birthday.
 63 |  *
 64 |  * @param {Date} birthday - A Date instance representing the birthday.
 65 |  * @returns {Number} - The person's age.
 66 |  *
 67 |  */
 68 | var calculateAge = function (birthday) {
 69 |   var ageDifMs = Date.now() - birthday.getTime();
 70 |   var ageDate = new Date(ageDifMs);
 71 | 
 72 |   return Math.abs(ageDate.getUTCFullYear() - 1970);
 73 | };
 74 | 
 75 | /**
 76 |  * Obtém o construtor do valor.
 77 |  * @param {*} value
 78 |  * @returns {String}
 79 |  */
 80 | var getConstructor = function (value) {
 81 |   var string = Object.prototype.toString.call(value);
 82 |   var ref = /\[object (.*?)\]/.exec(string);
 83 |   var constructor = ref[1];
 84 |   return constructor
 85 | };
 86 | 
 87 | /**
 88 |  * Usando um valor inicial, encadeia uma função e retorna seu resultado.
 89 |  * @param {A} initial
 90 |  * @param {function(A):function} callback
 91 |  * @param {Array.<*>} params
 92 |  * @returns {B}
 93 |  * @template A, B
 94 |  */
 95 | var chain = function (initial, callback, params) {
 96 |   var value = params.reduce(function (value, args) {
 97 |     return callback(value).apply(value, [].concat( args ))
 98 |   }, initial);
 99 | 
100 |   return value
101 | };
102 | 
103 | var DELIMITER = '.';
104 | 
105 | /**
106 |  * Spreads path into fields list.
107 |  * @param {string} path
108 |  * @returns {Array.<string>}
109 |  */
110 | var getProperties = function (path) { return is(path, 'String') ? path.split(DELIMITER) : []; };
111 | 
112 | /**
113 |  * Deep object.
114 |  * @typedef {Object.<string, (number|boolean|string|Deep)>} Deep
115 |  */
116 | 
117 | /**
118 |  * Checks if a propety is reachable.
119 |  * @param {Deep} object
120 |  * @param {string} property
121 |  * @returns {(number|boolean|string|null)}
122 |  */
123 | var getValue = function (object, property) {
124 |   var isReachable = is(object, 'Object') && object.hasOwnProperty(property);
125 |   var value = isReachable ? object[property] : null;
126 |   return value
127 | };
128 | 
129 | /**
130 |  * Get value from object path.
131 |  * @param {Deep} object
132 |  * @param {(string|Array.<string>)} path
133 |  * @returns {(number|boolean|string|null)}
134 |  */
135 | var get = function (object, path) {
136 |   var properties = getProperties(path);
137 |   var value = properties.reduce(getValue, object);
138 |   return value
139 | };
140 | 
141 | 
142 | /**
143 |  * Get value from first object.
144 |  * @param {string} name
145 |  * @param {Deep[]} objects
146 |  * @param {function(*):boolean} [validate]
147 |  * @returns {*}
148 |  */
149 | var getProperty = function (name, objects, validate) {
150 |   if ( validate === void 0 ) validate = defaultValidator;
151 | 
152 |   var properties = objects.map(function (object) { return get(object, name); });
153 |   var property = properties.find(function (property) { return validate(property); });
154 |   return property
155 | };
156 | 
157 | /**
158 |  * @param {String} value -
159 |  * @returns {String} -
160 |  */
161 | var normalizeString = function (value) {
162 |   return value.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
163 | };
164 | 
165 | 
166 | /**
167 |  * Faz em forma de corrente o replace do texto usando os argumentos
168 |  * especificados.
169 |  *
170 |  * @param {String} text
171 |  * @param {Array.<*>} args
172 |  * @returns {String}
173 |  */
174 | var replace = function (text, args) { return args
175 |   .reduce(function (text, ref) {
176 |     var matcher = ref[0];
177 |     var replaceBy = ref[1];
178 | 
179 |     return text.replace(matcher, replaceBy);
180 |   }, text); };
181 | 
182 | 
183 | /**
184 |  * @param {Object} entyty -
185 |  * @param {Array<string>} props -
186 |  * @returns {String} -
187 |  */
188 | var getEntityQuery = function (entity, props) {
189 |   var entityObj = entity || {};
190 |   return props.map(function (prop) {
191 |     var value = normalizeString(get(entityObj, prop) || '').toLowerCase();
192 |     return value
193 |   }).join(' ')
194 | };
195 | 
196 | 
197 | /**
198 |  * @param {String} word -
199 |  * @param {Array<string>} words -
200 |  * @returns {Booloean} -
201 |  */
202 | var matches = function (word, words) { return (word ? words.split(word).length - 1 : 0); };
203 | 
204 | 
205 | /**
206 |  * @param {Array} list -
207 |  * @param {String} strings -
208 |  * @param {Arrat} keys -
209 |  * @returns {Boolean} -
210 |  */
211 | var findBy = function (list, strings, keys) {
212 |   if ( list === void 0 ) list = [];
213 |   if ( strings === void 0 ) strings = '';
214 |   if ( keys === void 0 ) keys = [];
215 | 
216 |   var terms = strings.toLowerCase().split(' ');
217 | 
218 |   return list.filter(function (el) { return keys.some(function (key) {
219 |       var text = el[key].toLowerCase();
220 | 
221 |       return terms.some(function (term) { return text.includes(term); })
222 |     }); }
223 |   )
224 | };
225 | 
226 | dayjs.extend(customParseFormat);
227 | 
228 | /**
229 |  * Check value's constructor name.
230 |  * @param {*} value
231 |  * @param {string} constructor
232 |  * @returns {boolean}
233 |  */
234 | 
235 | var is = function (value, constructor) {
236 |   return Object.prototype.toString.call(value) === ("[object " + constructor + "]")
237 | };
238 | 
239 | 
240 | /**
241 |  * Creates a validator function that checks is value is included in values.
242 |  * @param {Array} values
243 |  * @returns {function(*):boolean}
244 |  */
245 | var includes = function (values) { return function (value) { return values.includes(value); }; };
246 | 
247 | 
248 | /**
249 |  * Checks if value is an alignment.
250 |  */
251 | var ALIGNMENTS = ['right', 'left', 'center'];
252 | var isAlignment = includes(ALIGNMENTS);
253 | 
254 | 
255 | /**
256 |  * Checks if value is a list of objects.
257 |  * @param {*} value
258 |  * @returns {boolean}
259 |  */
260 | var isContent = function (value) {
261 |   var isObject = function (value) { return is(value, 'Object'); };
262 |   var isContent = is(value, 'Array') && value.every(isObject);
263 |   return isContent
264 | };
265 | 
266 | 
267 | /**
268 |  *
269 |  */
270 | var isCPF = function (cpf) {
271 |   var isInvalid = function (cpf, rest, pos) { return rest !== parseInt(cpf.substring(pos, pos + 1)); };
272 | 
273 |   var sumDigit = function (cpf, digit) { return 11 - (cpf.substring(0, digit).split('').reduce(function (acc, curr, index) {
274 |     acc += parseInt(curr) * ((digit + 1) - index);
275 |     return acc
276 |   }, 0) % 11); };
277 | 
278 |   var getRest = function (sum) { return sum > 9 ? 0 : sum; };
279 | 
280 |   if (!is(cpf, 'String')) { return false }
281 | 
282 |   cpf = cpf.replace(/[\D]/gi, '');
283 | 
284 |   if (!cpf.match(/^\d+$/)) { return false }
285 | 
286 |   if (cpf === '00000000000' || cpf.length !== 11) { return false }
287 | 
288 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 9)), 9)) { return false }
289 | 
290 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 10)), 10)) { return false }
291 | 
292 |   return true
293 | };
294 | 
295 | 
296 | /**
297 |  * Valida se é uma data com o formato especificado ou, quando não especificado,
298 |  * valida se é um dos formatos 'DD/MM/YYYY', 'DD-MM-YYYY' e 'YYYY-MM-DD'.
299 |  *
300 |  * @example ```
301 |  * ('3/102/2006') => false
302 |  * ('31/02/2006') => false
303 |  * ('21/12/2006') => true
304 |  * ('21/12/2006', 'YYYY-MM-DD') => false
305 |  * ```
306 |  *
307 |  * @param {String} date
308 |  * @param {String} [format]
309 |  * @returns {Boolean}
310 |  */
311 | 
312 | var isDate = function (date, format) {
313 |   if ( format === void 0 ) format = null;
314 | 
315 |   var from = format || getDateFormat(date);
316 | 
317 |   // There's a lil' bug in dayjs where dayjs(null).isValid() returns false
318 |   // but dayjs(undefined).isValid() returns true.
319 | 
320 |   var isValid = from
321 |     ? dayjs(date, { format: from }).isValid()
322 |     : dayjs(date || null).isValid();
323 | 
324 |   return isValid
325 | };
326 | 
327 | 
328 | /**
329 |  * Valida se o valor é um CPNJ válido.
330 |  * @param {String} value
331 |  * @returns {Boolean}
332 |  */
333 | var isCNPJ = function (value) {
334 |   if (!is(value, 'String')) {
335 |     return false
336 |   }
337 | 
338 |   var digits = value.replace(/[\D]/gi, '');
339 | 
340 |   var dig1 = 0;
341 |   var dig2 = 0;
342 | 
343 |   var validation = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2];
344 | 
345 |   var digito = parseInt(digits.charAt(12) + digits.charAt(13));
346 | 
347 |   var getRest = function (dig) { return (((dig % 11) < 2) ? 0 : (11 - (dig % 11))); };
348 | 
349 |   validation.map(function (v, i) {
350 |     dig1 += (i > 0 ? (digits.charAt(i - 1) * v) : 0);
351 |     dig2 += digits.charAt(i) * v;
352 |   });
353 | 
354 |   dig1 = getRest(dig1);
355 |   dig2 = getRest(dig2);
356 | 
357 |   return (((dig1 * 10) + dig2) === digito)
358 | };
359 | 
360 | 
361 | /**
362 |  * Valida, de forma simples*, se o valor é um email válido.
363 |  * @param {String} value
364 |  * @returns {Boolean}
365 |  */
366 | var isEmail = function (value) {
367 |   var isValid = is(value, 'String') && /^.+@.+\..+$/.test(value);
368 |   return isValid
369 | };
370 | 
371 | 
372 | /**
373 |  * Checks if value is not null
374 |  * @param {*} value
375 |  * @returns {boolean}
376 |  */
377 | var defaultValidator = function (value) { return !is(value, 'Null'); };
378 | 
379 | 
380 | var validate = Object.freeze({
381 | 	is: is,
382 | 	isAlignment: isAlignment,
383 | 	isContent: isContent,
384 | 	isCPF: isCPF,
385 | 	isDate: isDate,
386 | 	isCNPJ: isCNPJ,
387 | 	isEmail: isEmail,
388 | 	defaultValidator: defaultValidator
389 | });
390 | 
391 | 
392 | 
393 | var index$1 = Object.freeze({
394 | 	getDateFormat: getDateFormat,
395 | 	formatDateBR: formatDateBR,
396 | 	formatDateUS: formatDateUS,
397 | 	calculateAge: calculateAge,
398 | 	toCPF: toCPF,
399 | 	toRG: toRG,
400 | 	toInterval: toInterval,
401 | 	toEmpty: toEmpty,
402 | 	toPhone: toPhone,
403 | 	toClean: toClean,
404 | 	toSlug: toSlug,
405 | 	toCEP: toCEP,
406 | 	toMoney: toMoney,
407 | 	toMilliseconds: toMilliseconds,
408 | 	toHours: toHours,
409 | 	toDays: toDays,
410 | 	toYears: toYears,
411 | 	toDate: toDate,
412 | 	getConstructor: getConstructor,
413 | 	chain: chain,
414 | 	get: get,
415 | 	getProperty: getProperty,
416 | 	normalizeString: normalizeString,
417 | 	replace: replace,
418 | 	getEntityQuery: getEntityQuery,
419 | 	matches: matches,
420 | 	findBy: findBy,
421 | 	is: is,
422 | 	isAlignment: isAlignment,
423 | 	isContent: isContent,
424 | 	isCPF: isCPF,
425 | 	isDate: isDate,
426 | 	isCNPJ: isCNPJ,
427 | 	isEmail: isEmail,
428 | 	defaultValidator: defaultValidator
429 | });
430 | 
431 | dayjs.extend(customParseFormat);
432 | dayjs.locale('pt-br');
433 | 
434 | 
435 | /**
436 |  * Transforma um valor para a formatação de CPF.
437 |  *
438 |  * @example ```
439 |  * ('00000000000') => '000.000.000-00'
440 |  * ('12345678') => '123.456.78'
441 |  * ('Abacaxi') => null
442 |  * ```
443 |  *
444 |  * @param {String} cpf
445 |  * @returns {String}
446 |  */
447 | 
448 | var toCPF = function (cpf) {
449 |   var isValid = is(cpf, 'String');
450 |   var formatted = !isValid ? null : replace(cpf, [
451 |     [/\D/g, ''],
452 |     [/(\d{3})(\d)/, '$1.$2'],
453 |     [/(\d{3})(\d)/, '$1.$2'],
454 |     [/(\d{3})(\d{1,2})$/, '$1-$2']
455 |   ]);
456 |   return formatted
457 | };
458 | 
459 | 
460 | /**
461 |  * Transforma um valor para a formatação de RG.
462 |  *
463 |  * @example ```
464 |  * ('000000000') => '00.000.000-0'
465 |  * ('12345678') => '123.456.78'
466 |  * ('Abacaxi') => null
467 |  * ```
468 |  *
469 |  * @param {String} rg
470 |  * @returns {String}
471 |  */
472 | 
473 | var toRG = function (rg) {
474 |   var isValid = is(rg, 'String');
475 |   var formatted = !isValid ? null : replace(rg.toUpperCase(), [
476 |     [/[^\d|A|B|X]/g, ''],
477 |     [/(\d{2})(\d)/, '$1.$2'],
478 |     [/(\d{3})(\d)/, '$1.$2'],
479 |     [/(\d{3})([\d|A|B|X]{1})$/, '$1-$2']
480 |   ]);
481 |   return formatted
482 | };
483 | 
484 | 
485 | /**
486 |  * Usa a formatação de datas para retornar um intervalo.
487 |  *
488 |  * @example ```
489 |  * ({ start: '21-12-2006', end: '31-12-2006' }) => '21/12/2006 a 31/12/2006'
490 |  * ```
491 |  *
492 |  * @param {{ start: String, end: String }} dates
493 |  * @param {{ from: String, to: String }} [options]
494 |  * @returns {String}
495 |  */
496 | 
497 | var toInterval = function (dates, options) {
498 |   if ( options === void 0 ) options = {};
499 | 
500 |   var start = dates.start;
501 |   var end = dates.end;
502 |   var interval = (toDate(start, options)) + " a " + (toDate(end, options));
503 |   return interval
504 | };
505 | 
506 | 
507 | /**
508 |  * Faz uma verificação simples e coloca o caractere para vazio caso o valor seja
509 |  * vazio (null, undefined, '').
510 |  *
511 |  * @param {*} value
512 |  * @param {String} char
513 |  * @returns {String}
514 |  */
515 | 
516 | var toEmpty = function (value, char) {
517 |   if ( char === void 0 ) char = '-';
518 | 
519 |   return value || char;
520 | };
521 | 
522 | 
523 | /**
524 |  * Formata um valor para o formato de telefone.
525 |  *
526 |  * @param {String} value
527 |  * @returns {String}
528 |  */
529 | 
530 | var toPhone = function (value) {
531 |   var isValid = is(value, 'String');
532 |   var formatted = !isValid ? null : replace(value, [
533 |     [/\D/g, ''],
534 |     [/(\d{1,2})/, '($1'],
535 |     [/(\(\d{2})(\d{1,4})/, '$1) $2'],
536 |     [/( \d{4})(\d{1,4})/, '$1-$2'],
537 |     [/( \d{4})(?:-)(\d{1})(\d{4})/, '$1$2-$3']
538 |   ]);
539 |   return formatted
540 | };
541 | 
542 | 
543 | /**
544 |  * Formata o texto removendo seus acentos.
545 |  *
546 |  * @example ```
547 |  * ('Vítor') => 'Vitor'
548 |  * ('Olá, tudo bem com você?') => 'Ola, tudo bem com voce?'
549 |  * ```
550 |  *
551 |  * @param {String} value
552 |  * @returns {String}
553 |  */
554 | 
555 | var toClean = function (value) {
556 |   var isValid = is(value, 'String');
557 |   var formatted = !isValid ? null : normalizeDiacritics(value);
558 |   return formatted
559 | };
560 | 
561 | 
562 | /**
563 |  * Formata um texto o transformando em _kebab-case_.
564 |  *
565 |  * @param {String} value
566 |  * @returns {String}
567 |  */
568 | 
569 | var toSlug = function (value) {
570 |   if (!is(value, 'String')) { // Short-circuit to handle all non-string values
571 |     return null               // and return null.
572 |   }
573 |   var formatted = replace(normalize(value), [
574 |     [/&/g, '-e-'],
575 |     [/\W/g, '-'],
576 |     [/--+/g, '-'],
577 |     [/(^-+)|(-+$)/, '']
578 |   ]);
579 |   return formatted
580 | };
581 | 
582 | 
583 | /**
584 |  * Formata um valor para CEP.
585 |  *
586 |  * @param {String} value
587 |  * @returns {Boolean}
588 |  */
589 | 
590 | var toCEP = function (value) {
591 |   var isValid = is(value, 'String');
592 |   var formatted = !isValid ? null : replace(value, [
593 |     [/\D/g, ''],
594 |     [/(\d{5})(\d{1,3})/, '$1-$2']
595 |   ]);
596 |   return formatted
597 | };
598 | 
599 | 
600 | /**
601 |  * Formata um valor para a formatação de moeda.
602 |  *
603 |  * @example ```
604 |  * ('1200') => 'R$ 1.200,00'
605 |  * (15.50) => 'R$ 15,50'
606 |  * ('Abacaxi') => null
607 |  * ```
608 |  *
609 |  * @param {String} number
610 |  * @returns {String}
611 |  */
612 | 
613 | var toMoney = function (number) {
614 |   var isValid = is(number, 'Number') || (is(number, 'String') && !isNaN(number));
615 |   var formatted = !isValid ? null : 'R$ ' + replace((+number).toFixed(2), [
616 |     ['.', ','],
617 |     [/(\d)(?=(\d{3})+(?!\d))/g, '$1.']
618 |   ]);
619 |   return formatted
620 | };
621 | 
622 | // Date Formaters
623 | // --------------
624 | 
625 | /**
626 |  * Converts hours to milliseconds
627 |  *
628 |  * @param {Number} value - The time in hours.
629 |  * @returns {}
630 |  */
631 | 
632 | var toMilliseconds = function (value) {
633 |   if (Number.isInteger(value)) { return value }
634 | 
635 |   var parsedValue = value.replace('hs', '').split(':');
636 |   var hours = +(parsedValue[0] || 0) * 3600000;
637 |   var minutes = (parsedValue[1] || '').length < 2
638 |     ? +(((parsedValue[1] || 0) + "0")) * 60000
639 |     : +(parsedValue[1] || 0) * 60000;
640 | 
641 |   return hours + minutes
642 | };
643 | 
644 | /**
645 |  * Converts milliseconds to hours
646 |  *
647 |  * @param {Number} ms - The time in miliseconds.
648 |  * @returns {String} - The formmated time in `${hours}:${minutes}`.
649 |  */
650 | var toHours = function (ms) {
651 |   var hours = Math.floor(ms / 3600000);
652 |   var minutes = Math.floor((ms % 3600000) / 3600000 * 60);
653 | 
654 |   return (hours + ":" + (minutes || '00'))
655 | };
656 | 
657 | 
658 | /**
659 |  * Formata para o formato de dias.
660 |  *
661 |  * @example ```
662 |  * (2) => '2 dias'
663 |  * (1) => '1 dia'
664 |  * (0) => '0 dias'
665 |  * ```
666 |  *
667 |  * @param {Number} quantity
668 |  * @returns {String}
669 |  */
670 | 
671 | var toDays = function (quantity) {
672 |   var isValid = is(quantity, 'Number') && Number.isFinite(quantity);
673 |   var days = (quantity === 1) ? '1 dia' : ((isValid ? ~~(quantity) : 0) + " dias");
674 |   return days
675 | };
676 | 
677 | 
678 | /**
679 |  * Obtém a quantidade de anos a partir da data.
680 |  *
681 |  * @example ```
682 |  * ('21-12-2006') => 10
683 |  * ('2000-12-21') => 16
684 |  * ('Abacaxi') => null
685 |  * ```
686 |  *
687 |  * @param {String} date
688 |  * @returns {Number}
689 |  */
690 | 
691 | var toYears = function (date) {
692 |   var format = getDateFormat(date);
693 |   var from = format ? dayjs(date, { format: format }) : null;
694 |   var diff = from ? dayjs().diff(from, 'years') : null;
695 |   var years = is(diff, 'Number') && !isNaN(diff) ? diff : null;
696 | 
697 |   return years
698 | };
699 | 
700 | 
701 | /**
702 |  * Formata uma data 'YYYY-MM-DD' ou 'DD-MM-YYYY' em 'DD/MM/YYYY'. Transforma
703 |  * a data em 'YYYY-MM-DD' caso o segundo parâmetro seja "true".
704 |  *
705 |  * @example ```
706 |  * ('21-12-2006') => '21/12/2006'
707 |  * ('2006-12-21') => '21/12/2006'
708 |  * ('21/12/2006') => '21/12/2006'
709 |  * ('21/12/2006', true) => '2006-12-21'
710 |  * ('2006-12-21', true) => '2006-12-21'
711 |  * ('2006/12/21') => null
712 |  * ```
713 |  *
714 |  * @param {String} date
715 |  * @param {{ from: String, to: String, UTC: Boolean }} [options]
716 |  * @returns {String}
717 |  */
718 | 
719 | var toDate = function (date, ref) {
720 |   if ( ref === void 0 ) ref = {};
721 |   var to = ref.to; if ( to === void 0 ) to = 'DD/MM/YYYY';
722 |   var from = ref.from; if ( from === void 0 ) from = getDateFormat(date);
723 |   var isUTC = ref.UTC; if ( isUTC === void 0 ) isUTC = false;
724 | 
725 |   var isValid = isDate(date, from);
726 |   if (!isValid) { return null }
727 | 
728 |   var formatted = isUTC
729 |     ? dayjs(date, (from ? { format: from } : {})).utc()
730 |     : dayjs(date, (from ? { format: from } : {}));
731 | 
732 |   // const formatted = dayjs(date, { format: from, utc: isUTC })
733 | 
734 |   return formatted.format(to)
735 | };
736 | 
737 | 
738 | var format = Object.freeze({
739 | 	toCPF: toCPF,
740 | 	toRG: toRG,
741 | 	toInterval: toInterval,
742 | 	toEmpty: toEmpty,
743 | 	toPhone: toPhone,
744 | 	toClean: toClean,
745 | 	toSlug: toSlug,
746 | 	toCEP: toCEP,
747 | 	toMoney: toMoney,
748 | 	toMilliseconds: toMilliseconds,
749 | 	toHours: toHours,
750 | 	toDays: toDays,
751 | 	toYears: toYears,
752 | 	toDate: toDate
753 | });
754 | 
755 | /**
756 |  * @param {Object} -
757 |  */
758 | var Alignable = function (ref) {
759 |   if ( ref === void 0 ) ref = {};
760 |   var cols = ref.cols; if ( cols === void 0 ) cols = 'cols';
761 | 
762 |   return ({
763 |   props: {
764 |     align: {
765 |       type: String,
766 |       default: 'left',
767 |       validator: isAlignment
768 |     }
769 |   },
770 | 
771 |   methods: {
772 |     /**
773 |      * Get column's alignment.
774 |      * @param {number} index
775 |      * @returns {('right'|'left'|'center')}
776 |      */
777 |     $getAlignment: function $getAlignment (index) {
778 |       var col = this[cols][index];
779 |       var alignment = getProperty('align', [col, this._props], isAlignment);
780 |       return alignment
781 |     }
782 |   }
783 | });
784 | };
785 | 
786 | function __async(g){return new Promise(function(s,j){function c(a,x){try{var r=g[x?"throw":"next"](a);}catch(e){j(e);return}r.done?s(r.value):Promise.resolve(r.value).then(c,d);}function d(e){c(e,1);}c();})}
787 | 
788 | /**
789 |  * Adiciona o dado isLoading com true, que assim que o componente e montado
790 |  * e a action e executada ele passa a ser false.
791 |  *
792 |  * @param {function(Vue): Promise} action - Action a ser executada, recebe
793 |  * o contexto do componente como parametro e deve retornar uma Promise.
794 |  *
795 |  */
796 | var Loadable = function (action) { return ({
797 |   data: function data () { return { isLoading: false } },
798 | 
799 |   mounted: function mounted () {return __async(function*(){
800 |     var loaderFn = action || this.load;
801 |     var isLoadable = is(loaderFn, 'Function');
802 | 
803 |     if (!isLoadable) { return }
804 | 
805 |     this.isLoading = true;
806 |     yield Promise.resolve(loaderFn.call(this));
807 |     this.isLoading = false;
808 |   }.call(this))}
809 | }); };
810 | 
811 | /**
812 |  *
813 |  */
814 | var MediaQuery = {
815 |   data: function data () {
816 |     return {
817 |       matchMedia: window.matchMedia('(max-width: 1023px)'),
818 |       isMobile: false
819 |     }
820 |   },
821 |   methods: {
822 |     setBreakpoint: function setBreakpoint () {
823 |       this.isMobile = this.matchMedia && this.matchMedia.matches;
824 |     }
825 |   },
826 |   beforeDestroy: function beforeDestroy () {
827 |     this.matchMedia.removeListener(this.setBreakpoint);
828 |   },
829 |   mounted: function mounted () {
830 |     this.matchMedia.addListener(this.setBreakpoint);
831 |     this.setBreakpoint();
832 |   }
833 | };
834 | 
835 | /**
836 |  * Resolve o problema das propriedades não inicializadas que não poderiam ser
837 |  * observadas.
838 |  * @param {{}} template
839 |  */
840 | var ObservableFix = function (template) {
841 |   if ( template === void 0 ) template = {};
842 | 
843 |   return ({
844 |   props: {
845 |     data: {
846 |       type: Object,
847 |       default: function () { return Object.assign({}, template); }
848 |     }
849 |   },
850 |   data: function data () {
851 |     return {
852 |       selected: Object.assign({}, template)
853 |     }
854 |   },
855 |   watch: {
856 |     data: function data () {
857 |       this.cloneData();
858 |     }
859 |   },
860 |   methods: {
861 |     cloneData: function cloneData () {
862 |       this.selected = Object.assign({}, template, this.data);
863 |     }
864 |   },
865 |   mounted: function mounted () {
866 |     this.cloneData();
867 |   }
868 | });
869 | };
870 | 
871 | /*
872 |   - 'Shadowed' Vue mixin is suposed to be used together with Sass 'shadowed' sass mixin.
873 | 
874 |   - Import the Vue mixin in your component and place a ref="shadowed" in the element
875 |     that you would like to have a shadowed scroll behavior.
876 | 
877 |   - The element must have a wrapper div (father element) for the mixin to work properly.
878 | 
879 |   - Place a @include shadowed($shadow-size) in the wrapper element (style section)
880 | */
881 | 
882 | var Shadowed = function (refName) {
883 |   if ( refName === void 0 ) refName = 'shadowed';
884 | 
885 |   return ({
886 |   data: function data () {
887 |     return {
888 |       upperShadow: false,
889 |       bottomShadow: false
890 |     }
891 |   },
892 | 
893 |   watch: {
894 |     upperShadow: function upperShadow (val) {
895 |       if (val) {
896 |         this.shadowedElement.classList.add('-upper-shadow');
897 |       } else {
898 |         this.shadowedElement.classList.remove('-upper-shadow');
899 |       }
900 |     },
901 |     bottomShadow: function bottomShadow (val) {
902 |       if (val) {
903 |         this.shadowedElement.classList.add('-bottom-shadow');
904 |       } else {
905 |         this.shadowedElement.classList.remove('-bottom-shadow');
906 |       }
907 |     }
908 |   },
909 | 
910 |   computed: {
911 |     shadowedElement: function shadowedElement () {
912 |       return this.$refs[refName].hasOwnProperty('$el') ?
913 |         this.$refs[refName].$el : this.$refs[refName]
914 |     }
915 |   },
916 | 
917 |   methods: {
918 |     toggleScrollShadow: function toggleScrollShadow () {
919 |       var ref = this.shadowedElement;
920 |       var scrollTop = ref.scrollTop;
921 |       var scrollHeight = ref.scrollHeight;
922 |       var clientHeight = ref.clientHeight;
923 | 
924 |       this.upperShadow = scrollTop > 0;
925 |       this.bottomShadow = scrollHeight > (clientHeight + scrollTop);
926 |     }
927 |   },
928 | 
929 |   beforeUpdate: function beforeUpdate () {
930 |     this.$nextTick(this.toggleScrollShadow);
931 |   },
932 | 
933 |   mounted: function mounted () {
934 |     this.$nextTick(this.toggleScrollShadow);
935 |     window.addEventListener('resize', this.toggleScrollShadow);
936 |     this.shadowedElement.addEventListener('scroll', this.toggleScrollShadow);
937 |   },
938 | 
939 |   beforeDestroy: function beforeDestroy () {
940 |     window.removeEventListener('resize', this.toggleScrollShadow);
941 |     this.shadowedElement.removeEventListener('scroll', this.toggleScrollShadow);
942 |   }
943 | });
944 | };
945 | 
946 | 
947 | 
948 | var index$2 = Object.freeze({
949 | 	Alignable: Alignable,
950 | 	Loadable: Loadable,
951 | 	MediaQuery: MediaQuery,
952 | 	ObservableFix: ObservableFix,
953 | 	Shadowed: Shadowed
954 | });
955 | 
956 | /**
957 |  * Opções do plugin.
958 |  * @typedef {Object} Options
959 |  * @property {Boolean} formatters
960 |  * @property {Boolean} formatFilters
961 |  * @property {Boolean} validators
962 |  */
963 | 
964 | /**
965 |  * Adiciona as funções auxiliares definidas no protótipo do Vue, e
966 |  * consequentemente aos componentes.
967 |  * @param {Vue} Vue
968 |  * @param {Options} options
969 |  */
970 | 
971 | var index = function (Vue, options) {
972 |   if ( options === void 0 ) options = {};
973 | 
974 |   if (options.formatters) {
975 |     Vue.prototype.$format = format;
976 |   }
977 | 
978 |   if (options.formatFilters) {
979 |     Object.keys(format).forEach(function (name) {
980 |       var handler = format[name];
981 |       Vue.filter(name, handler);
982 |     });
983 |   }
984 | 
985 |   if (options.validators) {
986 |     Vue.prototype.$validate = validate;
987 |   }
988 | };
989 | 
990 | export { validate, format, index$2 as mixin, index$1 as helpers };
991 | export default index;
992 | 


--------------------------------------------------------------------------------
/jest.config.js:
--------------------------------------------------------------------------------
1 | module.exports = {
2 |   transform: { '^.+\\.js$': 'babel-jest' },
3 |   moduleFileExtensions: [ 'js' ],
4 |   verbose: true
5 | }


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "vue-convenia-util",
 3 |   "version": "1.0.0",
 4 |   "description": "Plugin com validações, formatações e filtros para projetos Vue.",
 5 |   "keywords": [
 6 |     "convenia",
 7 |     "vue",
 8 |     "vue-plugin",
 9 |     "validation",
10 |     "format"
11 |   ],
12 |   "author": {
13 |     "name": "Vitor Cavalcanti",
14 |     "url": "https://vitorluizc.github.io/",
15 |     "email": "vitorluizc@outlook.com"
16 |   },
17 |   "license": "MIT",
18 |   "main": "./dist/vue-convenia-util.common.js",
19 |   "module": "./dist/vue-convenia-util.es.js",
20 |   "watch": {
21 |     "build": "src/*.js",
22 |     "test": "{src,test}/*.js"
23 |   },
24 |   "scripts": {
25 |     "start": "npm-watch",
26 |     "test": "jest",
27 |     "build": "bili ./src/index.js --format es --format cjs --exports named",
28 |     "prepare": "npm run build && npm run test"
29 |   },
30 |   "devDependencies": {
31 |     "@babel/core": "^7.4.4",
32 |     "@babel/plugin-syntax-dynamic-import": "^7.2.0",
33 |     "@babel/plugin-transform-modules-commonjs": "^7.4.4",
34 |     "@babel/preset-env": "^7.4.4",
35 |     "babel-jest": "^24.8.0",
36 |     "bili": "^0.19.0",
37 |     "jest": "^24.8.0",
38 |     "npm-watch": "^0.3.0",
39 |     "poi": "^9.5.4",
40 |     "sinon": "^4.1.2",
41 |     "standard": "^10.0.3",
42 |     "vue": "^2.5.9"
43 |   },
44 |   "standard": {
45 |     "ignore": [
46 |       "dist/vue-convenia-util.common.js",
47 |       "dist/vue-convenia-util.es.js"
48 |     ]
49 |   },
50 |   "dependencies": {
51 |     "dayjs-ext": "^2.2.0",
52 |     "normalize-text": "^0.2.0"
53 |   }
54 | }
55 | 


--------------------------------------------------------------------------------
/src/helpers/date.js:
--------------------------------------------------------------------------------
 1 | import dayjs from 'dayjs-ext'
 2 | import { is } from './index'
 3 | 
 4 | 
 5 | /**
 6 |  * Obtém o formato da data ou null se não for possível identificar.
 7 |  * @example ```
 8 |  * ('2000-21-12') => ['YYYY-DD-MM', 'YYYY-MM-DD HH:mm:ss']
 9 |  * ('21-12-2000') => ['DD-MM-YYYY', 'DD-MM-YYYY HH:mm:ss']
10 |  * ('21/12/2000 23:59:18') => ['DD/MM/YYYY', 'DD/MM/YYYY HH:mm:ss']
11 |  * ('2000/12/21') => null
12 |  * ```
13 |  * @param {String} date
14 |  * @returns {String}
15 |  */
16 | export const getDateFormat = (date) => {
17 |   const isValid = is(date, 'String') && date.trim().length >= 10
18 |   const format = !isValid ? null
19 |     : /^\d{4}-\d{2}-\d{2}$/.test(date) ? 'YYYY-MM-DD'
20 |     : /^\d{2}-\d{2}-\d{4}$/.test(date) ? 'DD-MM-YYYY'
21 |     : /^\d{2}\/\d{2}\/\d{4}$/.test(date) ? 'DD/MM/YYYY'
22 |     : null
23 | 
24 |   return format
25 | }
26 | 
27 | /**
28 |  * Receives a date in US string format or unix timestamp and returns
29 |  * it in brazillian format.
30 |  *
31 |  * @param {String|Number} value - The date to be formatted.
32 |  * @returns {String} - the formmated date.
33 |  *
34 |  */
35 | export const formatDateBR = value => {
36 |   if (!value) return ''
37 | 
38 |   const date = typeof value === 'string'
39 |     ? new Date(`${value}T00:00:00`)
40 |     : new Date(value)
41 | 
42 |   return date.toLocaleDateString('pt-BR')
43 | }
44 | 
45 | 
46 | /**
47 |  * Receives a date in BR string format and returns its US equivalent
48 |  *
49 |  * @param {String} value - The date to be formatted.
50 |  * @returns {String} - the formmated date.
51 |  *
52 |  */
53 | export const formatDateUS = date => {
54 |   if (!date) return ''
55 | 
56 |   return date.substr(0, 10).split('/').reverse().join('-')
57 | }
58 | 
59 | 
60 | /**
61 |  * Calculates a person's age given a birthday.
62 |  *
63 |  * @param {Date} birthday - A Date instance representing the birthday.
64 |  * @returns {Number} - The person's age.
65 |  *
66 |  */
67 | export const calculateAge = (birthday) => {
68 |   const ageDifMs = Date.now() - birthday.getTime();
69 |   const ageDate = new Date(ageDifMs);
70 | 
71 |   return Math.abs(ageDate.getUTCFullYear() - 1970);
72 | }
73 | 


--------------------------------------------------------------------------------
/src/helpers/formatters.js:
--------------------------------------------------------------------------------
  1 | import dayjs from 'dayjs-ext'
  2 | import customParseFormat from 'dayjs-ext/plugin/customParseFormat'
  3 | import 'dayjs-ext/locale/pt-br'
  4 | 
  5 | import normalize, { normalizeDiacritics } from 'normalize-text'
  6 | import { getDateFormat, replace, is, isDate } from './index'
  7 | 
  8 | dayjs.extend(customParseFormat)
  9 | dayjs.locale('pt-br')
 10 | 
 11 | 
 12 | /**
 13 |  * Transforma um valor para a formatação de CPF.
 14 |  *
 15 |  * @example ```
 16 |  * ('00000000000') => '000.000.000-00'
 17 |  * ('12345678') => '123.456.78'
 18 |  * ('Abacaxi') => null
 19 |  * ```
 20 |  *
 21 |  * @param {String} cpf
 22 |  * @returns {String}
 23 |  */
 24 | 
 25 | export const toCPF = (cpf) => {
 26 |   const isValid = is(cpf, 'String')
 27 |   const formatted = !isValid ? null : replace(cpf, [
 28 |     [/\D/g, ''],
 29 |     [/(\d{3})(\d)/, '$1.$2'],
 30 |     [/(\d{3})(\d)/, '$1.$2'],
 31 |     [/(\d{3})(\d{1,2})$/, '$1-$2']
 32 |   ])
 33 |   return formatted
 34 | }
 35 | 
 36 | 
 37 | /**
 38 |  * Transforma um valor para a formatação de RG.
 39 |  *
 40 |  * @example ```
 41 |  * ('000000000') => '00.000.000-0'
 42 |  * ('12345678') => '123.456.78'
 43 |  * ('Abacaxi') => null
 44 |  * ```
 45 |  *
 46 |  * @param {String} rg
 47 |  * @returns {String}
 48 |  */
 49 | 
 50 | export const toRG = (rg) => {
 51 |   const isValid = is(rg, 'String')
 52 |   const formatted = !isValid ? null : replace(rg.toUpperCase(), [
 53 |     [/[^\d|A|B|X]/g, ''],
 54 |     [/(\d{2})(\d)/, '$1.$2'],
 55 |     [/(\d{3})(\d)/, '$1.$2'],
 56 |     [/(\d{3})([\d|A|B|X]{1})$/, '$1-$2']
 57 |   ])
 58 |   return formatted
 59 | }
 60 | 
 61 | 
 62 | /**
 63 |  * Usa a formatação de datas para retornar um intervalo.
 64 |  *
 65 |  * @example ```
 66 |  * ({ start: '21-12-2006', end: '31-12-2006' }) => '21/12/2006 a 31/12/2006'
 67 |  * ```
 68 |  *
 69 |  * @param {{ start: String, end: String }} dates
 70 |  * @param {{ from: String, to: String }} [options]
 71 |  * @returns {String}
 72 |  */
 73 | 
 74 | export const toInterval = (dates, options = {}) => {
 75 |   const { start, end } = dates
 76 |   const interval = `${toDate(start, options)} a ${toDate(end, options)}`
 77 |   return interval
 78 | }
 79 | 
 80 | 
 81 | /**
 82 |  * Faz uma verificação simples e coloca o caractere para vazio caso o valor seja
 83 |  * vazio (null, undefined, '').
 84 |  *
 85 |  * @param {*} value
 86 |  * @param {String} char
 87 |  * @returns {String}
 88 |  */
 89 | 
 90 | export const toEmpty = (value, char = '-') => value || char
 91 | 
 92 | 
 93 | /**
 94 |  * Formata um valor para o formato de telefone.
 95 |  *
 96 |  * @param {String} value
 97 |  * @returns {String}
 98 |  */
 99 | 
100 | export const toPhone = (value) => {
101 |   const isValid = is(value, 'String')
102 |   const formatted = !isValid ? null : replace(value, [
103 |     [/\D/g, ''],
104 |     [/(\d{1,2})/, '($1'],
105 |     [/(\(\d{2})(\d{1,4})/, '$1) $2'],
106 |     [/( \d{4})(\d{1,4})/, '$1-$2'],
107 |     [/( \d{4})(?:-)(\d{1})(\d{4})/, '$1$2-$3']
108 |   ])
109 |   return formatted
110 | }
111 | 
112 | 
113 | /**
114 |  * Formata o texto removendo seus acentos.
115 |  *
116 |  * @example ```
117 |  * ('Vítor') => 'Vitor'
118 |  * ('Olá, tudo bem com você?') => 'Ola, tudo bem com voce?'
119 |  * ```
120 |  *
121 |  * @param {String} value
122 |  * @returns {String}
123 |  */
124 | 
125 | export const toClean = (value) => {
126 |   const isValid = is(value, 'String')
127 |   const formatted = !isValid ? null : normalizeDiacritics(value)
128 |   return formatted
129 | }
130 | 
131 | 
132 | /**
133 |  * Formata um texto o transformando em _kebab-case_.
134 |  *
135 |  * @param {String} value
136 |  * @returns {String}
137 |  */
138 | 
139 | export const toSlug = (value) => {
140 |   if (!is(value, 'String')) { // Short-circuit to handle all non-string values
141 |     return null               // and return null.
142 |   }
143 |   const formatted = replace(normalize(value), [
144 |     [/&/g, '-e-'],
145 |     [/\W/g, '-'],
146 |     [/--+/g, '-'],
147 |     [/(^-+)|(-+$)/, '']
148 |   ])
149 |   return formatted
150 | }
151 | 
152 | 
153 | /**
154 |  * Formata um valor para CEP.
155 |  *
156 |  * @param {String} value
157 |  * @returns {Boolean}
158 |  */
159 | 
160 | export const toCEP = (value) => {
161 |   const isValid = is(value, 'String')
162 |   const formatted = !isValid ? null : replace(value, [
163 |     [/\D/g, ''],
164 |     [/(\d{5})(\d{1,3})/, '$1-$2']
165 |   ])
166 |   return formatted
167 | }
168 | 
169 | 
170 | /**
171 |  * Formata um valor para a formatação de moeda.
172 |  *
173 |  * @example ```
174 |  * ('1200') => 'R$ 1.200,00'
175 |  * (15.50) => 'R$ 15,50'
176 |  * ('Abacaxi') => null
177 |  * ```
178 |  *
179 |  * @param {String} number
180 |  * @returns {String}
181 |  */
182 | 
183 | export const toMoney = (number) => {
184 |   const isValid = is(number, 'Number') || (is(number, 'String') && !isNaN(number))
185 |   const formatted = !isValid ? null : 'R$ ' + replace((+number).toFixed(2), [
186 |     ['.', ','],
187 |     [/(\d)(?=(\d{3})+(?!\d))/g, '$1.']
188 |   ])
189 |   return formatted
190 | }
191 | 
192 | // Date Formaters
193 | // --------------
194 | 
195 | /**
196 |  * Converts hours to milliseconds
197 |  *
198 |  * @param {Number} value - The time in hours.
199 |  * @returns {}
200 |  */
201 | 
202 | export const toMilliseconds = (value) => {
203 |   if (Number.isInteger(value)) return value
204 | 
205 |   const parsedValue = value.replace('hs', '').split(':')
206 |   const hours = +(parsedValue[0] || 0) * 3600000
207 |   const minutes = (parsedValue[1] || '').length < 2
208 |     ? +(`${parsedValue[1] || 0}0`) * 60000
209 |     : +(parsedValue[1] || 0) * 60000
210 | 
211 |   return hours + minutes
212 | }
213 | 
214 | /**
215 |  * Converts milliseconds to hours
216 |  *
217 |  * @param {Number} ms - The time in miliseconds.
218 |  * @returns {String} - The formmated time in `${hours}:${minutes}`.
219 |  */
220 | export const toHours = (ms) => {
221 |   const hours = Math.floor(ms / 3600000)
222 |   const minutes = Math.floor((ms % 3600000) / 3600000 * 60)
223 | 
224 |   return `${hours}:${minutes || '00'}`
225 | }
226 | 
227 | 
228 | /**
229 |  * Formata para o formato de dias.
230 |  *
231 |  * @example ```
232 |  * (2) => '2 dias'
233 |  * (1) => '1 dia'
234 |  * (0) => '0 dias'
235 |  * ```
236 |  *
237 |  * @param {Number} quantity
238 |  * @returns {String}
239 |  */
240 | 
241 | export const toDays = (quantity) => {
242 |   const isValid = is(quantity, 'Number') && Number.isFinite(quantity)
243 |   const days = (quantity === 1) ? '1 dia' : `${isValid ? ~~(quantity) : 0} dias`
244 |   return days
245 | }
246 | 
247 | 
248 | /**
249 |  * Obtém a quantidade de anos a partir da data.
250 |  *
251 |  * @example ```
252 |  * ('21-12-2006') => 10
253 |  * ('2000-12-21') => 16
254 |  * ('Abacaxi') => null
255 |  * ```
256 |  *
257 |  * @param {String} date
258 |  * @returns {Number}
259 |  */
260 | 
261 | export const toYears = (date) => {
262 |   const format = getDateFormat(date)
263 |   const from = format ? dayjs(date, { format }) : null
264 |   const diff = from ? dayjs().diff(from, 'years') : null
265 |   const years = is(diff, 'Number') && !isNaN(diff) ? diff : null
266 | 
267 |   return years
268 | }
269 | 
270 | 
271 | /**
272 |  * Formata uma data 'YYYY-MM-DD' ou 'DD-MM-YYYY' em 'DD/MM/YYYY'. Transforma
273 |  * a data em 'YYYY-MM-DD' caso o segundo parâmetro seja "true".
274 |  *
275 |  * @example ```
276 |  * ('21-12-2006') => '21/12/2006'
277 |  * ('2006-12-21') => '21/12/2006'
278 |  * ('21/12/2006') => '21/12/2006'
279 |  * ('21/12/2006', true) => '2006-12-21'
280 |  * ('2006-12-21', true) => '2006-12-21'
281 |  * ('2006/12/21') => null
282 |  * ```
283 |  *
284 |  * @param {String} date
285 |  * @param {{ from: String, to: String, UTC: Boolean }} [options]
286 |  * @returns {String}
287 |  */
288 | 
289 | export const toDate = (date, { to = 'DD/MM/YYYY', from = getDateFormat(date), UTC: isUTC = false } = {}) => {
290 |   const isValid = isDate(date, from)
291 |   if (!isValid) return null
292 | 
293 |   const formatted = isUTC
294 |     ? dayjs(date, (from ? { format: from } : {})).utc()
295 |     : dayjs(date, (from ? { format: from } : {}))
296 | 
297 |   // const formatted = dayjs(date, { format: from, utc: isUTC })
298 | 
299 |   return formatted.format(to)
300 | }
301 | 


--------------------------------------------------------------------------------
/src/helpers/functional.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Obtém o construtor do valor.
 3 |  * @param {*} value
 4 |  * @returns {String}
 5 |  */
 6 | export const getConstructor = (value) => {
 7 |   const string = Object.prototype.toString.call(value)
 8 |   const [ , constructor ] = /\[object (.*?)\]/.exec(string)
 9 |   return constructor
10 | }
11 | 
12 | /**
13 |  * Usando um valor inicial, encadeia uma função e retorna seu resultado.
14 |  * @param {A} initial
15 |  * @param {function(A):function} callback
16 |  * @param {Array.<*>} params
17 |  * @returns {B}
18 |  * @template A, B
19 |  */
20 | export const chain = (initial, callback, params) => {
21 |   const value = params.reduce((value, args) => {
22 |     return callback(value).apply(value, [...args])
23 |   }, initial)
24 | 
25 |   return value
26 | }
27 | 


--------------------------------------------------------------------------------
/src/helpers/get.js:
--------------------------------------------------------------------------------
 1 | import { is, defaultValidator } from './index'
 2 | 
 3 | const DELIMITER = '.'
 4 | 
 5 | /**
 6 |  * Spreads path into fields list.
 7 |  * @param {string} path
 8 |  * @returns {Array.<string>}
 9 |  */
10 | const getProperties = (path) => is(path, 'String') ? path.split(DELIMITER) : []
11 | 
12 | /**
13 |  * Deep object.
14 |  * @typedef {Object.<string, (number|boolean|string|Deep)>} Deep
15 |  */
16 | 
17 | /**
18 |  * Checks if a propety is reachable.
19 |  * @param {Deep} object
20 |  * @param {string} property
21 |  * @returns {(number|boolean|string|null)}
22 |  */
23 | const getValue = (object, property) => {
24 |   const isReachable = is(object, 'Object') && object.hasOwnProperty(property)
25 |   const value = isReachable ? object[property] : null
26 |   return value
27 | }
28 | 
29 | /**
30 |  * Get value from object path.
31 |  * @param {Deep} object
32 |  * @param {(string|Array.<string>)} path
33 |  * @returns {(number|boolean|string|null)}
34 |  */
35 | export const get = (object, path) => {
36 |   const properties = getProperties(path)
37 |   const value = properties.reduce(getValue, object)
38 |   return value
39 | }
40 | 
41 | 
42 | /**
43 |  * Get value from first object.
44 |  * @param {string} name
45 |  * @param {Deep[]} objects
46 |  * @param {function(*):boolean} [validate]
47 |  * @returns {*}
48 |  */
49 | export const getProperty = (name, objects, validate = defaultValidator) => {
50 |   const properties = objects.map((object) => get(object, name))
51 |   const property = properties.find((property) => validate(property))
52 |   return property
53 | }
54 | 
55 | export default get
56 | 


--------------------------------------------------------------------------------
/src/helpers/index.js:
--------------------------------------------------------------------------------
1 | export * from './date'
2 | export * from './formatters'
3 | export * from './functional'
4 | export * from './get'
5 | export * from './string'
6 | export * from './validators'
7 | 


--------------------------------------------------------------------------------
/src/helpers/string.js:
--------------------------------------------------------------------------------
 1 | import { get } from './index'
 2 | 
 3 | 
 4 | /**
 5 |  * @param {String} value -
 6 |  * @returns {String} -
 7 |  */
 8 | export const normalizeString = (value) => {
 9 |   return value.normalize('NFD').replace(/[\u0300-\u036f]/g, '')
10 | }
11 | 
12 | 
13 | /**
14 |  * Faz em forma de corrente o replace do texto usando os argumentos
15 |  * especificados.
16 |  *
17 |  * @param {String} text
18 |  * @param {Array.<*>} args
19 |  * @returns {String}
20 |  */
21 | export const replace = (text, args) => args
22 |   .reduce((text, [ matcher, replaceBy ]) => text.replace(matcher, replaceBy), text)
23 | 
24 | 
25 | /**
26 |  * @param {Object} entyty -
27 |  * @param {Array<string>} props -
28 |  * @returns {String} -
29 |  */
30 | export const getEntityQuery = (entity, props) => {
31 |   const entityObj = entity || {}
32 |   return props.map((prop) => {
33 |     const value = normalizeString(get(entityObj, prop) || '').toLowerCase()
34 |     return value
35 |   }).join(' ')
36 | }
37 | 
38 | 
39 | /**
40 |  * @param {String} word -
41 |  * @param {Array<string>} words -
42 |  * @returns {Booloean} -
43 |  */
44 | export const matches = (word, words) =>
45 |   (word ? words.split(word).length - 1 : 0)
46 | 
47 | 
48 | /**
49 |  * @param {Array} list -
50 |  * @param {String} strings -
51 |  * @param {Arrat} keys -
52 |  * @returns {Boolean} -
53 |  */
54 | export const findBy = (list = [], strings = '', keys = []) => {
55 |   const terms = strings.toLowerCase().split(' ')
56 | 
57 |   return list.filter(el =>
58 |     keys.some((key) => {
59 |       const text = el[key].toLowerCase()
60 | 
61 |       return terms.some(term => text.includes(term))
62 |     })
63 |   )
64 | }
65 | 


--------------------------------------------------------------------------------
/src/helpers/validators.js:
--------------------------------------------------------------------------------
  1 | import dayjs from 'dayjs-ext'
  2 | import customParseFormat from 'dayjs-ext/plugin/customParseFormat'
  3 | dayjs.extend(customParseFormat)
  4 | 
  5 | import { getDateFormat, getConstructor } from './index'
  6 | 
  7 | 
  8 | /**
  9 |  * Check value's constructor name.
 10 |  * @param {*} value
 11 |  * @param {string} constructor
 12 |  * @returns {boolean}
 13 |  */
 14 | 
 15 | export const is = (value, constructor) => {
 16 |   return Object.prototype.toString.call(value) === `[object ${constructor}]`
 17 | }
 18 | 
 19 | 
 20 | /**
 21 |  * Creates a validator function that checks is value is included in values.
 22 |  * @param {Array} values
 23 |  * @returns {function(*):boolean}
 24 |  */
 25 | const includes = (values) => (value) => values.includes(value)
 26 | 
 27 | 
 28 | /**
 29 |  * Checks if value is an alignment.
 30 |  */
 31 | const ALIGNMENTS = ['right', 'left', 'center']
 32 | export const isAlignment = includes(ALIGNMENTS)
 33 | 
 34 | 
 35 | /**
 36 |  * Checks if value is a list of objects.
 37 |  * @param {*} value
 38 |  * @returns {boolean}
 39 |  */
 40 | export const isContent = (value) => {
 41 |   const isObject = (value) => is(value, 'Object')
 42 |   const isContent = is(value, 'Array') && value.every(isObject)
 43 |   return isContent
 44 | }
 45 | 
 46 | 
 47 | /**
 48 |  *
 49 |  */
 50 | export const isCPF = (cpf) => {
 51 |   const isInvalid = (cpf, rest, pos) => rest !== parseInt(cpf.substring(pos, pos + 1))
 52 | 
 53 |   const sumDigit = (cpf, digit) => 11 - (cpf.substring(0, digit).split('').reduce((acc, curr, index) => {
 54 |     acc += parseInt(curr) * ((digit + 1) - index)
 55 |     return acc
 56 |   }, 0) % 11)
 57 | 
 58 |   const getRest = sum => sum > 9 ? 0 : sum
 59 | 
 60 |   if (!is(cpf, 'String')) return false
 61 | 
 62 |   cpf = cpf.replace(/[\D]/gi, '')
 63 | 
 64 |   if (!cpf.match(/^\d+$/)) return false
 65 | 
 66 |   if (cpf === '00000000000' || cpf.length !== 11) return false
 67 | 
 68 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 9)), 9)) return false
 69 | 
 70 |   if (isInvalid(cpf, getRest(sumDigit(cpf, 10)), 10)) return false
 71 | 
 72 |   return true
 73 | }
 74 | 
 75 | 
 76 | /**
 77 |  * Valida se é uma data com o formato especificado ou, quando não especificado,
 78 |  * valida se é um dos formatos 'DD/MM/YYYY', 'DD-MM-YYYY' e 'YYYY-MM-DD'.
 79 |  *
 80 |  * @example ```
 81 |  * ('3/102/2006') => false
 82 |  * ('31/02/2006') => false
 83 |  * ('21/12/2006') => true
 84 |  * ('21/12/2006', 'YYYY-MM-DD') => false
 85 |  * ```
 86 |  *
 87 |  * @param {String} date
 88 |  * @param {String} [format]
 89 |  * @returns {Boolean}
 90 |  */
 91 | 
 92 | export const isDate = (date, format = null) => {
 93 |   const from = format || getDateFormat(date)
 94 | 
 95 |   // There's a lil' bug in dayjs where dayjs(null).isValid() returns false
 96 |   // but dayjs(undefined).isValid() returns true.
 97 | 
 98 |   const isValid = from
 99 |     ? dayjs(date, { format: from }).isValid()
100 |     : dayjs(date || null).isValid()
101 | 
102 |   return isValid
103 | }
104 | 
105 | 
106 | /**
107 |  * Valida se o valor é um CPNJ válido.
108 |  * @param {String} value
109 |  * @returns {Boolean}
110 |  */
111 | export const isCNPJ = (value) => {
112 |   if (!is(value, 'String')) {
113 |     return false
114 |   }
115 | 
116 |   const digits = value.replace(/[\D]/gi, '')
117 | 
118 |   let dig1 = 0
119 |   let dig2 = 0
120 | 
121 |   const validation = [6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 2]
122 | 
123 |   const digito = parseInt(digits.charAt(12) + digits.charAt(13))
124 | 
125 |   const getRest = dig => (((dig % 11) < 2) ? 0 : (11 - (dig % 11)))
126 | 
127 |   validation.map((v, i) => {
128 |     dig1 += (i > 0 ? (digits.charAt(i - 1) * v) : 0)
129 |     dig2 += digits.charAt(i) * v
130 |   })
131 | 
132 |   dig1 = getRest(dig1)
133 |   dig2 = getRest(dig2)
134 | 
135 |   return (((dig1 * 10) + dig2) === digito)
136 | }
137 | 
138 | 
139 | /**
140 |  * Valida, de forma simples*, se o valor é um email válido.
141 |  * @param {String} value
142 |  * @returns {Boolean}
143 |  */
144 | export const isEmail = (value) => {
145 |   const isValid = is(value, 'String') && /^.+@.+\..+$/.test(value)
146 |   return isValid
147 | }
148 | 
149 | 
150 | /**
151 |  * Checks if value is not null
152 |  * @param {*} value
153 |  * @returns {boolean}
154 |  */
155 | export const defaultValidator = (value) => !is(value, 'Null')
156 | 


--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
 1 | import * as format from './helpers/formatters'
 2 | import * as validate from './helpers/validators'
 3 | import * as helpers from './helpers/index'
 4 | import * as mixin from './mixins/index'
 5 | 
 6 | /**
 7 |  * Opções do plugin.
 8 |  * @typedef {Object} Options
 9 |  * @property {Boolean} formatters
10 |  * @property {Boolean} formatFilters
11 |  * @property {Boolean} validators
12 |  */
13 | 
14 | /**
15 |  * Adiciona as funções auxiliares definidas no protótipo do Vue, e
16 |  * consequentemente aos componentes.
17 |  * @param {Vue} Vue
18 |  * @param {Options} options
19 |  */
20 | 
21 | export default (Vue, options = {}) => {
22 |   if (options.formatters) {
23 |     Vue.prototype.$format = format
24 |   }
25 | 
26 |   if (options.formatFilters) {
27 |     Object.keys(format).forEach(name => {
28 |       const handler = format[name]
29 |       Vue.filter(name, handler)
30 |     })
31 |   }
32 | 
33 |   if (options.validators) {
34 |     Vue.prototype.$validate = validate
35 |   }
36 | }
37 | 
38 | export {
39 |   validate,
40 |   format,
41 |   mixin,
42 |   helpers
43 | }
44 | 


--------------------------------------------------------------------------------
/src/mixins/Alignable.js:
--------------------------------------------------------------------------------
 1 | import { getProperty, isAlignment } from '../helpers/index'
 2 | 
 3 | /**
 4 |  * @param {Object} -
 5 |  */
 6 | export const Alignable = ({ cols = 'cols' } = {}) => ({
 7 |   props: {
 8 |     align: {
 9 |       type: String,
10 |       default: 'left',
11 |       validator: isAlignment
12 |     }
13 |   },
14 | 
15 |   methods: {
16 |     /**
17 |      * Get column's alignment.
18 |      * @param {number} index
19 |      * @returns {('right'|'left'|'center')}
20 |      */
21 |     $getAlignment (index) {
22 |       const col = this[cols][index]
23 |       const alignment = getProperty('align', [col, this._props], isAlignment)
24 |       return alignment
25 |     }
26 |   }
27 | })
28 | 
29 | export default Alignable
30 | 


--------------------------------------------------------------------------------
/src/mixins/Loadable.js:
--------------------------------------------------------------------------------
 1 | import { is } from '../helpers/index'
 2 | 
 3 | /**
 4 |  * Adiciona o dado isLoading com true, que assim que o componente e montado
 5 |  * e a action e executada ele passa a ser false.
 6 |  *
 7 |  * @param {function(Vue): Promise} action - Action a ser executada, recebe
 8 |  * o contexto do componente como parametro e deve retornar uma Promise.
 9 |  *
10 |  */
11 | export const Loadable = (action) => ({
12 |   data () { return { isLoading: false } },
13 | 
14 |   async mounted () {
15 |     const loaderFn = action || this.load
16 |     const isLoadable = is(loaderFn, 'Function')
17 | 
18 |     if (!isLoadable) return
19 | 
20 |     this.isLoading = true
21 |     await Promise.resolve(loaderFn.call(this))
22 |     this.isLoading = false
23 |   }
24 | })
25 | 
26 | export default Loadable
27 | 


--------------------------------------------------------------------------------
/src/mixins/MediaQuery.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  *
 3 |  */
 4 | export const MediaQuery = {
 5 |   data () {
 6 |     return {
 7 |       matchMedia: window.matchMedia('(max-width: 1023px)'),
 8 |       isMobile: false
 9 |     }
10 |   },
11 |   methods: {
12 |     setBreakpoint () {
13 |       this.isMobile = this.matchMedia && this.matchMedia.matches
14 |     }
15 |   },
16 |   beforeDestroy () {
17 |     this.matchMedia.removeListener(this.setBreakpoint)
18 |   },
19 |   mounted () {
20 |     this.matchMedia.addListener(this.setBreakpoint)
21 |     this.setBreakpoint()
22 |   }
23 | }
24 | 
25 | export default MediaQuery
26 | 


--------------------------------------------------------------------------------
/src/mixins/ObservableFix.js:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Resolve o problema das propriedades não inicializadas que não poderiam ser
 3 |  * observadas.
 4 |  * @param {{}} template
 5 |  */
 6 | export const ObservableFix = (template = {}) => ({
 7 |   props: {
 8 |     data: {
 9 |       type: Object,
10 |       default: () => Object.assign({}, template)
11 |     }
12 |   },
13 |   data () {
14 |     return {
15 |       selected: Object.assign({}, template)
16 |     }
17 |   },
18 |   watch: {
19 |     data () {
20 |       this.cloneData()
21 |     }
22 |   },
23 |   methods: {
24 |     cloneData () {
25 |       this.selected = Object.assign({}, template, this.data)
26 |     }
27 |   },
28 |   mounted () {
29 |     this.cloneData()
30 |   }
31 | })
32 | 
33 | export default ObservableFix
34 | 


--------------------------------------------------------------------------------
/src/mixins/Shadowed.js:
--------------------------------------------------------------------------------
 1 | /*
 2 |   - 'Shadowed' Vue mixin is suposed to be used together with Sass 'shadowed' sass mixin.
 3 | 
 4 |   - Import the Vue mixin in your component and place a ref="shadowed" in the element
 5 |     that you would like to have a shadowed scroll behavior.
 6 | 
 7 |   - The element must have a wrapper div (father element) for the mixin to work properly.
 8 | 
 9 |   - Place a @include shadowed($shadow-size) in the wrapper element (style section)
10 | */
11 | 
12 | export const Shadowed = (refName = 'shadowed') => ({
13 |   data () {
14 |     return {
15 |       upperShadow: false,
16 |       bottomShadow: false
17 |     }
18 |   },
19 | 
20 |   watch: {
21 |     upperShadow (val) {
22 |       if (val) {
23 |         this.shadowedElement.classList.add('-upper-shadow')
24 |       } else {
25 |         this.shadowedElement.classList.remove('-upper-shadow')
26 |       }
27 |     },
28 |     bottomShadow (val) {
29 |       if (val) {
30 |         this.shadowedElement.classList.add('-bottom-shadow')
31 |       } else {
32 |         this.shadowedElement.classList.remove('-bottom-shadow')
33 |       }
34 |     }
35 |   },
36 | 
37 |   computed: {
38 |     shadowedElement () {
39 |       return this.$refs[refName].hasOwnProperty('$el') ?
40 |         this.$refs[refName].$el : this.$refs[refName]
41 |     }
42 |   },
43 | 
44 |   methods: {
45 |     toggleScrollShadow () {
46 |       const { scrollTop, scrollHeight, clientHeight } = this.shadowedElement
47 | 
48 |       this.upperShadow = scrollTop > 0
49 |       this.bottomShadow = scrollHeight > (clientHeight + scrollTop)
50 |     }
51 |   },
52 | 
53 |   beforeUpdate () {
54 |     this.$nextTick(this.toggleScrollShadow)
55 |   },
56 | 
57 |   mounted () {
58 |     this.$nextTick(this.toggleScrollShadow)
59 |     window.addEventListener('resize', this.toggleScrollShadow)
60 |     this.shadowedElement.addEventListener('scroll', this.toggleScrollShadow)
61 |   },
62 | 
63 |   beforeDestroy () {
64 |     window.removeEventListener('resize', this.toggleScrollShadow)
65 |     this.shadowedElement.removeEventListener('scroll', this.toggleScrollShadow)
66 |   }
67 | })
68 | 
69 | export default Shadowed
70 | 


--------------------------------------------------------------------------------
/src/mixins/index.js:
--------------------------------------------------------------------------------
1 | export * from './Alignable'
2 | export * from './Loadable'
3 | export * from './MediaQuery'
4 | export * from './ObservableFix'
5 | export * from './Shadowed'
6 | 


--------------------------------------------------------------------------------
/test/formatters.spec.js:
--------------------------------------------------------------------------------
  1 | import { format } from '../src/index'
  2 | 
  3 | test('toCPF: Formata um valor, ou parte dele para CPF', () => {
  4 |   expect(format.toCPF('00000000000')).toBe('000.000.000-00')
  5 |   expect(format.toCPF('00000000')).toBe('000.000.00')
  6 |   expect(format.toCPF('366.418.768-70')).toBe('366.418.768-70')
  7 | })
  8 | 
  9 | test('toCPF: Não formata valores inválidos', () => {
 10 |   expect(format.toCPF(undefined)).toBeNull()
 11 |   expect(format.toCPF(null)).toBeNull()
 12 | })
 13 | 
 14 | test('toRG: Formata um valor, ou parte dele, para RG', () => {
 15 |   expect(format.toRG('000000000')).toBe('00.000.000-0')
 16 |   expect(format.toRG('00000000a')).toBe('00.000.000-A')
 17 |   expect(format.toRG('00000000B')).toBe('00.000.000-B')
 18 |   expect(format.toRG('00000000x')).toBe('00.000.000-X')
 19 |   expect(format.toRG('000000')).toBe('00.000.0')
 20 | })
 21 | 
 22 | test('toRG: Não formata valores inválidos', () => {
 23 |   expect(format.toRG(undefined)).toBeNull()
 24 |   expect(format.toRG(null)).toBeNull()
 25 | })
 26 | 
 27 | test('toMoney: Formata um valor para moeda', () => {
 28 |   expect(format.toMoney(1200.504)).toBe('R$ 1.200,50')
 29 |   expect(format.toMoney(0)).toBe('R$ 0,00')
 30 |   expect(format.toMoney('-74.89')).toBe('R$ -74,89')
 31 | })
 32 | 
 33 | test('toMoney: Não formata valores inválidos', () => {
 34 |   expect(format.toMoney(null)).toBeNull()
 35 |   expect(format.toMoney(undefined)).toBeNull()
 36 |   expect(format.toMoney([])).toBeNull()
 37 | })
 38 | 
 39 | test('toYears: Obtém em anos a diferença de uma data', () => {
 40 |   expect(format.toYears('28/03/1996')).toBe(23)
 41 |   expect(format.toYears('1979-04-13')).toBe(40)
 42 | })
 43 | 
 44 | test('toYears: Não formata valores inválidos', () => {
 45 |   expect(format.toYears(null)).toBeNull()
 46 |   expect(format.toYears(undefined)).toBeNull()
 47 |   expect(format.toYears('21/15/2017')).toBeNull()
 48 | })
 49 | 
 50 | test('toDays: Formata um número para sua quantidade em dias', () => {
 51 |   expect(format.toDays(null)).toBe('0 dias')
 52 |   expect(format.toDays(undefined)).toBe('0 dias')
 53 |   expect(format.toDays('quatro')).toBe('0 dias')
 54 |   expect(format.toDays(0)).toBe('0 dias')
 55 |   expect(format.toDays(4.5)).toBe('4 dias')
 56 |   expect(format.toDays(1)).toBe('1 dia')
 57 |   expect(format.toDays(2)).toBe('2 dias')
 58 | })
 59 | 
 60 | test('toDate: Formata uma data (DD-MM-YYYY | YYYY-MM-DD) para DD/MM/YYYY', () => {
 61 |   expect(format.toDate('21/08/2002')).toBe('21/08/2002')
 62 |   expect(format.toDate('21-08-2002')).toBe('21/08/2002')
 63 |   expect(format.toDate('2002-08-21')).toBe('21/08/2002')
 64 |   expect(format.toDate('2002-08-21')).toBe('21/08/2002')
 65 |   expect(format.toDate('2002-08-21')).toBe('21/08/2002')
 66 | })
 67 | 
 68 | test('toDate: Usando as opções é possível definir formatos de entrada e saída', () => {
 69 |   expect(format.toDate('21/08/2002', { from: 'DD/MM/YYYY', to: 'YYYY-MM-DD' })).toBe('2002-08-21')
 70 |   expect(format.toDate('2002-08-21', { to: 'YYYY/MM/DD' })).toBe('2002/08/21')
 71 |   expect(format.toDate('2002/08/21', { from: 'YYYY/MM/DD' })).toBe('21/08/2002')
 72 | })
 73 | 
 74 | test('toDate: Usando as opções é possível escolher usar UTC ao invés da timezone', () => {
 75 |   expect(format.toDate(1513791107947, { to: 'DD/MM/YYYY HH:mm', UTC: true })).toBe('20/12/2017 17:31')
 76 |   expect(format.toDate(1513791107947, { to: 'DD/MM/YYYY HH:mm', UTC: false })).toBe('20/12/2017 15:31')
 77 |   expect(format.toDate(1513791107947, { to: 'DD/MM/YYYY HH:mm' })).toBe('20/12/2017 15:31')
 78 | })
 79 | 
 80 | test('toDate: Não formata valores inválidos', () => {
 81 |   expect(format.toDate(null)).toBeNull()
 82 |   expect(format.toDate(undefined)).toBeNull()
 83 |   expect(format.toDate('21/08/01')).toBeNull()
 84 |   expect(format.toDate('21/30/2001')).toBeNull()
 85 | })
 86 | 
 87 | test('toInterval: Formata o intervalo de datas', () => {
 88 |   expect(format.toInterval({ start: '21-03-2006', end: '20-04-2006' })).toBe('21/03/2006 a 20/04/2006')
 89 |   expect(format.toInterval({ start: '21-03-2006', end: '20-04-2006' }, { to: 'MMMM' })).toBe('Março a Abril')
 90 | })
 91 | 
 92 | test('toEmpty: Retorna um caractere vazio para um dado vazio', () => {
 93 |   expect(format.toEmpty(null)).toBe('-')
 94 |   expect(format.toEmpty(undefined, '*')).toBe('*')
 95 |   expect(format.toEmpty('')).toBe('-')
 96 |   expect(format.toEmpty(NaN)).toBe('-')
 97 | })
 98 | 
 99 | test('toPhone: Formata um valor para telefone', () => {
100 |   expect(format.toPhone('11')).toBe('(11')
101 |   expect(format.toPhone('11971626')).toBe('(11) 9716-26')
102 |   expect(format.toPhone('1197162679')).toBe('(11) 9716-2679')
103 |   expect(format.toPhone('11971626799')).toBe('(11) 97162-6799')
104 | })
105 | 
106 | test('toPhone: Não formata valores inválidos', () => {
107 |   expect(format.toPhone(null)).toBeNull()
108 |   expect(format.toPhone(undefined)).toBeNull()
109 |   expect(format.toPhone(198928192)).toBeNull()
110 | })
111 | 
112 | test('toClean: Formata um texto removendo seus acentos', () => {
113 |   expect(format.toClean('Olá, tudo bem com você?')).toBe('Ola, tudo bem com voce?')
114 |   expect(format.toClean('São Paulo - SP')).toBe('Sao Paulo - SP')
115 | })
116 | 
117 | test('toClean: Não formata valores inválidos', () => {
118 |   expect(format.toClean(null)).toBeNull()
119 |   expect(format.toClean(undefined)).toBeNull()
120 | })
121 | 
122 | test('toSlug: Formata um texto para "kebab-case"', () => {
123 |   expect(format.toSlug('Olá, tudo bem com você?')).toBe('ola-tudo-bem-com-voce')
124 |   expect(format.toSlug('São Paulo - SP')).toBe('sao-paulo-sp')
125 | })
126 | 
127 | test('toSlug: Não formata valores inválidos', () => {
128 |   expect(format.toSlug(null)).toBeNull()
129 |   expect(format.toSlug(undefined)).toBeNull()
130 | })
131 | 
132 | test('toCEP: Formata um texto para CEP', () => {
133 |   expect(format.toCEP('15998030')).toBe('15998-030')
134 |   expect(format.toCEP('159980')).toBe('15998-0')
135 | })
136 | 
137 | test('toCEP: Não formata valores inválidos', () => {
138 |   expect(format.toCEP(null)).toBeNull()
139 |   expect(format.toCEP(undefined)).toBeNull()
140 |   expect(format.toCEP(15998030)).toBeNull()
141 | })
142 | 


--------------------------------------------------------------------------------
/test/index.spec.js:
--------------------------------------------------------------------------------
 1 | import sinon from 'sinon'
 2 | import install, { format, validate } from '../src/index'
 3 | 
 4 | const getVue = () => {
 5 |   const Vue = class {
 6 |     static use (plugin) {
 7 |       const install = (plugin && typeof plugin === 'object') ? plugin.install : plugin
 8 |       install.call(Vue)
 9 |     }
10 | 
11 |     static filter (name, handler) {}
12 |   }
13 | 
14 |   return Vue
15 | }
16 | 
17 | test('A exportação padrão é uma função', () => {
18 |   expect(typeof install).toBe('function')
19 | })
20 | 
21 | test('Exporta o namespace "format"', () => {
22 |   expect(!!format).toBeTruthy()
23 |   expect(typeof format).toBe('object')
24 | })
25 | 
26 | test('Exporta o namespace "validate"', () => {
27 |   expect(!!validate).toBeTruthy()
28 |   expect(typeof validate).toBe('object')
29 | })
30 | 
31 | test('Implanta os plugins selecionados', () => {
32 |   const Vue = getVue()
33 |   const spy = sinon.spy(Vue, 'filter')
34 |   const vm = new Vue()
35 | 
36 |   install(Vue, {
37 |     formatters: true,
38 |     formatFilters: true,
39 |     validators: true
40 |   })
41 | 
42 |   expect(spy.called).toBeTruthy()
43 |   expect(!!vm.$format).toBeTruthy()
44 |   expect(!!vm.$validate).toBeTruthy()
45 | })
46 | 
47 | test('Implanta apenas os plugins selecionados', () => {
48 |   const Vue = getVue()
49 |   const spy = sinon.spy(Vue, 'filter')
50 |   const vm = new Vue()
51 | 
52 |   install(Vue, {
53 |     formatters: false,
54 |     formatFilters: false,
55 |     validators: false
56 |   })
57 | 
58 |   expect(spy.called).toBeFalsy()
59 |   expect(!!vm.$format).toBeFalsy()
60 |   expect(!!vm.$validate).toBeFalsy()
61 | })
62 | 


--------------------------------------------------------------------------------
/test/validators.spec.js:
--------------------------------------------------------------------------------
 1 | import { validate } from '../src/index'
 2 | 
 3 | test('is: Verdadeiro para a comparação de um valor com seu construtor', () => {
 4 |   expect(validate.is(null, 'Null')).toBeTruthy()
 5 |   expect(validate.is(undefined, 'Undefined')).toBeTruthy()
 6 |   expect(validate.is(1200, 'String')).toBeFalsy()
 7 |   expect(validate.is('R$ 120,20', 'String')).toBeTruthy()
 8 |   expect(validate.is([0, 1, 2, 3], 'Object')).toBeFalsy()
 9 |   expect(validate.is({ name: 'Convenia' }, 'Object')).toBeTruthy()
10 | })
11 | 
12 | test('isCPF: Verdadeiro para um CPF válido', () => {
13 |   expect(validate.isCPF('366.418.768-70')).toBeTruthy()
14 |   expect(validate.isCPF('36641876870')).toBeTruthy()
15 |   expect(validate.isCPF('213.198.013-20')).toBeFalsy()
16 |   expect(validate.isCPF('2131201872781')).toBeFalsy()
17 |   expect(validate.isCPF('11111111111')).toBeTruthy()
18 |   expect(validate.isCPF('00000000000')).toBeFalsy()
19 |   expect(validate.isCPF('111.111.111-11')).toBeTruthy()
20 |   expect(validate.isCPF('UHASHUISIH910')).toBeFalsy()
21 | })
22 | 
23 | test('isCPF: Falso para dados que não sejam "string"', () => {
24 |   // Teste que valida a correção do issue #5
25 |   // Link: https://github.com/convenia/vue-convenia-util/issues/5
26 |   expect(validate.isCPF(undefined)).toBeFalsy()
27 |   expect(validate.isCPF(null)).toBeFalsy()
28 |   expect(validate.isCPF(36641876870)).toBeFalsy()
29 | })
30 | 
31 | test('isDate: Verdadeiro para uma data válida (DD/MM/YYYY | DD-MM-YYYY & YYYY-MM-DD)', () => {
32 |   expect(validate.isDate('28/03/2017')).toBeTruthy()
33 |   expect(validate.isDate('28-03-2017')).toBeTruthy()
34 |   expect(validate.isDate('2017-03-28')).toBeTruthy()
35 |   expect(validate.isDate('31/02/2017')).toBeFalsy()
36 | })
37 | 
38 | test('isDate: Falso para uma data inválida ou fora da formatação padrão', () => {
39 |   expect(validate.isDate('03/28/2017')).toBeFalsy()
40 |   expect(validate.isDate('28-13-9017')).toBeFalsy()
41 |   expect(validate.isDate('0000-00-00')).toBeFalsy()
42 |   expect(validate.isDate('29/12')).toBeFalsy()
43 | })
44 | 
45 | test('isDate: Valida usando o formato especificado ao invés de um dinâmico', () => {
46 |   expect(validate.isDate('31/13/17', 'DD/MM/YY')).toBeFalsy()
47 | })
48 | 
49 | test('isDate: Falso para dados que não sejam "string" (com excecao de timestamps)', () => {
50 |   expect(validate.isDate(undefined)).toBeFalsy()
51 |   expect(validate.isDate(null)).toBeFalsy()
52 |   expect(validate.isDate(36641876870)).toBeTruthy()
53 | })
54 | 
55 | test('isCNPJ: Verdadeiro para um CNPJ válido', () => {
56 |   expect(validate.isCNPJ('41142260000189')).toBeTruthy()
57 |   expect(validate.isCNPJ('45.723.174/0001-10')).toBeTruthy()
58 |   expect(validate.isCNPJ('41142260007182')).toBeFalsy()
59 |   expect(validate.isCNPJ('19.981.127/0001-10')).toBeFalsy()
60 | })
61 | 
62 | test('isCNPJ: Falso para dados que não sejam "string"', () => {
63 |   expect(validate.isCNPJ(undefined)).toBeFalsy()
64 |   expect(validate.isCNPJ(null)).toBeFalsy()
65 |   expect(validate.isCNPJ(41142260000189)).toBeFalsy()
66 | })
67 | 
68 | test('isEmail: Verdadeiro para um possível email', () => {
69 |   expect(validate.isEmail('example@example.com')).toBeTruthy()
70 |   expect(validate.isEmail('@example.com')).toBeFalsy()
71 |   expect(validate.isEmail('example.com.br')).toBeFalsy()
72 | })
73 | 
74 | test('isEmail: Falso para dados que não sejam "string"', () => {
75 |   expect(validate.isEmail(undefined)).toBeFalsy()
76 |   expect(validate.isEmail(null)).toBeFalsy()
77 |   expect(validate.isEmail(41142260000189)).toBeFalsy()
78 | })
79 | 


--------------------------------------------------------------------------------