vuejs 1.0.36 → 1.0.37

Sign up to get free protection for your applications and to get access to all the features.
@@ -0,0 +1,2054 @@
1
+ /*!
2
+ * vue-validator v3.0.0-alpha.2
3
+ * (c) 2016 kazuya kawaguchi
4
+ * Released under the MIT License.
5
+ */
6
+ (function (global, factory) {
7
+ typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
8
+ typeof define === 'function' && define.amd ? define(factory) :
9
+ (global.VueValidator = factory());
10
+ }(this, (function () { 'use strict';
11
+
12
+ /* */
13
+
14
+ function warn (msg, err) {
15
+ if (window.console) {
16
+ console.warn('[vue-validator] ' + msg);
17
+ if (err) {
18
+ console.warn(err.stack);
19
+ }
20
+ }
21
+ }
22
+
23
+ /* */
24
+
25
+ // validator configrations
26
+ var validator = {
27
+ classes: {}
28
+ };
29
+
30
+ var Config = function (Vue) {
31
+ // define Vue.config.validator configration
32
+ // $FlowFixMe: https://github.com/facebook/flow/issues/285
33
+ Object.defineProperty(Vue.config, 'validator', {
34
+ enumerable: true,
35
+ configurable: true,
36
+ get: function () { return validator },
37
+ set: function (val) { validator = val; }
38
+ });
39
+ };
40
+
41
+ /* */
42
+ /**
43
+ * build-in validators
44
+ */
45
+
46
+ /**
47
+ * required
48
+ * This function validate whether the value has been filled out.
49
+ */
50
+ function required (val, arg) {
51
+ var isRequired = arg === undefined ? true : arg;
52
+ if (Array.isArray(val)) {
53
+ if (val.length !== 0) {
54
+ var valid = true;
55
+ for (var i = 0, l = val.length; i < l; i++) {
56
+ valid = required(val[i], isRequired);
57
+ if ((isRequired && !valid) || (!isRequired && valid)) {
58
+ break
59
+ }
60
+ }
61
+ return valid
62
+ } else {
63
+ return !isRequired
64
+ }
65
+ } else if (typeof val === 'number' || typeof val === 'function') {
66
+ return isRequired
67
+ } else if (typeof val === 'boolean') {
68
+ return val === isRequired
69
+ } else if (typeof val === 'string') {
70
+ return isRequired ? (val.length > 0) : (val.length <= 0)
71
+ } else if (val !== null && typeof val === 'object') {
72
+ return isRequired ? (Object.keys(val).length > 0) : (Object.keys(val).length <= 0)
73
+ } else if (val === null || val === undefined) {
74
+ return !isRequired
75
+ } else {
76
+ return !isRequired
77
+ }
78
+ }
79
+
80
+ /**
81
+ * pattern
82
+ * This function validate whether the value matches the regex pattern
83
+ */
84
+ function pattern (val, pat) {
85
+ if (typeof pat !== 'string') { return false }
86
+
87
+ var match = pat.match(new RegExp('^/(.*?)/([gimy]*)$'));
88
+ if (!match) { return false }
89
+
90
+ return new RegExp(match[1], match[2]).test(val)
91
+ }
92
+
93
+ /**
94
+ * minlength
95
+ * This function validate whether the minimum length.
96
+ */
97
+ function minlength (val, min) {
98
+ if (typeof val === 'string') {
99
+ return isInteger(min, 10) && val.length >= parseInt(min, 10)
100
+ } else if (Array.isArray(val)) {
101
+ return val.length >= parseInt(min, 10)
102
+ } else {
103
+ return false
104
+ }
105
+ }
106
+
107
+ /**
108
+ * maxlength
109
+ * This function validate whether the maximum length.
110
+ */
111
+ function maxlength (val, max) {
112
+ if (typeof val === 'string') {
113
+ return isInteger(max, 10) && val.length <= parseInt(max, 10)
114
+ } else if (Array.isArray(val)) {
115
+ return val.length <= parseInt(max, 10)
116
+ } else {
117
+ return false
118
+ }
119
+ }
120
+
121
+ /**
122
+ * min
123
+ * This function validate whether the minimum value of the numberable value.
124
+ */
125
+ function min (val, arg) {
126
+ return !isNaN(+(val)) && !isNaN(+(arg)) && (+(val) >= +(arg))
127
+ }
128
+
129
+ /**
130
+ * max
131
+ * This function validate whether the maximum value of the numberable value.
132
+ */
133
+ function max (val, arg) {
134
+ return !isNaN(+(val)) && !isNaN(+(arg)) && (+(val) <= +(arg))
135
+ }
136
+
137
+ /**
138
+ * isInteger
139
+ * This function check whether the value of the string is integer.
140
+ */
141
+ function isInteger (val) {
142
+ return /^(-?[1-9]\d*|0)$/.test(val)
143
+ }
144
+
145
+
146
+ var validators = Object.freeze({
147
+ required: required,
148
+ pattern: pattern,
149
+ minlength: minlength,
150
+ maxlength: maxlength,
151
+ min: min,
152
+ max: max
153
+ });
154
+
155
+ /* */
156
+ var Asset = function (Vue) {
157
+ var ref = Vue.util;
158
+ var extend = ref.extend;
159
+
160
+ // set global validators asset
161
+ var assets = Object.create(null);
162
+ extend(assets, validators);
163
+ Vue.options.validators = assets;
164
+
165
+ // set option merge strategy
166
+ var strats = Vue.config.optionMergeStrategies;
167
+ if (strats) {
168
+ strats.validators = function (parent, child) {
169
+ if (!child) { return parent }
170
+ if (!parent) { return child }
171
+ var ret = Object.create(null);
172
+ extend(ret, parent);
173
+ var key;
174
+ for (key in child) {
175
+ ret[key] = child[key];
176
+ }
177
+ return ret
178
+ };
179
+ }
180
+
181
+ /**
182
+ * Register or retrieve a global validator definition.
183
+ */
184
+ function validator (
185
+ id,
186
+ def
187
+ ) {
188
+ if (def === undefined) {
189
+ return Vue.options['validators'][id]
190
+ } else {
191
+ Vue.options['validators'][id] = def;
192
+ if (def === null) {
193
+ delete Vue.options['validators']['id'];
194
+ }
195
+ }
196
+ }
197
+ Vue['validator'] = validator;
198
+ };
199
+
200
+ /* */
201
+
202
+ var Group = function (Vue) {
203
+ var ref = Vue.util;
204
+ var extend = ref.extend;
205
+
206
+ return {
207
+ data: function data () {
208
+ return {
209
+ valid: true,
210
+ dirty: false,
211
+ touched: false,
212
+ modified: false,
213
+ results: {}
214
+ }
215
+ },
216
+ computed: {
217
+ invalid: function invalid () { return !this.valid },
218
+ pristine: function pristine () { return !this.dirty },
219
+ untouched: function untouched () { return !this.touched },
220
+ result: function result () {
221
+ var ret = {
222
+ valid: this.valid,
223
+ invalid: this.invalid,
224
+ dirty: this.dirty,
225
+ pristine: this.pristine,
226
+ touched: this.touched,
227
+ untouched: this.untouched,
228
+ modified: this.modified
229
+ };
230
+ var results = this.results;
231
+ this._validityKeys.forEach(function (key) {
232
+ ret[key] = results[key];
233
+ if (ret[key].errors) {
234
+ var errors = ret.errors || [];
235
+ ret[key].errors.forEach(function (error) {
236
+ errors.push(error);
237
+ });
238
+ ret.errors = errors;
239
+ }
240
+ });
241
+ return ret
242
+ }
243
+ },
244
+ watch: {
245
+ results: function results (val, old) {
246
+ var keys = this._validityKeys;
247
+ var results = this.results;
248
+ this.valid = this.checkResults(keys, results, 'valid', true);
249
+ this.dirty = this.checkResults(keys, results, 'dirty', false);
250
+ this.touched = this.checkResults(keys, results, 'touched', false);
251
+ this.modified = this.checkResults(keys, results, 'modified', false);
252
+ }
253
+ },
254
+ created: function created () {
255
+ this._validities = Object.create(null);
256
+ this._validityWatchers = Object.create(null);
257
+ this._validityKeys = [];
258
+ this._committing = false;
259
+ },
260
+ destroyed: function destroyed () {
261
+ var this$1 = this;
262
+
263
+ this._validityKeys.forEach(function (key) {
264
+ this$1._validityWatchers[key]();
265
+ delete this$1._validityWatchers[key];
266
+ delete this$1._validities[key];
267
+ });
268
+ delete this._validityWatchers;
269
+ delete this._validities;
270
+ delete this._validityKeys;
271
+ },
272
+ methods: {
273
+ register: function register (name, validity) {
274
+ var this$1 = this;
275
+
276
+ this._validities[name] = validity;
277
+ this._validityKeys = Object.keys(this._validities);
278
+ this.setResults(name, {});
279
+ this.withCommit(function () {
280
+ this$1._validityWatchers[name] = validity.$watch('result', function (val, old) {
281
+ this$1.setResults(name, val);
282
+ }, { deep: true, immediate: true });
283
+ });
284
+ },
285
+ unregister: function unregister (name) {
286
+ var this$1 = this;
287
+
288
+ this._validityWatchers[name]();
289
+ delete this._validityWatchers[name];
290
+ delete this._validities[name];
291
+ this._validityKeys = Object.keys(this._validities);
292
+ this.withCommit(function () {
293
+ this$1.resetResults(name);
294
+ });
295
+ },
296
+ validityCount: function validityCount () {
297
+ return this._validityKeys.length
298
+ },
299
+ isRegistered: function isRegistered (name) {
300
+ return name in this._validities
301
+ },
302
+ getValidityKeys: function getValidityKeys () {
303
+ return this._validityKeys
304
+ },
305
+ checkResults: function checkResults (
306
+ keys,
307
+ results,
308
+ prop,
309
+ checking
310
+ ) {
311
+ var ret = checking;
312
+ for (var i = 0; i < keys.length; i++) {
313
+ var result = results[keys[i]];
314
+ if (result[prop] !== checking) {
315
+ ret = !checking;
316
+ break
317
+ }
318
+ }
319
+ return ret
320
+ },
321
+ setResults: function setResults (name, val) {
322
+ var this$1 = this;
323
+
324
+ var newVal = {};
325
+ this._validityKeys.forEach(function (key) {
326
+ newVal[key] = extend({}, this$1.results[key]);
327
+ });
328
+ newVal[name] = extend({}, val);
329
+ this.results = newVal;
330
+ },
331
+ resetResults: function resetResults (ignore) {
332
+ var this$1 = this;
333
+
334
+ var newVal = {};
335
+ this._validityKeys.forEach(function (key) {
336
+ if (ignore && ignore !== key) {
337
+ newVal[key] = extend({}, this$1.results[key]);
338
+ }
339
+ });
340
+ this.results = newVal;
341
+ },
342
+ withCommit: function withCommit (fn) {
343
+ var committing = this._committing;
344
+ this._committing = true;
345
+ fn();
346
+ this._committing = committing;
347
+ }
348
+ }
349
+ }
350
+ };
351
+
352
+ /* */
353
+ var ValidationClass = function (Vue) {
354
+ var ValidityGroup = Group(Vue);
355
+
356
+ var Validation = function Validation (options) {
357
+ if ( options === void 0 ) options = {};
358
+
359
+ this._result = {};
360
+ this._host = options.host;
361
+ this._named = Object.create(null);
362
+ this._group = Object.create(null);
363
+ this._validities = Object.create(null);
364
+ this._beginDestroy = false;
365
+ Vue.util.defineReactive(this._host, '$validation', this._result);
366
+ };
367
+
368
+ Validation.prototype.register = function register (
369
+ field,
370
+ validity,
371
+ options
372
+ ) {
373
+ if ( options === void 0 ) options = {};
374
+
375
+ // NOTE: lazy setup (in constructor, occured callstack recursive errors ...)
376
+ if (!this._validityManager) {
377
+ this._validityManager = new Vue(ValidityGroup);
378
+ this._watchValidityResult();
379
+ }
380
+
381
+ if (this._validities[field]) {
382
+ // TODO: should be output console.error
383
+ return
384
+ }
385
+ this._validities[field] = validity;
386
+
387
+ var named = options.named;
388
+ var group = options.group;
389
+ var groupValidity = group
390
+ ? this._getValidityGroup('group', group) || this._registerValidityGroup('group', group)
391
+ : null;
392
+ var namedValidity = named
393
+ ? this._getValidityGroup('named', named) || this._registerValidityGroup('named', named)
394
+ : null;
395
+ if (named && group && namedValidity && groupValidity) {
396
+ groupValidity.register(field, validity);
397
+ !namedValidity.isRegistered(group) && namedValidity.register(group, groupValidity);
398
+ !this._validityManager.isRegistered(named) && this._validityManager.register(named, namedValidity);
399
+ } else if (namedValidity) {
400
+ namedValidity.register(field, validity);
401
+ !this._validityManager.isRegistered(named) && this._validityManager.register(named, namedValidity);
402
+ } else if (groupValidity) {
403
+ groupValidity.register(field, validity);
404
+ !this._validityManager.isRegistered(group) && this._validityManager.register(group, groupValidity);
405
+ } else {
406
+ this._validityManager.register(field, validity);
407
+ }
408
+ };
409
+
410
+ Validation.prototype.unregister = function unregister (
411
+ field,
412
+ options
413
+ ) {
414
+ if ( options === void 0 ) options = {};
415
+
416
+ if (!this._validityManager) {
417
+ // TODO: should be output error
418
+ return
419
+ }
420
+
421
+ if (!this._validities[field]) {
422
+ // TODO: should be output error
423
+ return
424
+ }
425
+ delete this._validities[field];
426
+
427
+ var named = options.named;
428
+ var group = options.group;
429
+ var groupValidity = group ? this._getValidityGroup('group', group) : null;
430
+ var namedValidity = named ? this._getValidityGroup('named', named) : null;
431
+ if (named && group && namedValidity && groupValidity) {
432
+ groupValidity.unregister(field);
433
+ if (groupValidity.validityCount() === 0) {
434
+ namedValidity.isRegistered(group) && namedValidity.unregister(group);
435
+ this._unregisterValidityGroup('group', group);
436
+ }
437
+ if (namedValidity.validityCount() === 0) {
438
+ this._validityManager.isRegistered(named) && this._validityManager.unregister(named);
439
+ this._unregisterValidityGroup('named', named);
440
+ }
441
+ } else if (named && namedValidity) {
442
+ namedValidity.unregister(field);
443
+ if (namedValidity.validityCount() === 0) {
444
+ this._validityManager.isRegistered(named) && this._validityManager.unregister(named);
445
+ this._unregisterValidityGroup('named', named);
446
+ }
447
+ } else if (group && groupValidity) {
448
+ groupValidity.unregister(field);
449
+ if (groupValidity.validityCount() === 0) {
450
+ this._validityManager.isRegistered(group) && this._validityManager.unregister(group);
451
+ this._unregisterValidityGroup('group', group);
452
+ }
453
+ } else {
454
+ this._validityManager.unregister(field);
455
+ }
456
+ };
457
+
458
+ Validation.prototype.destroy = function destroy () {
459
+ var this$1 = this;
460
+
461
+ var validityKeys = Object.keys(this._validities);
462
+ var namedKeys = Object.keys(this._named);
463
+ var groupKeys = Object.keys(this._group);
464
+
465
+ // unregister validity
466
+ validityKeys.forEach(function (validityKey) {
467
+ groupKeys.forEach(function (groupKey) {
468
+ var group = this$1._getValidityGroup('group', groupKey);
469
+ if (group && group.isRegistered(groupKey)) {
470
+ group.unregister(validityKey);
471
+ }
472
+ });
473
+ namedKeys.forEach(function (namedKey) {
474
+ var named = this$1._getValidityGroup('named', namedKey);
475
+ if (named && named.isRegistered(validityKey)) {
476
+ named.unregister(validityKey);
477
+ }
478
+ });
479
+ if (this$1._validityManager.isRegistered(validityKey)) {
480
+ this$1._validityManager.unregister(validityKey);
481
+ }
482
+ delete this$1._validities[validityKey];
483
+ });
484
+
485
+ // unregister grouped validity
486
+ groupKeys.forEach(function (groupKey) {
487
+ namedKeys.forEach(function (namedKey) {
488
+ var named = this$1._getValidityGroup('named', namedKey);
489
+ if (named && named.isRegistered(groupKey)) {
490
+ named.unregister(groupKey);
491
+ }
492
+ });
493
+ if (this$1._validityManager.isRegistered(groupKey)) {
494
+ this$1._validityManager.unregister(groupKey);
495
+ }
496
+ this$1._unregisterValidityGroup('group', groupKey);
497
+ });
498
+
499
+ // unregister named validity
500
+ namedKeys.forEach(function (namedKey) {
501
+ if (this$1._validityManager.isRegistered(namedKey)) {
502
+ this$1._validityManager.unregister(namedKey);
503
+ }
504
+ this$1._unregisterValidityGroup('named', namedKey);
505
+ });
506
+
507
+ this._beginDestroy = true;
508
+ };
509
+
510
+ Validation.prototype._getValidityGroup = function _getValidityGroup (type, name) {
511
+ return type === 'named' ? this._named[name] : this._group[name]
512
+ };
513
+
514
+ Validation.prototype._registerValidityGroup = function _registerValidityGroup (type, name) {
515
+ var groups = type === 'named' ? this._named : this._group;
516
+ groups[name] = new Vue(ValidityGroup);
517
+ return groups[name]
518
+ };
519
+
520
+ Validation.prototype._unregisterValidityGroup = function _unregisterValidityGroup (type, name) {
521
+ var groups = type === 'named' ? this._named : this._group;
522
+ if (!groups[name]) {
523
+ // TODO: should be warn
524
+ return
525
+ }
526
+
527
+ groups[name].$destroy();
528
+ delete groups[name];
529
+ };
530
+
531
+ Validation.prototype._watchValidityResult = function _watchValidityResult () {
532
+ var this$1 = this;
533
+
534
+ this._watcher = this._validityManager.$watch('results', function (val, old) {
535
+ Vue.set(this$1._host, '$validation', val);
536
+ if (this$1._beginDestroy) {
537
+ this$1._destroyValidityMananger();
538
+ }
539
+ }, { deep: true });
540
+ };
541
+
542
+ Validation.prototype._unwatchValidityResult = function _unwatchValidityResult () {
543
+ this._watcher();
544
+ delete this._watcher;
545
+ };
546
+
547
+ Validation.prototype._destroyValidityMananger = function _destroyValidityMananger () {
548
+ this._unwatchValidityResult();
549
+ this._validityManager.$destroy();
550
+ this._validityManager = null;
551
+ };
552
+
553
+ return Validation
554
+ };
555
+
556
+ /* */
557
+
558
+ var Mixin = function (Vue) {
559
+ var Validation = ValidationClass(Vue);
560
+
561
+ return {
562
+ beforeCreate: function beforeCreate () {
563
+ this._validation = new Validation({ host: this });
564
+ }
565
+ }
566
+ };
567
+
568
+ /* */
569
+
570
+ var baseProps = {
571
+ field: {
572
+ type: String,
573
+ required: true
574
+ },
575
+ validators: {
576
+ type: [String, Array, Object],
577
+ required: true
578
+ },
579
+ group: {
580
+ type: String
581
+ },
582
+ multiple: {
583
+ type: Boolean
584
+ },
585
+ autotouch: {
586
+ type: String,
587
+ default: function () {
588
+ return 'on'
589
+ }
590
+ },
591
+ classes: {
592
+ type: Object,
593
+ default: function () {
594
+ return {}
595
+ }
596
+ }
597
+ };
598
+
599
+ var DEFAULT_CLASSES = {
600
+ valid: 'valid',
601
+ invalid: 'invalid',
602
+ touched: 'touched',
603
+ untouched: 'untouched',
604
+ pristine: 'pristine',
605
+ dirty: 'dirty',
606
+ modified: 'modified'
607
+ };
608
+
609
+ /* */
610
+ var States = function (Vue) {
611
+ var ref = Vue.util;
612
+ var extend = ref.extend;
613
+ var isPlainObject = ref.isPlainObject;
614
+
615
+ function initialStates (states, validators, init) {
616
+ if ( init === void 0 ) init = undefined;
617
+
618
+ if (Array.isArray(validators)) {
619
+ validators.forEach(function (validator) {
620
+ states[validator] = init;
621
+ });
622
+ } else {
623
+ Object.keys(validators).forEach(function (validator) {
624
+ var props = (validators[validator] &&
625
+ validators[validator]['props'] &&
626
+ isPlainObject(validators[validator]['props']))
627
+ ? validators[validator]['props']
628
+ : null;
629
+ if (props) {
630
+ Object.keys(props).forEach(function (prop) {
631
+ states[validator] = {};
632
+ states[validator][prop] = init;
633
+ });
634
+ } else {
635
+ states[validator] = init;
636
+ }
637
+ });
638
+ }
639
+ }
640
+
641
+ function getInitialResults (validators) {
642
+ var results = {};
643
+ initialStates(results, validators, undefined);
644
+ return results
645
+ }
646
+
647
+ function getInitialProgresses (validators) {
648
+ var progresses = {};
649
+ initialStates(progresses, validators, '');
650
+ return progresses
651
+ }
652
+
653
+ var props = extend({
654
+ child: {
655
+ type: Object,
656
+ required: true
657
+ },
658
+ value: {
659
+ type: Object
660
+ }
661
+ }, baseProps);
662
+
663
+ function data () {
664
+ var validators = nomalizeValidators(this.validators);
665
+ return {
666
+ results: getInitialResults(validators),
667
+ valid: true,
668
+ dirty: false,
669
+ touched: false,
670
+ modified: false,
671
+ progresses: getInitialProgresses(validators)
672
+ }
673
+ }
674
+
675
+ return {
676
+ props: props,
677
+ data: data
678
+ }
679
+ };
680
+
681
+ function nomalizeValidators (target) {
682
+ return typeof target === 'string' ? [target] : target
683
+ }
684
+
685
+ /* */
686
+
687
+ var Computed = function (Vue) {
688
+ var ref = Vue.util;
689
+ var isPlainObject = ref.isPlainObject;
690
+
691
+ function setError (
692
+ result,
693
+ field,
694
+ validator,
695
+ message,
696
+ prop
697
+ ) {
698
+ var error = { field: field, validator: validator };
699
+ if (message) {
700
+ error.message = message;
701
+ }
702
+ if (prop) {
703
+ error.prop = prop;
704
+ }
705
+ result.errors = result.errors || [];
706
+ result.errors.push(error);
707
+ }
708
+
709
+ function walkProgresses (keys, target) {
710
+ var progress = '';
711
+ for (var i = 0; i < keys.length; i++) {
712
+ var result = target[keys[i]];
713
+ if (typeof result === 'string' && result) {
714
+ progress = result;
715
+ break
716
+ }
717
+ if (isPlainObject(result)) {
718
+ var nestedKeys = Object.keys(result);
719
+ progress = walkProgresses(nestedKeys, result);
720
+ if (!progress) {
721
+ break
722
+ }
723
+ }
724
+ }
725
+ return progress
726
+ }
727
+
728
+ function invalid () {
729
+ return !this.valid
730
+ }
731
+
732
+ function pristine () {
733
+ return !this.dirty
734
+ }
735
+
736
+ function untouched () {
737
+ return !this.touched
738
+ }
739
+
740
+ function result () {
741
+ var this$1 = this;
742
+
743
+ var ret = {
744
+ valid: this.valid,
745
+ invalid: this.invalid,
746
+ dirty: this.dirty,
747
+ pristine: this.pristine,
748
+ touched: this.touched,
749
+ untouched: this.untouched,
750
+ modified: this.modified
751
+ };
752
+
753
+ var keys = this._keysCached(this._uid.toString(), this.results);
754
+ keys.forEach(function (validator) {
755
+ var result = this$1.results[validator];
756
+ if (typeof result === 'boolean') {
757
+ if (result) {
758
+ ret[validator] = false;
759
+ } else {
760
+ setError(ret, this$1.field, validator);
761
+ ret[validator] = !result;
762
+ }
763
+ } else if (typeof result === 'string') {
764
+ setError(ret, this$1.field, validator, result);
765
+ ret[validator] = result;
766
+ } else if (isPlainObject(result)) { // object
767
+ var props = Object.keys(result);
768
+ props.forEach(function (prop) {
769
+ var propRet = result[prop];
770
+ ret[prop] = ret[prop] || {};
771
+ if (typeof propRet === 'boolean') {
772
+ if (propRet) {
773
+ ret[prop][validator] = false;
774
+ } else {
775
+ setError(ret, this$1.field, validator, undefined, prop);
776
+ ret[prop][validator] = !propRet;
777
+ }
778
+ } else if (typeof propRet === 'string') {
779
+ setError(ret, this$1.field, validator, propRet, prop);
780
+ ret[prop][validator] = propRet;
781
+ } else {
782
+ ret[prop][validator] = false;
783
+ }
784
+ });
785
+ } else {
786
+ ret[validator] = false;
787
+ }
788
+ });
789
+
790
+ return ret
791
+ }
792
+
793
+ function progress () {
794
+ var ret = '';
795
+ ret = walkProgresses(
796
+ this._keysCached(this._uid.toString(), this.results),
797
+ this.progresses
798
+ );
799
+ return ret
800
+ }
801
+
802
+ return {
803
+ invalid: invalid,
804
+ pristine: pristine,
805
+ untouched: untouched,
806
+ result: result,
807
+ progress: progress
808
+ }
809
+ };
810
+
811
+ /* */
812
+
813
+ var Render = function (Vue) {
814
+ return {
815
+ render: function render (h) {
816
+ return this.child
817
+ }
818
+ }
819
+ };
820
+
821
+ /* */
822
+
823
+ var SingleElementClass = function (Vue) {
824
+ var ref = Vue.util;
825
+ var looseEqual = ref.looseEqual;
826
+
827
+ var SingleElement = function SingleElement (vm) {
828
+ this._vm = vm;
829
+ this.initValue = this.getValue();
830
+ this.attachValidity();
831
+ };
832
+
833
+ SingleElement.prototype.attachValidity = function attachValidity () {
834
+ this._vm.$el.$validity = this._vm;
835
+ };
836
+
837
+ SingleElement.prototype.getValue = function getValue () {
838
+ var el = this._vm.$el;
839
+ if (el.tagName === 'SELECT') {
840
+ return getSelectValue(el)
841
+ } else {
842
+ if (el.type === 'checkbox') {
843
+ return el.checked
844
+ } else {
845
+ return el.value
846
+ }
847
+ }
848
+ };
849
+
850
+ SingleElement.prototype.checkModified = function checkModified () {
851
+ var el = this._vm.$el;
852
+ if (el.tagName === 'SELECT') {
853
+ return !looseEqual(this.initValue, getSelectValue(el))
854
+ } else {
855
+ if (el.type === 'checkbox') {
856
+ return !looseEqual(this.initValue, el.checked)
857
+ } else {
858
+ return !looseEqual(this.initValue, el.value)
859
+ }
860
+ }
861
+ };
862
+
863
+ SingleElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
864
+ this._vm.$el.addEventListener('focusout', this._vm.willUpdateTouched);
865
+ };
866
+
867
+ SingleElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
868
+ this._vm.$el.removeEventListener('focusout', this._vm.willUpdateTouched);
869
+ };
870
+
871
+ SingleElement.prototype.listenInputableEvent = function listenInputableEvent () {
872
+ var vm = this._vm;
873
+ var el = vm.$el;
874
+ if (el.tagName === 'SELECT') {
875
+ el.addEventListener('change', vm.handleInputable);
876
+ } else {
877
+ if (el.type === 'checkbox') {
878
+ el.addEventListener('change', vm.handleInputable);
879
+ } else {
880
+ el.addEventListener('input', vm.handleInputable);
881
+ }
882
+ }
883
+ };
884
+
885
+ SingleElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
886
+ var vm = this._vm;
887
+ var el = vm.$el;
888
+ if (el.tagName === 'SELECT') {
889
+ el.removeEventListener('change', vm.handleInputable);
890
+ } else {
891
+ if (el.type === 'checkbox') {
892
+ el.removeEventListener('change', vm.handleInputable);
893
+ } else {
894
+ el.removeEventListener('input', vm.handleInputable);
895
+ }
896
+ }
897
+ };
898
+
899
+ return SingleElement
900
+ };
901
+
902
+ function getSelectValue (el) {
903
+ var value = [];
904
+ for (var i = 0, l = el.options.length; i < l; i++) {
905
+ var option = el.options[i];
906
+ if (!option.disabled && option.selected) {
907
+ value.push(option.value);
908
+ }
909
+ }
910
+ return value
911
+ }
912
+
913
+ /* */
914
+
915
+ var MultiElementClass = function (Vue) {
916
+ var ref = Vue.util;
917
+ var looseEqual = ref.looseEqual;
918
+
919
+ var MultiElement = function MultiElement (vm) {
920
+ // TODO: should be checked whether included radio or checkbox
921
+ this._vm = vm;
922
+ this.initValue = this.getValue();
923
+ this.attachValidity();
924
+ };
925
+
926
+ MultiElement.prototype.attachValidity = function attachValidity () {
927
+ var this$1 = this;
928
+
929
+ this._vm.$el.$validity = this._vm;
930
+ this._eachItems(function (item) {
931
+ item.$validity = this$1._vm;
932
+ });
933
+ };
934
+
935
+ MultiElement.prototype.getValue = function getValue () {
936
+ return this._getCheckedValue()
937
+ };
938
+
939
+ MultiElement.prototype.checkModified = function checkModified () {
940
+ return !looseEqual(this.initValue, this._getCheckedValue())
941
+ };
942
+
943
+ MultiElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
944
+ var this$1 = this;
945
+
946
+ this._eachItems(function (item) {
947
+ item.addEventListener('focusout', this$1._vm.willUpdateTouched);
948
+ });
949
+ };
950
+
951
+ MultiElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
952
+ var this$1 = this;
953
+
954
+ this._eachItems(function (item) {
955
+ item.removeEventListener('focusout', this$1._vm.willUpdateTouched);
956
+ });
957
+ };
958
+
959
+ MultiElement.prototype.listenInputableEvent = function listenInputableEvent () {
960
+ var this$1 = this;
961
+
962
+ this._eachItems(function (item) {
963
+ item.addEventListener('change', this$1._vm.handleInputable);
964
+ });
965
+ };
966
+
967
+ MultiElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
968
+ var this$1 = this;
969
+
970
+ this._eachItems(function (item) {
971
+ item.removeEventListener('change', this$1._vm.handleInputable);
972
+ });
973
+ };
974
+
975
+ MultiElement.prototype._getCheckedValue = function _getCheckedValue () {
976
+ var value = [];
977
+ this._eachItems(function (item) {
978
+ if (!item.disabled && item.checked) {
979
+ value.push(item.value);
980
+ }
981
+ });
982
+ return value
983
+ };
984
+
985
+ MultiElement.prototype._getItems = function _getItems () {
986
+ return this._vm.$el.querySelectorAll('input[type="checkbox"], input[type="radio"]')
987
+ };
988
+
989
+ MultiElement.prototype._eachItems = function _eachItems (cb) {
990
+ var items = this._getItems();
991
+ for (var i = 0; i < items.length; i++) {
992
+ cb(items[i]);
993
+ }
994
+ };
995
+
996
+ return MultiElement
997
+ };
998
+
999
+ /* */
1000
+
1001
+ var inBrowser =
1002
+ typeof window !== 'undefined' &&
1003
+ Object.prototype.toString.call(window) !== '[object Object]';
1004
+ var UA = inBrowser && window.navigator.userAgent.toLowerCase();
1005
+ var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
1006
+
1007
+ function getClass (el) {
1008
+ var classname = el.className;
1009
+ if (typeof classname === 'object') {
1010
+ classname = classname.baseVal || '';
1011
+ }
1012
+ return classname
1013
+ }
1014
+
1015
+ function setClass (el, cls) {
1016
+ if (isIE9 && !/svg$/.test(el.namespaceURI)) {
1017
+ el.className = cls;
1018
+ } else {
1019
+ el.setAttribute('class', cls);
1020
+ }
1021
+ }
1022
+
1023
+ function addClass (el, cls) {
1024
+ if (el.classList) {
1025
+ el.classList.add(cls);
1026
+ } else {
1027
+ var cur = ' ' + getClass(el) + ' ';
1028
+ if (cur.indexOf(' ' + cls + ' ') < 0) {
1029
+ setClass(el, (cur + cls).trim());
1030
+ }
1031
+ }
1032
+ }
1033
+
1034
+ function removeClass (el, cls) {
1035
+ if (el.classList) {
1036
+ el.classList.remove(cls);
1037
+ } else {
1038
+ var cur = ' ' + getClass(el) + ' ';
1039
+ var tar = ' ' + cls + ' ';
1040
+ while (cur.indexOf(tar) >= 0) {
1041
+ cur = cur.replace(tar, ' ');
1042
+ }
1043
+ setClass(el, cur.trim());
1044
+ }
1045
+ if (!el.className) {
1046
+ el.removeAttribute('class');
1047
+ }
1048
+ }
1049
+
1050
+ function toggleClasses (el, key, fn) {
1051
+ if (!el) { return }
1052
+
1053
+ key = key.trim();
1054
+ if (key.indexOf(' ') === -1) {
1055
+ fn(el, key);
1056
+ return
1057
+ }
1058
+
1059
+ var keys = key.split(/\s+/);
1060
+ for (var i = 0, l = keys.length; i < l; i++) {
1061
+ fn(el, keys[i]);
1062
+ }
1063
+ }
1064
+
1065
+ function memoize (fn) {
1066
+ var cache = Object.create(null);
1067
+ return function memoizeFn (id) {
1068
+ var args = [], len = arguments.length - 1;
1069
+ while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
1070
+
1071
+ var hit = cache[id];
1072
+ return hit || (cache[id] = fn.apply(void 0, args))
1073
+ }
1074
+ }
1075
+
1076
+ /* */
1077
+ var ComponentElementClass = function (Vue) {
1078
+ var ref = Vue.util;
1079
+ var looseEqual = ref.looseEqual;
1080
+ var isPlainObject = ref.isPlainObject;
1081
+
1082
+ function getValidatorProps (validators) {
1083
+ var normalized = typeof validators === 'string' ? [validators] : validators;
1084
+ var targets = [];
1085
+ if (isPlainObject(normalized)) {
1086
+ Object.keys(normalized).forEach(function (validator) {
1087
+ var props = (normalized[validator] &&
1088
+ normalized[validator]['props'] &&
1089
+ isPlainObject(normalized[validator]['props']))
1090
+ ? normalized[validator]['props']
1091
+ : null;
1092
+ if (props) {
1093
+ Object.keys(props).forEach(function (prop) {
1094
+ if (!~targets.indexOf(prop)) {
1095
+ targets.push(prop);
1096
+ }
1097
+ });
1098
+ }
1099
+ });
1100
+ }
1101
+ return targets
1102
+ }
1103
+
1104
+ var ComponentElement = function ComponentElement (vm, vnode, validatorProps) {
1105
+ this._vm = vm;
1106
+ this._vnode = vnode;
1107
+ this._validatorProps = validatorProps || memoize(getValidatorProps);
1108
+ this.initValue = this.getValue();
1109
+ this._watchers = [];
1110
+ this.attachValidity();
1111
+ };
1112
+
1113
+ ComponentElement.prototype.attachValidity = function attachValidity () {
1114
+ this._vm.$el.$validity = this._vm;
1115
+ };
1116
+
1117
+ ComponentElement.prototype.getValidatorProps = function getValidatorProps$1 () {
1118
+ var vm = this._vm;
1119
+ return this._validatorProps(vm._uid.toString(), vm.validators)
1120
+ };
1121
+
1122
+ ComponentElement.prototype.getValue = function getValue () {
1123
+ var this$1 = this;
1124
+
1125
+ var value = {};
1126
+ this.getValidatorProps().forEach(function (prop) {
1127
+ value[prop] = this$1._vnode.child[prop];
1128
+ });
1129
+ return value
1130
+ };
1131
+
1132
+ ComponentElement.prototype.checkModified = function checkModified () {
1133
+ return !looseEqual(this.initValue, this.getValue())
1134
+ };
1135
+
1136
+ ComponentElement.prototype.listenToucheableEvent = function listenToucheableEvent () {
1137
+ this._vm.$el.addEventListener('focusout', this._vm.willUpdateTouched);
1138
+ };
1139
+
1140
+ ComponentElement.prototype.unlistenToucheableEvent = function unlistenToucheableEvent () {
1141
+ this._vm.$el.removeEventListener('focusout', this._vm.willUpdateTouched);
1142
+ };
1143
+
1144
+ ComponentElement.prototype.listenInputableEvent = function listenInputableEvent () {
1145
+ var this$1 = this;
1146
+
1147
+ this.getValidatorProps().forEach(function (prop) {
1148
+ this$1._watchers.push(this$1._vnode.child.$watch(prop, this$1._vm.watchInputable));
1149
+ });
1150
+ };
1151
+
1152
+ ComponentElement.prototype.unlistenInputableEvent = function unlistenInputableEvent () {
1153
+ this._watchers.forEach(function (watcher) { watcher(); });
1154
+ this._watchers = [];
1155
+ };
1156
+
1157
+ return ComponentElement
1158
+ };
1159
+
1160
+ /* */
1161
+ var Elements = function (Vue) {
1162
+ var SingleElement = SingleElementClass(Vue);
1163
+ var MultiElement = MultiElementClass(Vue);
1164
+ var ComponentElement = ComponentElementClass(Vue);
1165
+
1166
+ return {
1167
+ SingleElement: SingleElement,
1168
+ MultiElement: MultiElement,
1169
+ ComponentElement: ComponentElement
1170
+ }
1171
+ };
1172
+
1173
+ /* */
1174
+ var Lifecycles = function (Vue) {
1175
+ var ref = Elements(Vue);
1176
+ var SingleElement = ref.SingleElement;
1177
+ var MultiElement = ref.MultiElement;
1178
+ var ComponentElement = ref.ComponentElement;
1179
+
1180
+ function createValidityElement (vm, vnode) {
1181
+ return vm.multiple
1182
+ ? new MultiElement(vm)
1183
+ : checkBuiltInElement(vnode)
1184
+ ? new SingleElement(vm)
1185
+ : checkComponentElement(vnode)
1186
+ ? new ComponentElement(vm, vnode)
1187
+ : null
1188
+ }
1189
+
1190
+ function watchModelable (val) {
1191
+ this.$emit('input', {
1192
+ result: this.result,
1193
+ progress: this.progress,
1194
+ progresses: this.progresses
1195
+ });
1196
+ }
1197
+
1198
+ function created () {
1199
+ this._elementable = null;
1200
+
1201
+ this._keysCached = memoize(function (results) {
1202
+ return Object.keys(results)
1203
+ });
1204
+
1205
+ // for event control flags
1206
+ this._modified = false;
1207
+
1208
+ // watch validation raw results
1209
+ this._watchValidationRawResults();
1210
+
1211
+ var validation = this.$options.propsData ? this.$options.propsData.validation : null;
1212
+ if (validation) {
1213
+ var instance = validation.instance;
1214
+ var name = validation.name;
1215
+ var group = this.group;
1216
+ instance.register(this.field, this, { named: name, group: group });
1217
+ }
1218
+ }
1219
+
1220
+ function destroyed () {
1221
+ var validation = this.$options.propsData ? this.$options.propsData.validation : null;
1222
+ if (validation) {
1223
+ var instance = validation.instance;
1224
+ var name = validation.name;
1225
+ var group = this.group;
1226
+ instance.unregister(this.field, { named: name, group: group });
1227
+ }
1228
+
1229
+ if (this._unwatchResultProp) {
1230
+ this._unwatchResultProp();
1231
+ this._unwatchResultProp = null;
1232
+ }
1233
+
1234
+ if (this._unwatchProgressProp) {
1235
+ this._unwatchProgressProp();
1236
+ this._unwatchProgressProp = null;
1237
+ }
1238
+
1239
+ this._unwatchValidationRawResults();
1240
+
1241
+ this._elementable.unlistenInputableEvent();
1242
+ if (this.autotouch === 'on') {
1243
+ this._elementable.unlistenToucheableEvent();
1244
+ }
1245
+ this._elementable = null;
1246
+ }
1247
+
1248
+ function mounted () {
1249
+ this._elementable = createValidityElement(this, this._vnode);
1250
+ if (this._elementable) {
1251
+ if (this.autotouch === 'on') {
1252
+ this._elementable.listenToucheableEvent();
1253
+ }
1254
+ this._elementable.listenInputableEvent();
1255
+ } else {
1256
+ // TODO: should be warn
1257
+ }
1258
+
1259
+ if (hasModelDirective(this.$vnode)) {
1260
+ this._unwatchResultProp = this.$watch('result', watchModelable);
1261
+ this._unwatchProgressProp = this.$watch('progress', watchModelable);
1262
+ }
1263
+
1264
+ toggleClasses(this.$el, this.classes.untouched, addClass);
1265
+ toggleClasses(this.$el, this.classes.pristine, addClass);
1266
+ }
1267
+
1268
+ return {
1269
+ created: created,
1270
+ destroyed: destroyed,
1271
+ mounted: mounted
1272
+ }
1273
+ };
1274
+
1275
+ function checkComponentElement (vnode) {
1276
+ return vnode.child &&
1277
+ vnode.componentOptions &&
1278
+ vnode.tag &&
1279
+ vnode.tag.match(/vue-component/)
1280
+ }
1281
+
1282
+ function checkBuiltInElement (vnode) {
1283
+ return !vnode.child &&
1284
+ !vnode.componentOptions &&
1285
+ vnode.tag
1286
+ }
1287
+
1288
+ function hasModelDirective (vnode) {
1289
+ return ((vnode && vnode.data && vnode.data.directives) || []).find(function (dir) { return dir.name === 'model'; })
1290
+ }
1291
+
1292
+ /* */
1293
+
1294
+ var Event = function (Vue) {
1295
+ function _fireEvent (type) {
1296
+ var args = [], len = arguments.length - 1;
1297
+ while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
1298
+
1299
+ (ref = this).$emit.apply(ref, [ type ].concat( args ));
1300
+ var ref;
1301
+ }
1302
+
1303
+ return {
1304
+ _fireEvent: _fireEvent
1305
+ }
1306
+ };
1307
+
1308
+ /* */
1309
+ var State = function (Vue) {
1310
+ var ref = Vue.util;
1311
+ var isPlainObject = ref.isPlainObject;
1312
+
1313
+ function getValue (options) {
1314
+ return this._elementable.getValue()
1315
+ }
1316
+
1317
+ function checkModified () {
1318
+ return this._elementable.checkModified()
1319
+ }
1320
+
1321
+ function willUpdateTouched (options) {
1322
+ if (!this.touched) {
1323
+ this.touched = true;
1324
+ toggleClasses(this.$el, this.classes.touched, addClass);
1325
+ toggleClasses(this.$el, this.classes.untouched, removeClass);
1326
+ this._fireEvent('touched');
1327
+ }
1328
+ }
1329
+
1330
+ function willUpdateDirty () {
1331
+ if (!this.dirty && this.checkModified()) {
1332
+ this.dirty = true;
1333
+ toggleClasses(this.$el, this.classes.dirty, addClass);
1334
+ toggleClasses(this.$el, this.classes.pristine, removeClass);
1335
+ this._fireEvent('dirty');
1336
+ }
1337
+ }
1338
+
1339
+ function willUpdateModified () {
1340
+ var modified = this.modified = this.checkModified();
1341
+ if (this._modified !== modified) {
1342
+ this._modified = modified;
1343
+ toggleClasses(this.$el, this.classes.modified, modified ? addClass : removeClass);
1344
+ this._fireEvent('modified', modified);
1345
+ }
1346
+ }
1347
+
1348
+ function handleInputable (e) {
1349
+ this.willUpdateDirty();
1350
+ this.willUpdateModified();
1351
+ }
1352
+
1353
+ function watchInputable (val) {
1354
+ this.willUpdateDirty();
1355
+ this.willUpdateModified();
1356
+ }
1357
+
1358
+ function _initStates (keys, target, init) {
1359
+ if ( init === void 0 ) init = undefined;
1360
+
1361
+ for (var i = 0; i < keys.length; i++) {
1362
+ var result = target[keys[i]];
1363
+ if (isPlainObject(result)) {
1364
+ var nestedKeys = Object.keys(result);
1365
+ _initStates(nestedKeys, result, init);
1366
+ } else {
1367
+ target[keys[i]] = init;
1368
+ }
1369
+ }
1370
+ }
1371
+
1372
+ function reset () {
1373
+ this._unwatchValidationRawResults();
1374
+ var keys = this._keysCached(this._uid.toString(), this.results);
1375
+ _initStates(keys, this.results, undefined);
1376
+ _initStates(keys, this.progresses, '');
1377
+ toggleClasses(this.$el, this.classes.valid, removeClass);
1378
+ toggleClasses(this.$el, this.classes.invalid, removeClass);
1379
+ toggleClasses(this.$el, this.classes.touched, removeClass);
1380
+ toggleClasses(this.$el, this.classes.untouched, addClass);
1381
+ toggleClasses(this.$el, this.classes.dirty, removeClass);
1382
+ toggleClasses(this.$el, this.classes.pristine, addClass);
1383
+ toggleClasses(this.$el, this.classes.modified, removeClass);
1384
+ this.valid = true;
1385
+ this.dirty = false;
1386
+ this.touched = false;
1387
+ this.modified = false;
1388
+ this._modified = false;
1389
+ this._watchValidationRawResults();
1390
+ }
1391
+
1392
+ function _walkValid (keys, target) {
1393
+ var valid = true;
1394
+ for (var i = 0; i < keys.length; i++) {
1395
+ var result = target[keys[i]];
1396
+ if (typeof result === 'boolean' && !result) {
1397
+ valid = false;
1398
+ break
1399
+ }
1400
+ if (typeof result === 'string' && result) {
1401
+ valid = false;
1402
+ break
1403
+ }
1404
+ if (isPlainObject(result)) {
1405
+ var nestedKeys = Object.keys(result);
1406
+ valid = _walkValid(nestedKeys, result);
1407
+ if (!valid) {
1408
+ break
1409
+ }
1410
+ }
1411
+ }
1412
+ return valid
1413
+ }
1414
+
1415
+ function _watchValidationRawResults () {
1416
+ var this$1 = this;
1417
+
1418
+ this._unwatchResults = this.$watch('results', function (val) {
1419
+ this$1.valid = _walkValid(
1420
+ this$1._keysCached(this$1._uid.toString(), this$1.results),
1421
+ this$1.results
1422
+ );
1423
+ if (this$1.valid) {
1424
+ toggleClasses(this$1.$el, this$1.classes.valid, addClass);
1425
+ toggleClasses(this$1.$el, this$1.classes.invalid, removeClass);
1426
+ } else {
1427
+ toggleClasses(this$1.$el, this$1.classes.valid, removeClass);
1428
+ toggleClasses(this$1.$el, this$1.classes.invalid, addClass);
1429
+ }
1430
+
1431
+ this$1._fireEvent(this$1.valid ? 'valid' : 'invalid');
1432
+ }, { deep: true });
1433
+ }
1434
+
1435
+ function _unwatchValidationRawResults () {
1436
+ this._unwatchResults();
1437
+ this._unwatchResults = undefined;
1438
+ delete this._unwatchResults;
1439
+ }
1440
+
1441
+ function touch () {
1442
+ this.willUpdateTouched();
1443
+ }
1444
+
1445
+ return {
1446
+ getValue: getValue,
1447
+ checkModified: checkModified,
1448
+ willUpdateTouched: willUpdateTouched,
1449
+ willUpdateDirty: willUpdateDirty,
1450
+ willUpdateModified: willUpdateModified,
1451
+ handleInputable: handleInputable,
1452
+ watchInputable: watchInputable,
1453
+ reset: reset,
1454
+ _walkValid: _walkValid,
1455
+ _watchValidationRawResults: _watchValidationRawResults,
1456
+ _unwatchValidationRawResults: _unwatchValidationRawResults,
1457
+ touch: touch
1458
+ }
1459
+ };
1460
+
1461
+ /* */
1462
+
1463
+ /**
1464
+ * Forgiving check for a promise
1465
+ */
1466
+ function isPromise (p) {
1467
+ return p && typeof p.then === 'function'
1468
+ }
1469
+
1470
+ var Validate = function (Vue) {
1471
+ var ref = Vue.util;
1472
+ var extend = ref.extend;
1473
+ var isPlainObject = ref.isPlainObject;
1474
+ var resolveAsset = ref.resolveAsset;
1475
+
1476
+ function _resolveValidator (name) {
1477
+ var options = (this.child && this.child.context)
1478
+ ? this.child.context.$options
1479
+ : this.$options;
1480
+ return resolveAsset(options, 'validators', name)
1481
+ }
1482
+
1483
+ function _getValidateRawDescriptor (
1484
+ validator,
1485
+ field,
1486
+ value
1487
+ ) {
1488
+ var asset = this._resolveValidator(validator);
1489
+ if (!asset) {
1490
+ // TODO: should be warned
1491
+ return null
1492
+ }
1493
+
1494
+ var fn = null;
1495
+ var rule = null;
1496
+ var msg = null;
1497
+ if (isPlainObject(asset)) {
1498
+ if (asset.check && typeof asset.check === 'function') {
1499
+ fn = asset.check;
1500
+ }
1501
+ if (asset.message) {
1502
+ msg = asset.message;
1503
+ }
1504
+ } else if (typeof asset === 'function') {
1505
+ fn = asset;
1506
+ } else {
1507
+ // TODO: should be warned
1508
+ return null
1509
+ }
1510
+
1511
+ if (!fn) {
1512
+ // TODO: should be warned
1513
+ return null
1514
+ }
1515
+
1516
+ var props = null;
1517
+ var validators = this.validators;
1518
+ if (isPlainObject(validators)) {
1519
+ if (isPlainObject(validators[validator])) {
1520
+ if (validators[validator].props && isPlainObject(validators[validator].props)) {
1521
+ props = validators[validator].props;
1522
+ } else {
1523
+ if (validators[validator].rule) {
1524
+ rule = validators[validator].rule;
1525
+ }
1526
+ if (validators[validator].message) {
1527
+ msg = validators[validator].message;
1528
+ }
1529
+ }
1530
+ } else {
1531
+ rule = validators[validator];
1532
+ }
1533
+ }
1534
+
1535
+ var descriptor = { fn: fn, value: value, field: field };
1536
+ if (rule) {
1537
+ descriptor.rule = rule;
1538
+ }
1539
+ if (msg) {
1540
+ descriptor.msg = msg;
1541
+ }
1542
+ if (props) {
1543
+ descriptor.props = props;
1544
+ }
1545
+
1546
+ return descriptor
1547
+ }
1548
+
1549
+ function _resolveMessage (
1550
+ field,
1551
+ msg,
1552
+ override
1553
+ ) {
1554
+ if (override) { return override }
1555
+ return msg
1556
+ ? typeof msg === 'function'
1557
+ ? msg(field)
1558
+ : msg
1559
+ : undefined
1560
+ }
1561
+
1562
+ function _invokeValidator (
1563
+ ref,
1564
+ value,
1565
+ cb
1566
+ ) {
1567
+ var this$1 = this;
1568
+ var fn = ref.fn;
1569
+ var field = ref.field;
1570
+ var rule = ref.rule;
1571
+ var msg = ref.msg;
1572
+
1573
+ var future = fn.call(this.child.context, value, rule);
1574
+ if (typeof future === 'function') { // function
1575
+ future(function () { // resolve
1576
+ cb(true);
1577
+ }, function (err) { // reject
1578
+ cb(false, this$1._resolveMessage(field, msg, err));
1579
+ });
1580
+ } else if (isPromise(future)) { // promise
1581
+ future.then(function () { // resolve
1582
+ cb(true);
1583
+ }, function (err) { // reject
1584
+ cb(false, this$1._resolveMessage(field, msg, err));
1585
+ }).catch(function (err) {
1586
+ cb(false, this$1._resolveMessage(field, msg, err.message));
1587
+ });
1588
+ } else { // sync
1589
+ cb(future, future === false ? this._resolveMessage(field, msg) : undefined);
1590
+ }
1591
+ }
1592
+
1593
+ function _getValidateDescriptors (
1594
+ validator,
1595
+ field,
1596
+ value
1597
+ ) {
1598
+ var descriptors = [];
1599
+
1600
+ var rawDescriptor = this._getValidateRawDescriptor(validator, this.field, value);
1601
+ if (!rawDescriptor) { return descriptors }
1602
+
1603
+ if (!rawDescriptor.props) {
1604
+ var descriptor = { name: validator };
1605
+ extend(descriptor, rawDescriptor);
1606
+ descriptors.push(descriptor);
1607
+ } else {
1608
+ var propsKeys = Object.keys(!rawDescriptor.props);
1609
+ propsKeys.forEach(function (prop) {
1610
+ var descriptor = {
1611
+ fn: rawDescriptor.fn,
1612
+ name: validator,
1613
+ value: rawDescriptor.value[prop],
1614
+ field: rawDescriptor.field,
1615
+ prop: prop
1616
+ };
1617
+ if (rawDescriptor.props[prop].rule) {
1618
+ descriptor.rule = rawDescriptor.props[prop].rule;
1619
+ }
1620
+ if (rawDescriptor.props[prop].message) {
1621
+ descriptor.msg = rawDescriptor.props[prop].message;
1622
+ }
1623
+ descriptors.push(descriptor);
1624
+ });
1625
+ }
1626
+
1627
+ return descriptors
1628
+ }
1629
+
1630
+ function _syncValidates (field, cb) {
1631
+ var this$1 = this;
1632
+
1633
+ var validators = this._keysCached(this._uid.toString(), this.results);
1634
+ var value = this.getValue();
1635
+ var descriptors = [];
1636
+ validators.forEach(function (validator) {
1637
+ this$1._getValidateDescriptors(validator, field, value).forEach(function (desc) {
1638
+ descriptors.push(desc);
1639
+ });
1640
+ });
1641
+
1642
+ var count = 0;
1643
+ var len = descriptors.length;
1644
+ descriptors.forEach(function (desc) {
1645
+ var validator = desc.name;
1646
+ var prop = desc.prop;
1647
+ if ((!prop && this$1.progresses[validator]) || (prop && this$1.progresses[validator][prop])) {
1648
+ count++;
1649
+ if (count === len) {
1650
+ cb(this$1._walkValid(this$1._keysCached(this$1._uid.toString(), this$1.results), this$1.results));
1651
+ }
1652
+ return
1653
+ }
1654
+
1655
+ if (!prop) {
1656
+ this$1.progresses[validator] = 'running';
1657
+ } else {
1658
+ this$1.progresses[validator][prop] = 'running';
1659
+ }
1660
+
1661
+ this$1.$nextTick(function () {
1662
+ this$1._invokeValidator(desc, desc.value, function (ret, msg) {
1663
+ if (!prop) {
1664
+ this$1.progresses[validator] = '';
1665
+ this$1.results[validator] = msg || ret;
1666
+ } else {
1667
+ this$1.progresses[validator][prop] = '';
1668
+ this$1.results[validator][prop] = msg || ret;
1669
+ }
1670
+
1671
+ count++;
1672
+ if (count === len) {
1673
+ cb(this$1._walkValid(this$1._keysCached(this$1._uid.toString(), this$1.results), this$1.results));
1674
+ }
1675
+ });
1676
+ });
1677
+ });
1678
+ }
1679
+
1680
+ // TODO:should be refactor!!
1681
+ function _validate (validator, value, cb) {
1682
+ var this$1 = this;
1683
+
1684
+ var descriptor = this._getValidateRawDescriptor(validator, this.field, value);
1685
+ if (descriptor && !descriptor.props) {
1686
+ if (this.progresses[validator]) { return false }
1687
+ this.progresses[validator] = 'running';
1688
+ this.$nextTick(function () {
1689
+ this$1._invokeValidator(descriptor, descriptor.value, function (ret, msg) {
1690
+ this$1.progresses[validator] = '';
1691
+ this$1.results[validator] = msg || ret;
1692
+ if (cb) {
1693
+ this$1.$nextTick(function () {
1694
+ cb.call(this$1, null, ret, msg);
1695
+ });
1696
+ } else {
1697
+ var e = { result: ret };
1698
+ if (msg) {
1699
+ e['msg'] = msg;
1700
+ }
1701
+ this$1._fireEvent('validate', validator, e);
1702
+ }
1703
+ });
1704
+ });
1705
+ } else if (descriptor && descriptor.props) {
1706
+ var propsKeys = Object.keys(descriptor.props);
1707
+ propsKeys.forEach(function (prop) {
1708
+ if (this$1.progresses[validator][prop]) { return }
1709
+ this$1.progresses[validator][prop] = 'running';
1710
+ var values = descriptor.value;
1711
+ var propDescriptor = {
1712
+ fn: descriptor.fn,
1713
+ value: values[prop],
1714
+ field: descriptor.field
1715
+ };
1716
+ if (descriptor.props[prop].rule) {
1717
+ propDescriptor.rule = descriptor.props[prop].rule;
1718
+ }
1719
+ if (descriptor.props[prop].message) {
1720
+ propDescriptor.msg = descriptor.props[prop].message;
1721
+ }
1722
+ this$1.$nextTick(function () {
1723
+ this$1._invokeValidator(propDescriptor, propDescriptor.value, function (result, msg) {
1724
+ this$1.progresses[validator][prop] = '';
1725
+ this$1.results[validator][prop] = msg || result;
1726
+ var e = { prop: prop, result: result };
1727
+ if (msg) {
1728
+ e['msg'] = msg;
1729
+ }
1730
+ this$1._fireEvent('validate', validator, e);
1731
+ });
1732
+ });
1733
+ });
1734
+ } else {
1735
+ // TODO:
1736
+ var err = new Error();
1737
+ cb ? cb.call(this, err) : this._fireEvent('validate', validator, err);
1738
+ }
1739
+ return true
1740
+ }
1741
+
1742
+ // TODO: should be re-design of API
1743
+ function validate () {
1744
+ var this$1 = this;
1745
+ var args = [], len = arguments.length;
1746
+ while ( len-- ) args[ len ] = arguments[ len ];
1747
+
1748
+ var validators;
1749
+ var value;
1750
+ var cb;
1751
+ var ret = true;
1752
+
1753
+ if (args.length === 3) {
1754
+ validators = [args[0]];
1755
+ value = args[1];
1756
+ cb = args[2];
1757
+ } else if (args.length === 2) {
1758
+ if (isPlainObject(args[0])) {
1759
+ validators = [args[0].validator];
1760
+ value = args[0].value || this.getValue();
1761
+ cb = args[1];
1762
+ } else {
1763
+ validators = this._keysCached(this._uid.toString(), this.results);
1764
+ value = args[0];
1765
+ cb = args[1];
1766
+ }
1767
+ } else if (args.length === 1) {
1768
+ validators = this._keysCached(this._uid.toString(), this.results);
1769
+ value = this.getValue();
1770
+ cb = args[0];
1771
+ } else {
1772
+ validators = this._keysCached(this._uid.toString(), this.results);
1773
+ value = this.getValue();
1774
+ cb = null;
1775
+ }
1776
+
1777
+ if (args.length === 3 || (args.length === 2 && isPlainObject(args[0]))) {
1778
+ ret = this._validate(validators[0], value, cb);
1779
+ } else {
1780
+ validators.forEach(function (validator) {
1781
+ ret = this$1._validate(validator, value, cb);
1782
+ });
1783
+ }
1784
+
1785
+ return ret
1786
+ }
1787
+
1788
+ return {
1789
+ _resolveValidator: _resolveValidator,
1790
+ _getValidateRawDescriptor: _getValidateRawDescriptor,
1791
+ _getValidateDescriptors: _getValidateDescriptors,
1792
+ _resolveMessage: _resolveMessage,
1793
+ _invokeValidator: _invokeValidator,
1794
+ _validate: _validate,
1795
+ _syncValidates: _syncValidates,
1796
+ validate: validate
1797
+ }
1798
+ };
1799
+
1800
+ /* */
1801
+
1802
+ var Methods = function (Vue) {
1803
+ var ref = Vue.util;
1804
+ var extend = ref.extend;
1805
+
1806
+ var methods = {};
1807
+ extend(methods, Event(Vue));
1808
+ extend(methods, State(Vue));
1809
+ extend(methods, Validate(Vue));
1810
+
1811
+ return methods
1812
+ };
1813
+
1814
+ /* */
1815
+
1816
+ var ValidityControl = function (Vue) {
1817
+ var ref = Vue.util;
1818
+ var extend = ref.extend;
1819
+
1820
+ var ref$1 = States(Vue);
1821
+ var props = ref$1.props;
1822
+ var data = ref$1.data;
1823
+ var computed = Computed(Vue);
1824
+ var lifecycles = Lifecycles(Vue);
1825
+ var ref$2 = Render(Vue);
1826
+ var render = ref$2.render;
1827
+ var methods = Methods(Vue);
1828
+
1829
+ var validity = {
1830
+ props: props,
1831
+ data: data,
1832
+ render: render,
1833
+ computed: computed,
1834
+ methods: methods
1835
+ };
1836
+ extend(validity, lifecycles);
1837
+
1838
+ return validity
1839
+ };
1840
+
1841
+ /* */
1842
+ var Validity = function (Vue) {
1843
+ var ref = Vue.util;
1844
+ var extend = ref.extend;
1845
+
1846
+ return {
1847
+ functional: true,
1848
+ props: baseProps,
1849
+ render: function render (
1850
+ h,
1851
+ ref
1852
+ ) {
1853
+ var props = ref.props;
1854
+ var data = ref.data;
1855
+ var children = ref.children;
1856
+
1857
+ return children.map(function (child) {
1858
+ if (!child.tag) { return child }
1859
+ var newData = extend({}, data);
1860
+ newData.props = extend({}, props);
1861
+ // TODO: should be refactored
1862
+ newData.props.classes = extend(extend(extend({}, DEFAULT_CLASSES), Vue.config.validator.classes), newData.props.classes);
1863
+ newData.props.child = child;
1864
+ return h('validity-control', newData)
1865
+ })
1866
+ }
1867
+ }
1868
+ };
1869
+
1870
+ /* */
1871
+ var ValidityGroup = function (Vue) {
1872
+ var ref = Vue.util;
1873
+ var extend = ref.extend;
1874
+
1875
+ var props = extend({
1876
+ tag: {
1877
+ type: String,
1878
+ default: 'fieldset'
1879
+ }
1880
+ }, baseProps);
1881
+
1882
+ return {
1883
+ functional: true,
1884
+ props: props,
1885
+ render: function render (
1886
+ h,
1887
+ ref
1888
+ ) {
1889
+ var props = ref.props;
1890
+ var data = ref.data;
1891
+ var children = ref.children;
1892
+
1893
+ var child = h(props.tag, children);
1894
+ var newData = extend({}, data);
1895
+ newData.props = extend({}, props);
1896
+ // TODO: should be refactored
1897
+ newData.props.classes = extend(extend(extend({}, DEFAULT_CLASSES), Vue.config.validator.classes), newData.props.classes);
1898
+ newData.props.child = child;
1899
+ newData.props.multiple = true;
1900
+ return h('validity-control', newData)
1901
+ }
1902
+ }
1903
+ };
1904
+
1905
+ /* */
1906
+
1907
+ var Validation = function (Vue) {
1908
+ var ref = Vue.util;
1909
+ var extend = ref.extend;
1910
+
1911
+ return {
1912
+ functional: true,
1913
+ props: {
1914
+ name: {
1915
+ type: String
1916
+ },
1917
+ tag: {
1918
+ type: String,
1919
+ default: 'form'
1920
+ }
1921
+ },
1922
+ render: function render (
1923
+ h,
1924
+ ref
1925
+ ) {
1926
+ var props = ref.props;
1927
+ var data = ref.data;
1928
+ var parent = ref.parent;
1929
+ var children = ref.children;
1930
+ var slots = ref.slots;
1931
+
1932
+ if (!parent._validation) {
1933
+ // TODO: should be warned
1934
+ return children
1935
+ }
1936
+ var tag = props.tag || 'form';
1937
+ walkChildren(parent._validation, props.name, children);
1938
+ var newData = extend({ attrs: {}}, data);
1939
+ if (tag === 'form') {
1940
+ newData.attrs.novalidate = true;
1941
+ }
1942
+ return h(tag, newData, children)
1943
+ }
1944
+ }
1945
+ };
1946
+
1947
+ function walkChildren (validation, name, children) {
1948
+ children.forEach(function (child) {
1949
+ if (child &&
1950
+ child.componentOptions &&
1951
+ child.componentOptions.propsData && child.componentOptions.tag === 'validity-control') {
1952
+ child.componentOptions.propsData.validation = {
1953
+ instance: validation,
1954
+ name: name
1955
+ };
1956
+ }
1957
+ child.children && walkChildren(validation, name, child.children);
1958
+ });
1959
+ }
1960
+
1961
+ /* */
1962
+ var Component = function (Vue) {
1963
+ return {
1964
+ 'validity-control': ValidityControl(Vue),
1965
+ 'validity': Validity(Vue),
1966
+ 'validity-group': ValidityGroup(Vue),
1967
+ 'validation': Validation(Vue)
1968
+ }
1969
+ };
1970
+
1971
+ /* */
1972
+ // TODO: should be defined strict type
1973
+ function mapValidation (results) {
1974
+ var res = {};
1975
+
1976
+ normalizeMap(results).forEach(function (ref) {
1977
+ var key = ref.key;
1978
+ var val = ref.val;
1979
+
1980
+ res[key] = function mappedValidation () {
1981
+ var validation = this.$validation;
1982
+ if (!this._isMounted) {
1983
+ return null
1984
+ }
1985
+ var paths = val.split('.');
1986
+ var first = paths.shift();
1987
+ if (first !== '$validation') {
1988
+ warn(("unknown validation result path: " + val));
1989
+ return null
1990
+ }
1991
+ var path;
1992
+ var value = validation;
1993
+ do {
1994
+ path = paths.shift();
1995
+ value = value[path];
1996
+ } while (paths.length > 0 && value !== undefined)
1997
+ return value
1998
+ };
1999
+ });
2000
+
2001
+ return res
2002
+ }
2003
+
2004
+ // TODO: should be defined strict type
2005
+ function normalizeMap (map) {
2006
+ return Array.isArray(map)
2007
+ ? map.map(function (key) { return ({ key: key, val: key }); })
2008
+ : Object.keys(map).map(function (key) { return ({ key: key, val: map[key] }); })
2009
+ }
2010
+
2011
+ /* */
2012
+ var installed = false;
2013
+
2014
+ function plugin (Vue, options) {
2015
+ if ( options === void 0 ) options = {};
2016
+
2017
+ if (installed) {
2018
+ warn('already installed.');
2019
+ return
2020
+ }
2021
+
2022
+ Config(Vue);
2023
+ Asset(Vue);
2024
+ installMixin(Vue);
2025
+ installComponent(Vue);
2026
+ installed = true;
2027
+ }
2028
+
2029
+ function installMixin (Vue) {
2030
+ Vue.mixin(Mixin(Vue));
2031
+ }
2032
+
2033
+ function installComponent (Vue) {
2034
+ var components = Component(Vue);
2035
+ Object.keys(components).forEach(function (id) {
2036
+ Vue.component(id, components[id]);
2037
+ });
2038
+ }
2039
+
2040
+ plugin.mapValidation = mapValidation; // for standalone
2041
+ plugin.version = '3.0.0-alpha.2';
2042
+
2043
+ if (typeof window !== 'undefined' && window.Vue) {
2044
+ window.Vue.use(plugin);
2045
+ }
2046
+
2047
+ var index = {
2048
+ install: plugin,
2049
+ mapValidation: mapValidation
2050
+ };
2051
+
2052
+ return index;
2053
+
2054
+ })));