vueonrails 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (58) hide show
  1. checksums.yaml +7 -0
  2. data/README.md +70 -0
  3. data/app/controllers/vue_controller.rb +2 -0
  4. data/app/helpers/syntax_helper.rb +28 -0
  5. data/app/views/vue/index.html.erb +1 -0
  6. data/config/routes.rb +5 -0
  7. data/lib/generators/generator_templates/packs/index.css +4 -0
  8. data/lib/generators/generator_templates/packs/index.js +30 -0
  9. data/lib/generators/generator_templates/packs/index.vue +13 -0
  10. data/lib/generators/generator_templates/packs/pack.js.erb +18 -0
  11. data/lib/generators/generator_templates/sfc/single-file-component.vue +45 -0
  12. data/lib/generators/generator_templates/tests/unit.test.js.erb +17 -0
  13. data/lib/generators/generator_templates/turbolinks/turbolinks-pack.js.erb +23 -0
  14. data/lib/generators/options/click.rb +10 -0
  15. data/lib/generators/options/form.rb +19 -0
  16. data/lib/generators/options/list.rb +32 -0
  17. data/lib/generators/options/modal.rb +26 -0
  18. data/lib/generators/options/seperate.rb +5 -0
  19. data/lib/generators/options/single.rb +3 -0
  20. data/lib/generators/options/table.rb +10 -0
  21. data/lib/generators/options/test.rb +2 -0
  22. data/lib/generators/options/turbolinks-seperate.rb +5 -0
  23. data/lib/generators/options/turbolinks-single.rb +3 -0
  24. data/lib/generators/options/vuex.rb +10 -0
  25. data/lib/generators/vue/USAGE +17 -0
  26. data/lib/generators/vue/vue_generator.rb +60 -0
  27. data/lib/install/Procfile +2 -0
  28. data/lib/install/config/alias.js +9 -0
  29. data/lib/install/setup.rb +78 -0
  30. data/lib/install/spv.rb +20 -0
  31. data/lib/install/test.rb +46 -0
  32. data/lib/install/turbolinks.rb +3 -0
  33. data/lib/install/ui.rb +4 -0
  34. data/lib/install/vuex.rb +12 -0
  35. data/lib/tasks/assets.rake +12 -0
  36. data/lib/tasks/info.rake +21 -0
  37. data/lib/tasks/vue.rake +27 -0
  38. data/lib/vueonrails.rb +13 -0
  39. data/lib/vueonrails/post_message.rb +4 -0
  40. data/lib/vueonrails/version.rb +3 -0
  41. data/vendor/assets/javascripts/axios.js +1545 -0
  42. data/vendor/assets/javascripts/axios.map +1 -0
  43. data/vendor/assets/javascripts/element-ui.js +12 -0
  44. data/vendor/assets/javascripts/vue-resource.js +1531 -0
  45. data/vendor/assets/javascripts/vue-router.js +2709 -0
  46. data/vendor/assets/javascripts/vue-router2.js +2284 -0
  47. data/vendor/assets/javascripts/vue-validator.js +910 -0
  48. data/vendor/assets/javascripts/vue-validator2.js +2615 -0
  49. data/vendor/assets/javascripts/vue-validator3.js +2054 -0
  50. data/vendor/assets/javascripts/vue.js +10237 -0
  51. data/vendor/assets/javascripts/vue.min.js +9 -0
  52. data/vendor/assets/javascripts/vue2.js +8568 -0
  53. data/vendor/assets/javascripts/vue2.min.js +8 -0
  54. data/vendor/assets/javascripts/vueonrails.js +39 -0
  55. data/vendor/assets/javascripts/vuex.js +722 -0
  56. data/vendor/assets/javascripts/vuex2.js +805 -0
  57. data/vendor/assets/stylesheets/element-ui.css +1 -0
  58. metadata +128 -0
@@ -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
+ })));