查看 | 历史 | 提交 | 提交对比
Administrator
2023-04-17 63fbfddabe08e353ad75e495c2ac8dc5203da88c
提交 | 用户 | 时间
58d006 1 /*=============================================================================
A 2     Author:            Eric M. Barnard - @ericmbarnard                                
3     License:        MIT (http://opensource.org/licenses/mit-license.php)        
4                                                                                 
5     Description:    Validation Library for KnockoutJS                            
6     Version:        2.0.1                                            
7 ===============================================================================
8 */
9 /*globals require: false, exports: false, define: false, ko: false */
10
11 (function (factory) {
12     // Module systems magic dance.
13
14     if (typeof require === "function" && typeof exports === "object" && typeof module === "object") {
15         // CommonJS or Node: hard-coded dependency on "knockout"
16         factory(require("knockout"), exports);
17     } else if (typeof define === "function" && define["amd"]) {
18         // AMD anonymous module with hard-coded dependency on "knockout"
19         define(["knockout", "exports"], factory);
20     } else {
21         // <script> tag: use the global `ko` object, attaching a `mapping` property
22         factory(ko, ko.validation = {});
23     }
24 }(function ( ko, exports ) {
25
26     if (typeof (ko) === 'undefined') {
27         throw new Error('Knockout is required, please ensure it is loaded before loading this validation plug-in');
28     }
29
30     // create our namespace object
31     ko.validation = exports;
32
33     var kv = ko.validation,
34         koUtils = ko.utils,
35         unwrap = koUtils.unwrapObservable,
36         forEach = koUtils.arrayForEach,
37         extend = koUtils.extend;
38 ;/*global ko: false*/
39
40 var defaults = {
41     registerExtenders: true,
42     messagesOnModified: true,
43     errorsAsTitle: true,            // enables/disables showing of errors as title attribute of the target element.
44     errorsAsTitleOnModified: false, // shows the error when hovering the input field (decorateElement must be true)
45     messageTemplate: null,
46     insertMessages: true,           // automatically inserts validation messages as <span></span>
47     parseInputAttributes: false,    // parses the HTML5 validation attribute from a form element and adds that to the object
48     writeInputAttributes: false,    // adds HTML5 input validation attributes to form elements that ko observable's are bound to
49     decorateInputElement: false,         // false to keep backward compatibility
50     decorateElementOnModified: true,// true to keep backward compatibility
51     errorClass: null,               // single class for error message and element
52     errorElementClass: 'validationElement',  // class to decorate error element
53     errorMessageClass: 'validationMessage',  // class to decorate error message
54     allowHtmlMessages: false,        // allows HTML in validation messages
55     grouping: {
56         deep: false,        //by default grouping is shallow
57         observable: true,   //and using observables
58         live: false            //react to changes to observableArrays if observable === true
59     },
60     validate: {
61         // throttle: 10
62     }
63 };
64
65 // make a copy  so we can use 'reset' later
66 var configuration = extend({}, defaults);
67
68 configuration.html5Attributes = ['required', 'pattern', 'min', 'max', 'step'];
69 configuration.html5InputTypes = ['email', 'number', 'date'];
70
71 configuration.reset = function () {
72     extend(configuration, defaults);
73 };
74
75 kv.configuration = configuration;
76 ;kv.utils = (function () {
77     var seedId = new Date().getTime();
78
79     var domData = {}; //hash of data objects that we reference from dom elements
80     var domDataKey = '__ko_validation__';
81
82     return {
83         isArray: function (o) {
84             return o.isArray || Object.prototype.toString.call(o) === '[object Array]';
85         },
86         isObject: function (o) {
87             return o !== null && typeof o === 'object';
88         },
89         isNumber: function(o) {
90             return !isNaN(o);    
91         },
92         isObservableArray: function(instance) {
93             return !!instance &&
94                     typeof instance["remove"] === "function" &&
95                     typeof instance["removeAll"] === "function" &&
96                     typeof instance["destroy"] === "function" &&
97                     typeof instance["destroyAll"] === "function" &&
98                     typeof instance["indexOf"] === "function" &&
99                     typeof instance["replace"] === "function";
100         },
101         values: function (o) {
102             var r = [];
103             for (var i in o) {
104                 if (o.hasOwnProperty(i)) {
105                     r.push(o[i]);
106                 }
107             }
108             return r;
109         },
110         getValue: function (o) {
111             return (typeof o === 'function' ? o() : o);
112         },
113         hasAttribute: function (node, attr) {
114             return node.getAttribute(attr) !== null;
115         },
116         getAttribute: function (element, attr) {
117             return element.getAttribute(attr);
118         },
119         setAttribute: function (element, attr, value) {
120             return element.setAttribute(attr, value);
121         },
122         isValidatable: function (o) {
123             return !!(o && o.rules && o.isValid && o.isModified);
124         },
125         insertAfter: function (node, newNode) {
126             node.parentNode.insertBefore(newNode, node.nextSibling);
127         },
128         newId: function () {
129             return seedId += 1;
130         },
131         getConfigOptions: function (element) {
132             var options = kv.utils.contextFor(element);
133
134             return options || kv.configuration;
135         },
136         setDomData: function (node, data) {
137             var key = node[domDataKey];
138
139             if (!key) {
140                 node[domDataKey] = key = kv.utils.newId();
141             }
142
143             domData[key] = data;
144         },
145         getDomData: function (node) {
146             var key = node[domDataKey];
147
148             if (!key) {
149                 return undefined;
150             }
151
152             return domData[key];
153         },
154         contextFor: function (node) {
155             switch (node.nodeType) {
156                 case 1:
157                 case 8:
158                     var context = kv.utils.getDomData(node);
159                     if (context) { return context; }
160                     if (node.parentNode) { return kv.utils.contextFor(node.parentNode); }
161                     break;
162             }
163             return undefined;
164         },
165         isEmptyVal: function (val) {
166             if (val === undefined) {
167                 return true;
168             }
169             if (val === null) {
170                 return true;
171             }
172             if (val === "") {
173                 return true;
174             }
175         },
176         getOriginalElementTitle: function (element) {
177             var savedOriginalTitle = kv.utils.getAttribute(element, 'data-orig-title'),
178                 currentTitle = element.title,
179                 hasSavedOriginalTitle = kv.utils.hasAttribute(element, 'data-orig-title');
180
181             return hasSavedOriginalTitle ?
182                 savedOriginalTitle : currentTitle;
183         },
184         async: function (expr) {
185             if (window.setImmediate) { window.setImmediate(expr); }
186             else { window.setTimeout(expr, 0); }
187         },
188         forEach: function (object, callback) {
189             if (kv.utils.isArray(object)) {
190                 return forEach(object, callback);
191             }
192             for (var prop in object) {
193                 if (object.hasOwnProperty(prop)) {
194                     callback(object[prop], prop);
195                 }
196             }
197         }
198     };
199 }());;var api = (function () {
200
201     var isInitialized = 0,
202         configuration = kv.configuration,
203         utils = kv.utils;
204
205     function cleanUpSubscriptions(context) {
206         forEach(context.subscriptions, function (subscription) {
207             subscription.dispose();
208         });
209         context.subscriptions = [];
210     }
211
212     function dispose(context) {
213         if (context.options.deep) {
214             forEach(context.flagged, function (obj) {
215                 delete obj.__kv_traversed;
216             });
217             context.flagged.length = 0;
218         }
219
220         if (!context.options.live) {
221             cleanUpSubscriptions(context);
222         }
223     }
224
225     function runTraversal(obj, context) {
226         context.validatables = [];
227         cleanUpSubscriptions(context);
228         traverseGraph(obj, context);
229         dispose(context);
230     }
231
232     function traverseGraph(obj, context, level) {
233         var objValues = [],
234             val = obj.peek ? obj.peek() : obj;
235
236         if (obj.__kv_traversed === true) {
237             return;
238         }
239
240         if (context.options.deep) {
241             obj.__kv_traversed = true;
242             context.flagged.push(obj);
243         }
244
245         //default level value depends on deep option.
246         level = (level !== undefined ? level : context.options.deep ? 1 : -1);
247
248         // if object is observable then add it to the list
249         if (ko.isObservable(obj)) {
250             // ensure it's validatable but don't extend validatedObservable because it
251             // would overwrite isValid property.
252             if (!obj.errors && !utils.isValidatable(obj)) {
253                 obj.extend({ validatable: true });
254             }
255             context.validatables.push(obj);
256
257             if (context.options.live && utils.isObservableArray(obj)) {
258                 context.subscriptions.push(obj.subscribe(function () {
259                     context.graphMonitor.valueHasMutated();
260                 }));
261             }
262         }
263
264         //get list of values either from array or object but ignore non-objects
265         // and destroyed objects
266         if (val && !val._destroy) {
267             if (utils.isArray(val)) {
268                 objValues = val;
269             }
270             else if (utils.isObject(val)) {
271                 objValues = utils.values(val);
272             }
273         }
274
275         //process recursively if it is deep grouping
276         if (level !== 0) {
277             utils.forEach(objValues, function (observable) {
278                 //but not falsy things and not HTML Elements
279                 if (observable && !observable.nodeType && (!ko.isComputed(observable) || observable.rules)) {
280                     traverseGraph(observable, context, level + 1);
281                 }
282             });
283         }
284     }
285
286     function collectErrors(array) {
287         var errors = [];
288         forEach(array, function (observable) {
289             // Do not collect validatedObservable errors
290             if (utils.isValidatable(observable) && !observable.isValid()) {
291                 // Use peek because we don't want a dependency for 'error' property because it
292                 // changes before 'isValid' does. (Issue #99)
293                 errors.push(observable.error.peek());
294             }
295         });
296         return errors;
297     }
298
299     return {
300         //Call this on startup
301         //any config can be overridden with the passed in options
302         init: function (options, force) {
303             //done run this multiple times if we don't really want to
304             if (isInitialized > 0 && !force) {
305                 return;
306             }
307
308             //because we will be accessing options properties it has to be an object at least
309             options = options || {};
310             //if specific error classes are not provided then apply generic errorClass
311             //it has to be done on option so that options.errorClass can override default
312             //errorElementClass and errorMessage class but not those provided in options
313             options.errorElementClass = options.errorElementClass || options.errorClass || configuration.errorElementClass;
314             options.errorMessageClass = options.errorMessageClass || options.errorClass || configuration.errorMessageClass;
315
316             extend(configuration, options);
317
318             if (configuration.registerExtenders) {
319                 kv.registerExtenders();
320             }
321
322             isInitialized = 1;
323         },
324
325         // resets the config back to its original state
326         reset: kv.configuration.reset,
327
328         // recursively walks a viewModel and creates an object that
329         // provides validation information for the entire viewModel
330         // obj -> the viewModel to walk
331         // options -> {
332         //      deep: false, // if true, will walk past the first level of viewModel properties
333         //      observable: false // if true, returns a computed observable indicating if the viewModel is valid
334         // }
335         group: function group(obj, options) { // array of observables or viewModel
336             options = extend(extend({}, configuration.grouping), options);
337
338             var context = {
339                 options: options,
340                 graphMonitor: ko.observable(),
341                 flagged: [],
342                 subscriptions: [],
343                 validatables: []
344             };
345
346             var result = null;
347
348             //if using observables then traverse structure once and add observables
349             if (options.observable) {
350                 result = ko.computed(function () {
351                     context.graphMonitor(); //register dependency
352                     runTraversal(obj, context);
353                     return collectErrors(context.validatables);
354                 });
355             }
356             else { //if not using observables then every call to error() should traverse the structure
357                 result = function () {
358                     runTraversal(obj, context);
359                     return collectErrors(context.validatables);
360                 };
361             }
362
363             result.showAllMessages = function (show) { // thanks @heliosPortal
364                 if (show === undefined) {//default to true
365                     show = true;
366                 }
367
368                 result.forEach(function (observable) {
369                     if (utils.isValidatable(observable)) {
370                         observable.isModified(show);
371                     }
372                 });
373             };
374
375             result.isAnyMessageShown = function () {
376                 var invalidAndModifiedPresent;
377
378                 invalidAndModifiedPresent = !!result.find(function (observable) {
379                     return utils.isValidatable(observable) && !observable.isValid() && observable.isModified();
380                 });
381                 return invalidAndModifiedPresent;
382             };
383
384             result.filter = function(predicate) {
385                 predicate = predicate || function () { return true; };
386                 // ensure we have latest changes
387                 result();
388
389                 return koUtils.arrayFilter(context.validatables, predicate);
390             };
391
392             result.find = function(predicate) {
393                 predicate = predicate || function () { return true; };
394                 // ensure we have latest changes
395                 result();
396
397                 return koUtils.arrayFirst(context.validatables, predicate);
398             };
399
400             result.forEach = function(callback) {
401                 callback = callback || function () { };
402                 // ensure we have latest changes
403                 result();
404
405                 forEach(context.validatables, callback);
406             };
407
408             result.map = function(mapping) {
409                 mapping = mapping || function (item) { return item; };
410                 // ensure we have latest changes
411                 result();
412
413                 return koUtils.arrayMap(context.validatables, mapping);
414             };
415
416             /**
417              * @private You should not rely on this method being here.
418              * It's a private method and it may change in the future.
419              *
420              * @description Updates the validated object and collects errors from it.
421              */
422             result._updateState = function(newValue) {
423                 if (!utils.isObject(newValue)) {
424                     throw new Error('An object is required.');
425                 }
426                 obj = newValue;
427                 if (options.observable) {
428                     context.graphMonitor.valueHasMutated();
429                 }
430                 else {
431                     runTraversal(newValue, context);
432                     return collectErrors(context.validatables);
433                 }
434             };
435             return result;
436         },
437
438         formatMessage: function (message, params, observable) {
439             if (utils.isObject(params) && params.typeAttr) {
440                 params = params.value;
441             }
442             if (typeof (message) === 'function') {
443                 return message(params, observable);
444             }
445             var replacements = unwrap(params) || [];
446             if (!utils.isArray(replacements)) {
447                 replacements = [replacements];
448             }
449             return message.replace(/{(\d+)}/gi, function(match, index) {
450                 if (typeof replacements[index] !== 'undefined') {
451                     return replacements[index];
452                 }
453                 return match;
454             });
455         },
456
457         // addRule:
458         // This takes in a ko.observable and a Rule Context - which is just a rule name and params to supply to the validator
459         // ie: kv.addRule(myObservable, {
460         //          rule: 'required',
461         //          params: true
462         //      });
463         //
464         addRule: function (observable, rule) {
465             observable.extend({ validatable: true });
466
467             var hasRule = !!koUtils.arrayFirst(observable.rules(), function(item) {
468                 return item.rule && item.rule === rule.rule;
469             });
470
471             if (!hasRule) {
472                 //push a Rule Context to the observables local array of Rule Contexts
473                 observable.rules.push(rule);
474             }
475             return observable;
476         },
477
478         // addAnonymousRule:
479         // Anonymous Rules essentially have all the properties of a Rule, but are only specific for a certain property
480         // and developers typically are wanting to add them on the fly or not register a rule with the 'kv.rules' object
481         //
482         // Example:
483         // var test = ko.observable('something').extend{(
484         //      validation: {
485         //          validator: function(val, someOtherVal){
486         //              return true;
487         //          },
488         //          message: "Something must be really wrong!',
489         //          params: true
490         //      }
491         //  )};
492         addAnonymousRule: function (observable, ruleObj) {
493             if (ruleObj['message'] === undefined) {
494                 ruleObj['message'] = 'Error';
495             }
496
497             //make sure onlyIf is honoured
498             if (ruleObj.onlyIf) {
499                 ruleObj.condition = ruleObj.onlyIf;
500             }
501
502             //add the anonymous rule to the observable
503             kv.addRule(observable, ruleObj);
504         },
505
506         addExtender: function (ruleName) {
507             ko.extenders[ruleName] = function (observable, params) {
508                 //params can come in a few flavors
509                 // 1. Just the params to be passed to the validator
510                 // 2. An object containing the Message to be used and the Params to pass to the validator
511                 // 3. A condition when the validation rule to be applied
512                 //
513                 // Example:
514                 // var test = ko.observable(3).extend({
515                 //      max: {
516                 //          message: 'This special field has a Max of {0}',
517                 //          params: 2,
518                 //          onlyIf: function() {
519                 //                      return specialField.IsVisible();
520                 //                  }
521                 //      }
522                 //  )};
523                 //
524                 if (params && (params.message || params.onlyIf)) { //if it has a message or condition object, then its an object literal to use
525                     return kv.addRule(observable, {
526                         rule: ruleName,
527                         message: params.message,
528                         params: utils.isEmptyVal(params.params) ? true : params.params,
529                         condition: params.onlyIf
530                     });
531                 } else {
532                     return kv.addRule(observable, {
533                         rule: ruleName,
534                         params: params
535                     });
536                 }
537             };
538         },
539
540         // loops through all kv.rules and adds them as extenders to
541         // ko.extenders
542         registerExtenders: function () { // root extenders optional, use 'validation' extender if would cause conflicts
543             if (configuration.registerExtenders) {
544                 for (var ruleName in kv.rules) {
545                     if (kv.rules.hasOwnProperty(ruleName)) {
546                         if (!ko.extenders[ruleName]) {
547                             kv.addExtender(ruleName);
548                         }
549                     }
550                 }
551             }
552         },
553
554         //creates a span next to the @element with the specified error class
555         insertValidationMessage: function (element) {
556             var span = document.createElement('SPAN');
557             span.className = utils.getConfigOptions(element).errorMessageClass;
558             utils.insertAfter(element, span);
559             return span;
560         },
561
562         // if html-5 validation attributes have been specified, this parses
563         // the attributes on @element
564         parseInputValidationAttributes: function (element, valueAccessor) {
565             forEach(kv.configuration.html5Attributes, function (attr) {
566                 if (utils.hasAttribute(element, attr)) {
567
568                     var params = element.getAttribute(attr) || true;
569
570                     if (attr === 'min' || attr === 'max')
571                     {
572                         // If we're validating based on the min and max attributes, we'll
573                         // need to know what the 'type' attribute is set to
574                         var typeAttr = element.getAttribute('type');
575                         if (typeof typeAttr === "undefined" || !typeAttr)
576                         {
577                             // From http://www.w3.org/TR/html-markup/input:
578                             //   An input element with no type attribute specified represents the
579                             //   same thing as an input element with its type attribute set to "text".
580                             typeAttr = "text";
581                         }
582                         params = {typeAttr: typeAttr, value: params};
583                     }
584
585                     kv.addRule(valueAccessor(), {
586                         rule: attr,
587                         params: params
588                     });
589                 }
590             });
591
592             var currentType = element.getAttribute('type');
593             forEach(kv.configuration.html5InputTypes, function (type) {
594                 if (type === currentType) {
595                     kv.addRule(valueAccessor(), {
596                         rule: (type === 'date') ? 'dateISO' : type,
597                         params: true
598                     });
599                 }
600             });
601         },
602
603         // writes html5 validation attributes on the element passed in
604         writeInputValidationAttributes: function (element, valueAccessor) {
605             var observable = valueAccessor();
606
607             if (!observable || !observable.rules) {
608                 return;
609             }
610
611             var contexts = observable.rules(); // observable array
612
613             // loop through the attributes and add the information needed
614             forEach(kv.configuration.html5Attributes, function (attr) {
615                 var ctx = koUtils.arrayFirst(contexts, function (ctx) {
616                     return ctx.rule && ctx.rule.toLowerCase() === attr.toLowerCase();
617                 });
618
619                 if (!ctx) {
620                     return;
621                 }
622
623                 // we have a rule matching a validation attribute at this point
624                 // so lets add it to the element along with the params
625                 ko.computed({
626                     read: function() {
627                         var params = ko.unwrap(ctx.params);
628
629                         // we have to do some special things for the pattern validation
630                         if (ctx.rule === "pattern" && params instanceof RegExp) {
631                             // we need the pure string representation of the RegExpr without the //gi stuff
632                             params = params.source;
633                         }
634
635                         element.setAttribute(attr, params);
636                     },
637                     disposeWhenNodeIsRemoved: element
638                 });
639             });
640
641             contexts = null;
642         },
643
644         //take an existing binding handler and make it cause automatic validations
645         makeBindingHandlerValidatable: function (handlerName) {
646             var init = ko.bindingHandlers[handlerName].init;
647
648             ko.bindingHandlers[handlerName].init = function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
649
650                 init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
651
652                 return ko.bindingHandlers['validationCore'].init(element, valueAccessor, allBindingsAccessor, viewModel, bindingContext);
653             };
654         },
655
656         // visit an objects properties and apply validation rules from a definition
657         setRules: function (target, definition) {
658             var setRules = function (target, definition) {
659                 if (!target || !definition) { return; }
660
661                 for (var prop in definition) {
662                     if (!definition.hasOwnProperty(prop)) { continue; }
663                     var ruleDefinitions = definition[prop];
664
665                     //check the target property exists and has a value
666                     if (!target[prop]) { continue; }
667                     var targetValue = target[prop],
668                         unwrappedTargetValue = unwrap(targetValue),
669                         rules = {},
670                         nonRules = {};
671
672                     for (var rule in ruleDefinitions) {
673                         if (!ruleDefinitions.hasOwnProperty(rule)) { continue; }
674                         if (kv.rules[rule]) {
675                             rules[rule] = ruleDefinitions[rule];
676                         } else {
677                             nonRules[rule] = ruleDefinitions[rule];
678                         }
679                     }
680
681                     //apply rules
682                     if (ko.isObservable(targetValue)) {
683                         targetValue.extend(rules);
684                     }
685
686                     //then apply child rules
687                     //if it's an array, apply rules to all children
688                     if (unwrappedTargetValue && utils.isArray(unwrappedTargetValue)) {
689                         for (var i = 0; i < unwrappedTargetValue.length; i++) {
690                             setRules(unwrappedTargetValue[i], nonRules);
691                         }
692                         //otherwise, just apply to this property
693                     } else {
694                         setRules(unwrappedTargetValue, nonRules);
695                     }
696                 }
697             };
698             setRules(target, definition);
699         }
700     };
701
702 }());
703
704 // expose api publicly
705 extend(ko.validation, api);
706 ;//Validation Rules:
707 // You can view and override messages or rules via:
708 // kv.rules[ruleName]
709 //
710 // To implement a custom Rule, simply use this template:
711 // kv.rules['<custom rule name>'] = {
712 //      validator: function (val, param) {
713 //          <custom logic>
714 //          return <true or false>;
715 //      },
716 //      message: '<custom validation message>' //optionally you can also use a '{0}' to denote a placeholder that will be replaced with your 'param'
717 // };
718 //
719 // Example:
720 // kv.rules['mustEqual'] = {
721 //      validator: function( val, mustEqualVal ){
722 //          return val === mustEqualVal;
723 //      },
724 //      message: 'This field must equal {0}'
725 // };
726 //
727 kv.rules = {};
728 kv.rules['required'] = {
729     validator: function (val, required) {
730         var testVal;
731
732         if (val === undefined || val === null) {
733             return !required;
734         }
735
736         testVal = val;
737         if (typeof (val) === 'string') {
738             if (String.prototype.trim) {
739                 testVal = val.trim();
740             }
741             else {
742                 testVal = val.replace(/^\s+|\s+$/g, '');
743             }
744         }
745
746         if (!required) {// if they passed: { required: false }, then don't require this
747             return true;
748         }
749
750         return ((testVal + '').length > 0);
751     },
752     message: 'This field is required.'
753 };
754
755 function minMaxValidatorFactory(validatorName) {
756     var isMaxValidation = validatorName === "max";
757
758     return function (val, options) {
759         if (kv.utils.isEmptyVal(val)) {
760             return true;
761         }
762
763         var comparisonValue, type;
764         if (options.typeAttr === undefined) {
765             // This validator is being called from javascript rather than
766             // being bound from markup
767             type = "text";
768             comparisonValue = options;
769         } else {
770             type = options.typeAttr;
771             comparisonValue = options.value;
772         }
773
774         // From http://www.w3.org/TR/2012/WD-html5-20121025/common-input-element-attributes.html#attr-input-min,
775         // if the value is parseable to a number, then the minimum should be numeric
776         if (!isNaN(comparisonValue) && !(comparisonValue instanceof Date)) {
777             type = "number";
778         }
779
780         var regex, valMatches, comparisonValueMatches;
781         switch (type.toLowerCase()) {
782             case "week":
783                 regex = /^(\d{4})-W(\d{2})$/;
784                 valMatches = val.match(regex);
785                 if (valMatches === null) {
786                     throw new Error("Invalid value for " + validatorName + " attribute for week input.  Should look like " +
787                         "'2000-W33' http://www.w3.org/TR/html-markup/input.week.html#input.week.attrs.min");
788                 }
789                 comparisonValueMatches = comparisonValue.match(regex);
790                 // If no regex matches were found, validation fails
791                 if (!comparisonValueMatches) {
792                     return false;
793                 }
794
795                 if (isMaxValidation) {
796                     return (valMatches[1] < comparisonValueMatches[1]) || // older year
797                         // same year, older week
798                         ((valMatches[1] === comparisonValueMatches[1]) && (valMatches[2] <= comparisonValueMatches[2]));
799                 } else {
800                     return (valMatches[1] > comparisonValueMatches[1]) || // newer year
801                         // same year, newer week
802                         ((valMatches[1] === comparisonValueMatches[1]) && (valMatches[2] >= comparisonValueMatches[2]));
803                 }
804                 break;
805
806             case "month":
807                 regex = /^(\d{4})-(\d{2})$/;
808                 valMatches = val.match(regex);
809                 if (valMatches === null) {
810                     throw new Error("Invalid value for " + validatorName + " attribute for month input.  Should look like " +
811                         "'2000-03' http://www.w3.org/TR/html-markup/input.month.html#input.month.attrs.min");
812                 }
813                 comparisonValueMatches = comparisonValue.match(regex);
814                 // If no regex matches were found, validation fails
815                 if (!comparisonValueMatches) {
816                     return false;
817                 }
818
819                 if (isMaxValidation) {
820                     return ((valMatches[1] < comparisonValueMatches[1]) || // older year
821                         // same year, older month
822                         ((valMatches[1] === comparisonValueMatches[1]) && (valMatches[2] <= comparisonValueMatches[2])));
823                 } else {
824                     return (valMatches[1] > comparisonValueMatches[1]) || // newer year
825                         // same year, newer month
826                         ((valMatches[1] === comparisonValueMatches[1]) && (valMatches[2] >= comparisonValueMatches[2]));
827                 }
828                 break;
829
830             case "number":
831             case "range":
832                 if (isMaxValidation) {
833                     return (!isNaN(val) && parseFloat(val) <= parseFloat(comparisonValue));
834                 } else {
835                     return (!isNaN(val) && parseFloat(val) >= parseFloat(comparisonValue));
836                 }
837                 break;
838
839             default:
840                 if (isMaxValidation) {
841                     return val <= comparisonValue;
842                 } else {
843                     return val >= comparisonValue;
844                 }
845         }
846     };
847 }
848
849 kv.rules['min'] = {
850     validator: minMaxValidatorFactory("min"),
851     message: 'Please enter a value greater than or equal to {0}.'
852 };
853
854 kv.rules['max'] = {
855     validator: minMaxValidatorFactory("max"),
856     message: 'Please enter a value less than or equal to {0}.'
857 };
858
859 kv.rules['minLength'] = {
860     validator: function (val, minLength) {
861         if(kv.utils.isEmptyVal(val)) { return true; }
862         var normalizedVal = kv.utils.isNumber(val) ? ('' + val) : val;
863         return normalizedVal.length >= minLength;
864     },
865     message: 'Please enter at least {0} characters.'
866 };
867
868 kv.rules['maxLength'] = {
869     validator: function (val, maxLength) {
870         if(kv.utils.isEmptyVal(val)) { return true; }
871         var normalizedVal = kv.utils.isNumber(val) ? ('' + val) : val;
872         return normalizedVal.length <= maxLength;
873     },
874     message: 'Please enter no more than {0} characters.'
875 };
876
877 kv.rules['pattern'] = {
878     validator: function (val, regex) {
879         return kv.utils.isEmptyVal(val) || val.toString().match(regex) !== null;
880     },
881     message: 'Please check this value.'
882 };
883
884 kv.rules['step'] = {
885     validator: function (val, step) {
886
887         // in order to handle steps of .1 & .01 etc.. Modulus won't work
888         // if the value is a decimal, so we have to correct for that
889         if (kv.utils.isEmptyVal(val) || step === 'any') { return true; }
890         var dif = (val * 100) % (step * 100);
891         return Math.abs(dif) < 0.00001 || Math.abs(1 - dif) < 0.00001;
892     },
893     message: 'The value must increment by {0}.'
894 };
895
896 kv.rules['email'] = {
897     validator: function (val, validate) {
898         if (!validate) { return true; }
899
900         //I think an empty email address is also a valid entry
901         //if one want's to enforce entry it should be done with 'required: true'
902         return kv.utils.isEmptyVal(val) || (
903             // jquery validate regex - thanks Scott Gonzalez
904             validate && /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))$/i.test(val)
905         );
906     },
907     message: 'Please enter a proper email address.'
908 };
909
910 kv.rules['date'] = {
911     validator: function (value, validate) {
912         if (!validate) { return true; }
913         return kv.utils.isEmptyVal(value) || (validate && !/Invalid|NaN/.test(new Date(value)));
914     },
915     message: 'Please enter a proper date.'
916 };
917
918 kv.rules['dateISO'] = {
919     validator: function (value, validate) {
920         if (!validate) { return true; }
921         return kv.utils.isEmptyVal(value) || (validate && /^\d{4}[-/](?:0?[1-9]|1[012])[-/](?:0?[1-9]|[12][0-9]|3[01])$/.test(value));
922     },
923     message: 'Please enter a proper date.'
924 };
925
926 kv.rules['number'] = {
927     validator: function (value, validate) {
928         if (!validate) { return true; }
929         return kv.utils.isEmptyVal(value) || (validate && /^-?(?:\d+|\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test(value));
930     },
931     message: 'Please enter a number.'
932 };
933
934 kv.rules['digit'] = {
935     validator: function (value, validate) {
936         if (!validate) { return true; }
937         return kv.utils.isEmptyVal(value) || (validate && /^\d+$/.test(value));
938     },
939     message: 'Please enter a digit.'
940 };
941
942 kv.rules['phoneUS'] = {
943     validator: function (phoneNumber, validate) {
944         if (!validate) { return true; }
945         if (kv.utils.isEmptyVal(phoneNumber)) { return true; } // makes it optional, use 'required' rule if it should be required
946         if (typeof (phoneNumber) !== 'string') { return false; }
947         phoneNumber = phoneNumber.replace(/\s+/g, "");
948         return validate && phoneNumber.length > 9 && phoneNumber.match(/^(1-?)?(\([2-9]\d{2}\)|[2-9]\d{2})-?[2-9]\d{2}-?\d{4}$/);
949     },
950     message: 'Please specify a valid phone number.'
951 };
952
953 kv.rules['equal'] = {
954     validator: function (val, params) {
955         var otherValue = params;
956         return val === kv.utils.getValue(otherValue);
957     },
958     message: 'Values must equal.'
959 };
960
961 kv.rules['notEqual'] = {
962     validator: function (val, params) {
963         var otherValue = params;
964         return val !== kv.utils.getValue(otherValue);
965     },
966     message: 'Please choose another value.'
967 };
968
969 //unique in collection
970 // options are:
971 //    collection: array or function returning (observable) array
972 //              in which the value has to be unique
973 //    valueAccessor: function that returns value from an object stored in collection
974 //              if it is null the value is compared directly
975 //    external: set to true when object you are validating is automatically updating collection
976 kv.rules['unique'] = {
977     validator: function (val, options) {
978         var c = kv.utils.getValue(options.collection),
979             external = kv.utils.getValue(options.externalValue),
980             counter = 0;
981
982         if (!val || !c) { return true; }
983
984         koUtils.arrayFilter(c, function (item) {
985             if (val === (options.valueAccessor ? options.valueAccessor(item) : item)) { counter++; }
986         });
987         // if value is external even 1 same value in collection means the value is not unique
988         return counter < (!!external ? 1 : 2);
989     },
990     message: 'Please make sure the value is unique.'
991 };
992
993
994 //now register all of these!
995 (function () {
996     kv.registerExtenders();
997 }());
998 ;// The core binding handler
999 // this allows us to setup any value binding that internally always
1000 // performs the same functionality
1001 ko.bindingHandlers['validationCore'] = (function () {
1002
1003     return {
1004         init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
1005             var config = kv.utils.getConfigOptions(element);
1006             var observable = valueAccessor();
1007
1008             // parse html5 input validation attributes, optional feature
1009             if (config.parseInputAttributes) {
1010                 kv.utils.async(function () { kv.parseInputValidationAttributes(element, valueAccessor); });
1011             }
1012
1013             // if requested insert message element and apply bindings
1014             if (config.insertMessages && kv.utils.isValidatable(observable)) {
1015
1016                 // insert the <span></span>
1017                 var validationMessageElement = kv.insertValidationMessage(element);
1018
1019                 // if we're told to use a template, make sure that gets rendered
1020                 if (config.messageTemplate) {
1021                     ko.renderTemplate(config.messageTemplate, { field: observable }, null, validationMessageElement, 'replaceNode');
1022                 } else {
1023                     ko.applyBindingsToNode(validationMessageElement, { validationMessage: observable });
1024                 }
1025             }
1026
1027             // write the html5 attributes if indicated by the config
1028             if (config.writeInputAttributes && kv.utils.isValidatable(observable)) {
1029
1030                 kv.writeInputValidationAttributes(element, valueAccessor);
1031             }
1032
1033             // if requested, add binding to decorate element
1034             if (config.decorateInputElement && kv.utils.isValidatable(observable)) {
1035                 ko.applyBindingsToNode(element, { validationElement: observable });
1036             }
1037         }
1038     };
1039
1040 }());
1041
1042 // override for KO's default 'value', 'checked', 'textInput' and selectedOptions bindings
1043 kv.makeBindingHandlerValidatable("value");
1044 kv.makeBindingHandlerValidatable("checked");
1045 if (ko.bindingHandlers.textInput) {
1046     kv.makeBindingHandlerValidatable("textInput");
1047 }
1048 kv.makeBindingHandlerValidatable("selectedOptions");
1049
1050
1051 ko.bindingHandlers['validationMessage'] = { // individual error message, if modified or post binding
1052     update: function (element, valueAccessor) {
1053         var obsv = valueAccessor(),
1054             config = kv.utils.getConfigOptions(element),
1055             val = unwrap(obsv),
1056             msg = null,
1057             isModified = false,
1058             isValid = false;
1059
1060         if (obsv === null || typeof obsv === 'undefined') {
1061             throw new Error('Cannot bind validationMessage to undefined value. data-bind expression: ' +
1062                 element.getAttribute('data-bind'));
1063         }
1064
1065         if (!obsv.isValid || !obsv.isModified) {
1066             throw new Error("Observable is not validatable");
1067         }
1068
1069         isModified = obsv.isModified();
1070         isValid = obsv.isValid();
1071
1072         var error = null;
1073         if (!config.messagesOnModified || isModified) {
1074             error = isValid ? null : obsv.error;
1075         }
1076
1077         var isVisible = !config.messagesOnModified || isModified ? !isValid : false;
1078         var isCurrentlyVisible = element.style.display !== "none";
1079
1080         if (config.allowHtmlMessages) {
1081             koUtils.setHtml(element, error);
1082         } else {
1083             ko.bindingHandlers.text.update(element, function () { return error; });
1084         }
1085
1086         if (isCurrentlyVisible && !isVisible) {
1087             element.style.display = 'none';
1088         } else if (!isCurrentlyVisible && isVisible) {
1089             element.style.display = '';
1090         }
1091     }
1092 };
1093
1094 ko.bindingHandlers['validationElement'] = {
1095     update: function (element, valueAccessor, allBindingsAccessor) {
1096         var obsv = valueAccessor(),
1097             config = kv.utils.getConfigOptions(element),
1098             val = unwrap(obsv),
1099             msg = null,
1100             isModified = false,
1101             isValid = false;
1102
1103         if (obsv === null || typeof obsv === 'undefined') {
1104             throw new Error('Cannot bind validationElement to undefined value. data-bind expression: ' +
1105                 element.getAttribute('data-bind'));
1106         }
1107
1108         if (!obsv.isValid || !obsv.isModified) {
1109             throw new Error("Observable is not validatable");
1110         }
1111
1112         isModified = obsv.isModified();
1113         isValid = obsv.isValid();
1114
1115         // create an evaluator function that will return something like:
1116         // css: { validationElement: true }
1117         var cssSettingsAccessor = function () {
1118             var css = {};
1119
1120             var shouldShow = ((!config.decorateElementOnModified || isModified) ? !isValid : false);
1121
1122             // css: { validationElement: false }
1123             css[config.errorElementClass] = shouldShow;
1124
1125             return css;
1126         };
1127
1128         //add or remove class on the element;
1129         ko.bindingHandlers.css.update(element, cssSettingsAccessor, allBindingsAccessor);
1130         if (!config.errorsAsTitle) { return; }
1131
1132         ko.bindingHandlers.attr.update(element, function () {
1133             var
1134                 hasModification = !config.errorsAsTitleOnModified || isModified,
1135                 title = kv.utils.getOriginalElementTitle(element);
1136
1137             if (hasModification && !isValid) {
1138                 return { title: obsv.error, 'data-orig-title': title };
1139             } else if (!hasModification || isValid) {
1140                 return { title: title, 'data-orig-title': null };
1141             }
1142         });
1143     }
1144 };
1145
1146 // ValidationOptions:
1147 // This binding handler allows you to override the initial config by setting any of the options for a specific element or context of elements
1148 //
1149 // Example:
1150 // <div data-bind="validationOptions: { insertMessages: true, messageTemplate: 'customTemplate', errorMessageClass: 'mySpecialClass'}">
1151 //      <input type="text" data-bind="value: someValue"/>
1152 //      <input type="text" data-bind="value: someValue2"/>
1153 // </div>
1154 ko.bindingHandlers['validationOptions'] = (function () {
1155     return {
1156         init: function (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) {
1157             var options = unwrap(valueAccessor());
1158             if (options) {
1159                 var newConfig = extend({}, kv.configuration);
1160                 extend(newConfig, options);
1161
1162                 //store the validation options on the node so we can retrieve it later
1163                 kv.utils.setDomData(element, newConfig);
1164             }
1165         }
1166     };
1167 }());
1168 ;// Validation Extender:
1169 // This is for creating custom validation logic on the fly
1170 // Example:
1171 // var test = ko.observable('something').extend{(
1172 //      validation: {
1173 //          validator: function(val, someOtherVal){
1174 //              return true;
1175 //          },
1176 //          message: "Something must be really wrong!',
1177 //          params: true
1178 //      }
1179 //  )};
1180 ko.extenders['validation'] = function (observable, rules) { // allow single rule or array
1181     forEach(kv.utils.isArray(rules) ? rules : [rules], function (rule) {
1182         // the 'rule' being passed in here has no name to identify a core Rule,
1183         // so we add it as an anonymous rule
1184         // If the developer is wanting to use a core Rule, but use a different message see the 'addExtender' logic for examples
1185         kv.addAnonymousRule(observable, rule);
1186     });
1187     return observable;
1188 };
1189
1190 //This is the extender that makes a Knockout Observable also 'Validatable'
1191 //examples include:
1192 // 1. var test = ko.observable('something').extend({validatable: true});
1193 // this will ensure that the Observable object is setup properly to respond to rules
1194 //
1195 // 2. test.extend({validatable: false});
1196 // this will remove the validation properties from the Observable object should you need to do that.
1197 ko.extenders['validatable'] = function (observable, options) {
1198     if (!kv.utils.isObject(options)) {
1199         options = { enable: options };
1200     }
1201
1202     if (!('enable' in options)) {
1203         options.enable = true;
1204     }
1205
1206     if (options.enable && !kv.utils.isValidatable(observable)) {
1207         var config = kv.configuration.validate || {};
1208         var validationOptions = {
1209             throttleEvaluation : options.throttle || config.throttle
1210         };
1211
1212         observable.error = ko.observable(null); // holds the error message, we only need one since we stop processing validators when one is invalid
1213
1214         // observable.rules:
1215         // ObservableArray of Rule Contexts, where a Rule Context is simply the name of a rule and the params to supply to it
1216         //
1217         // Rule Context = { rule: '<rule name>', params: '<passed in params>', message: '<Override of default Message>' }
1218         observable.rules = ko.observableArray(); //holds the rule Contexts to use as part of validation
1219
1220         //in case async validation is occurring
1221         observable.isValidating = ko.observable(false);
1222
1223         //the true holder of whether the observable is valid or not
1224         observable.__valid__ = ko.observable(true);
1225
1226         observable.isModified = ko.observable(false);
1227
1228         // a semi-protected observable
1229         observable.isValid = ko.computed(observable.__valid__);
1230
1231         //manually set error state
1232         observable.setError = function (error) {
1233             var previousError = observable.error.peek();
1234             var previousIsValid = observable.__valid__.peek();
1235
1236             observable.error(error);
1237             observable.__valid__(false);
1238
1239             if (previousError !== error && !previousIsValid) {
1240                 // if the observable was not valid before then isValid will not mutate,
1241                 // hence causing any grouping to not display the latest error.
1242                 observable.isValid.notifySubscribers();
1243             }
1244         };
1245
1246         //manually clear error state
1247         observable.clearError = function () {
1248             observable.error(null);
1249             observable.__valid__(true);
1250             return observable;
1251         };
1252
1253         //subscribe to changes in the observable
1254         var h_change = observable.subscribe(function () {
1255             observable.isModified(true);
1256         });
1257
1258         // we use a computed here to ensure that anytime a dependency changes, the
1259         // validation logic evaluates
1260         var h_obsValidationTrigger = ko.computed(extend({
1261             read: function () {
1262                 var obs = observable(),
1263                     ruleContexts = observable.rules();
1264
1265                 kv.validateObservable(observable);
1266
1267                 return true;
1268             }
1269         }, validationOptions));
1270
1271         extend(h_obsValidationTrigger, validationOptions);
1272
1273         observable._disposeValidation = function () {
1274             //first dispose of the subscriptions
1275             observable.isValid.dispose();
1276             observable.rules.removeAll();
1277             if (observable.isModified.getSubscriptionsCount() > 0) {
1278                 observable.isModified._subscriptions['change'] = [];
1279             }
1280             if (observable.isValidating.getSubscriptionsCount() > 0) {
1281                 observable.isValidating._subscriptions['change'] = [];
1282             }
1283             if (observable.__valid__.getSubscriptionsCount() > 0) {
1284                 observable.__valid__._subscriptions['change'] = [];
1285             }
1286             h_change.dispose();
1287             h_obsValidationTrigger.dispose();
1288
1289             delete observable['rules'];
1290             delete observable['error'];
1291             delete observable['isValid'];
1292             delete observable['isValidating'];
1293             delete observable['__valid__'];
1294             delete observable['isModified'];
1295         };
1296     } else if (options.enable === false && observable._disposeValidation) {
1297         observable._disposeValidation();
1298     }
1299     return observable;
1300 };
1301
1302 function validateSync(observable, rule, ctx) {
1303     //Execute the validator and see if its valid
1304     if (!rule.validator(observable(), (ctx.params === undefined ? true : unwrap(ctx.params)))) { // default param is true, eg. required = true
1305
1306         //not valid, so format the error message and stick it in the 'error' variable
1307         observable.setError(kv.formatMessage(
1308                     ctx.message || rule.message,
1309                     unwrap(ctx.params),
1310                     observable));
1311         return false;
1312     } else {
1313         return true;
1314     }
1315 }
1316
1317 function validateAsync(observable, rule, ctx) {
1318     observable.isValidating(true);
1319
1320     var callBack = function (valObj) {
1321         var isValid = false,
1322             msg = '';
1323
1324         if (!observable.__valid__()) {
1325
1326             // since we're returning early, make sure we turn this off
1327             observable.isValidating(false);
1328
1329             return; //if its already NOT valid, don't add to that
1330         }
1331
1332         //we were handed back a complex object
1333         if (valObj['message']) {
1334             isValid = valObj.isValid;
1335             msg = valObj.message;
1336         } else {
1337             isValid = valObj;
1338         }
1339
1340         if (!isValid) {
1341             //not valid, so format the error message and stick it in the 'error' variable
1342             observable.error(kv.formatMessage(
1343                 msg || ctx.message || rule.message,
1344                 unwrap(ctx.params),
1345                 observable));
1346             observable.__valid__(isValid);
1347         }
1348
1349         // tell it that we're done
1350         observable.isValidating(false);
1351     };
1352
1353     //fire the validator and hand it the callback
1354     rule.validator(observable(), unwrap(ctx.params || true), callBack);
1355 }
1356
1357 kv.validateObservable = function (observable) {
1358     var i = 0,
1359         rule, // the rule validator to execute
1360         ctx, // the current Rule Context for the loop
1361         ruleContexts = observable.rules(), //cache for iterator
1362         len = ruleContexts.length; //cache for iterator
1363
1364     for (; i < len; i++) {
1365
1366         //get the Rule Context info to give to the core Rule
1367         ctx = ruleContexts[i];
1368
1369         // checks an 'onlyIf' condition
1370         if (ctx.condition && !ctx.condition()) {
1371             continue;
1372         }
1373
1374         //get the core Rule to use for validation
1375         rule = ctx.rule ? kv.rules[ctx.rule] : ctx;
1376
1377         if (rule['async'] || ctx['async']) {
1378             //run async validation
1379             validateAsync(observable, rule, ctx);
1380
1381         } else {
1382             //run normal sync validation
1383             if (!validateSync(observable, rule, ctx)) {
1384                 return false; //break out of the loop
1385             }
1386         }
1387     }
1388     //finally if we got this far, make the observable valid again!
1389     observable.clearError();
1390     return true;
1391 };
1392 ;
1393 var _locales = {};
1394 var _currentLocale;
1395
1396 kv.defineLocale = function(name, values) {
1397     if (name && values) {
1398         _locales[name.toLowerCase()] = values;
1399         return values;
1400     }
1401     return null;
1402 };
1403
1404 kv.locale = function(name) {
1405     if (name) {
1406         name = name.toLowerCase();
1407
1408         if (_locales.hasOwnProperty(name)) {
1409             kv.localize(_locales[name]);
1410             _currentLocale = name;
1411         }
1412         else {
1413             throw new Error('Localization ' + name + ' has not been loaded.');
1414         }
1415     }
1416     return _currentLocale;
1417 };
1418
1419 //quick function to override rule messages
1420 kv.localize = function (msgTranslations) {
1421     var rules = kv.rules;
1422
1423     //loop the properties in the object and assign the msg to the rule
1424     for (var ruleName in msgTranslations) {
1425         if (rules.hasOwnProperty(ruleName)) {
1426             rules[ruleName].message = msgTranslations[ruleName];
1427         }
1428     }
1429 };
1430
1431 // Populate default locale (this will make en-US.js somewhat redundant)
1432 (function() {
1433     var localeData = {};
1434     var rules = kv.rules;
1435
1436     for (var ruleName in rules) {
1437         if (rules.hasOwnProperty(ruleName)) {
1438             localeData[ruleName] = rules[ruleName].message;
1439         }
1440     }
1441     kv.defineLocale('en-us', localeData);
1442 })();
1443
1444 // No need to invoke locale because the messages are already defined along with the rules for en-US
1445 _currentLocale = 'en-us';
1446 ;/**
1447  * Possible invocations:
1448  *         applyBindingsWithValidation(viewModel)
1449  *         applyBindingsWithValidation(viewModel, options)
1450  *         applyBindingsWithValidation(viewModel, rootNode)
1451  *        applyBindingsWithValidation(viewModel, rootNode, options)
1452  */
1453 ko.applyBindingsWithValidation = function (viewModel, rootNode, options) {
1454     var node = document.body,
1455         config;
1456
1457     if (rootNode && rootNode.nodeType) {
1458         node = rootNode;
1459         config = options;
1460     }
1461     else {
1462         config = rootNode;
1463     }
1464
1465     kv.init();
1466
1467     if (config) {
1468         config = extend(extend({}, kv.configuration), config);
1469         kv.utils.setDomData(node, config);
1470     }
1471
1472     ko.applyBindings(viewModel, node);
1473 };
1474
1475 //override the original applyBindings so that we can ensure all new rules and what not are correctly registered
1476 var origApplyBindings = ko.applyBindings;
1477 ko.applyBindings = function (viewModel, rootNode) {
1478
1479     kv.init();
1480
1481     origApplyBindings(viewModel, rootNode);
1482 };
1483
1484 ko.validatedObservable = function (initialValue, options) {
1485     if (!options && !kv.utils.isObject(initialValue)) {
1486         return ko.observable(initialValue).extend({ validatable: true });
1487     }
1488
1489     var obsv = ko.observable(initialValue);
1490     obsv.errors = kv.group(kv.utils.isObject(initialValue) ? initialValue : {}, options);
1491     obsv.isValid = ko.observable(obsv.errors().length === 0);
1492
1493     if (ko.isObservable(obsv.errors)) {
1494         obsv.errors.subscribe(function(errors) {
1495             obsv.isValid(errors.length === 0);
1496         });
1497     }
1498     else {
1499         ko.computed(obsv.errors).subscribe(function (errors) {
1500             obsv.isValid(errors.length === 0);
1501         });
1502     }
1503
1504     obsv.subscribe(function(newValue) {
1505         if (!kv.utils.isObject(newValue)) {
1506             /*
1507              * The validation group works on objects.
1508              * Since the new value is a primitive (scalar, null or undefined) we need
1509              * to create an empty object to pass along.
1510              */
1511             newValue = {};
1512         }
1513         // Force the group to refresh
1514         obsv.errors._updateState(newValue);
1515         obsv.isValid(obsv.errors().length === 0);
1516     });
1517
1518     return obsv;
1519 };
1520 ;}));