| 2 |
lars |
1 |
/*!
|
|
|
2 |
* jQuery Validation Plugin v1.19.0
|
|
|
3 |
*
|
|
|
4 |
* https://jqueryvalidation.org/
|
|
|
5 |
*
|
|
|
6 |
* Copyright (c) 2018 Jörn Zaefferer
|
|
|
7 |
* Released under the MIT license
|
|
|
8 |
*/
|
|
|
9 |
(function( factory ) {
|
|
|
10 |
if ( typeof define === "function" && define.amd ) {
|
|
|
11 |
define( ["jquery"], factory );
|
|
|
12 |
} else if (typeof module === "object" && module.exports) {
|
|
|
13 |
module.exports = factory( require( "jquery" ) );
|
|
|
14 |
} else {
|
|
|
15 |
factory( jQuery );
|
|
|
16 |
}
|
|
|
17 |
}(function( $ ) {
|
|
|
18 |
|
|
|
19 |
$.extend( $.fn, {
|
|
|
20 |
|
|
|
21 |
// https://jqueryvalidation.org/validate/
|
|
|
22 |
validate: function( options ) {
|
|
|
23 |
|
|
|
24 |
// If nothing is selected, return nothing; can't chain anyway
|
|
|
25 |
if ( !this.length ) {
|
|
|
26 |
if ( options && options.debug && window.console ) {
|
|
|
27 |
console.warn( "Nothing selected, can't validate, returning nothing." );
|
|
|
28 |
}
|
|
|
29 |
return;
|
|
|
30 |
}
|
|
|
31 |
|
|
|
32 |
// Check if a validator for this form was already created
|
|
|
33 |
var validator = $.data( this[ 0 ], "validator" );
|
|
|
34 |
if ( validator ) {
|
|
|
35 |
return validator;
|
|
|
36 |
}
|
|
|
37 |
|
|
|
38 |
// Add novalidate tag if HTML5.
|
|
|
39 |
this.attr( "novalidate", "novalidate" );
|
|
|
40 |
|
|
|
41 |
validator = new $.validator( options, this[ 0 ] );
|
|
|
42 |
$.data( this[ 0 ], "validator", validator );
|
|
|
43 |
|
|
|
44 |
if ( validator.settings.onsubmit ) {
|
|
|
45 |
|
|
|
46 |
this.on( "click.validate", ":submit", function( event ) {
|
|
|
47 |
|
|
|
48 |
// Track the used submit button to properly handle scripted
|
|
|
49 |
// submits later.
|
|
|
50 |
validator.submitButton = event.currentTarget;
|
|
|
51 |
|
|
|
52 |
// Allow suppressing validation by adding a cancel class to the submit button
|
|
|
53 |
if ( $( this ).hasClass( "cancel" ) ) {
|
|
|
54 |
validator.cancelSubmit = true;
|
|
|
55 |
}
|
|
|
56 |
|
|
|
57 |
// Allow suppressing validation by adding the html5 formnovalidate attribute to the submit button
|
|
|
58 |
if ( $( this ).attr( "formnovalidate" ) !== undefined ) {
|
|
|
59 |
validator.cancelSubmit = true;
|
|
|
60 |
}
|
|
|
61 |
} );
|
|
|
62 |
|
|
|
63 |
// Validate the form on submit
|
|
|
64 |
this.on( "submit.validate", function( event ) {
|
|
|
65 |
if ( validator.settings.debug ) {
|
|
|
66 |
|
|
|
67 |
// Prevent form submit to be able to see console output
|
|
|
68 |
event.preventDefault();
|
|
|
69 |
}
|
|
|
70 |
|
|
|
71 |
function handle() {
|
|
|
72 |
var hidden, result;
|
|
|
73 |
|
|
|
74 |
// Insert a hidden input as a replacement for the missing submit button
|
|
|
75 |
// The hidden input is inserted in two cases:
|
|
|
76 |
// - A user defined a `submitHandler`
|
|
|
77 |
// - There was a pending request due to `remote` method and `stopRequest()`
|
|
|
78 |
// was called to submit the form in case it's valid
|
|
|
79 |
if ( validator.submitButton && ( validator.settings.submitHandler || validator.formSubmitted ) ) {
|
|
|
80 |
hidden = $( "<input type='hidden'/>" )
|
|
|
81 |
.attr( "name", validator.submitButton.name )
|
|
|
82 |
.val( $( validator.submitButton ).val() )
|
|
|
83 |
.appendTo( validator.currentForm );
|
|
|
84 |
}
|
|
|
85 |
|
|
|
86 |
if ( validator.settings.submitHandler && !validator.settings.debug ) {
|
|
|
87 |
result = validator.settings.submitHandler.call( validator, validator.currentForm, event );
|
|
|
88 |
if ( hidden ) {
|
|
|
89 |
|
|
|
90 |
// And clean up afterwards; thanks to no-block-scope, hidden can be referenced
|
|
|
91 |
hidden.remove();
|
|
|
92 |
}
|
|
|
93 |
if ( result !== undefined ) {
|
|
|
94 |
return result;
|
|
|
95 |
}
|
|
|
96 |
return false;
|
|
|
97 |
}
|
|
|
98 |
return true;
|
|
|
99 |
}
|
|
|
100 |
|
|
|
101 |
// Prevent submit for invalid forms or custom submit handlers
|
|
|
102 |
if ( validator.cancelSubmit ) {
|
|
|
103 |
validator.cancelSubmit = false;
|
|
|
104 |
return handle();
|
|
|
105 |
}
|
|
|
106 |
if ( validator.form() ) {
|
|
|
107 |
if ( validator.pendingRequest ) {
|
|
|
108 |
validator.formSubmitted = true;
|
|
|
109 |
return false;
|
|
|
110 |
}
|
|
|
111 |
return handle();
|
|
|
112 |
} else {
|
|
|
113 |
validator.focusInvalid();
|
|
|
114 |
return false;
|
|
|
115 |
}
|
|
|
116 |
} );
|
|
|
117 |
}
|
|
|
118 |
|
|
|
119 |
return validator;
|
|
|
120 |
},
|
|
|
121 |
|
|
|
122 |
// https://jqueryvalidation.org/valid/
|
|
|
123 |
valid: function() {
|
|
|
124 |
var valid, validator, errorList;
|
|
|
125 |
|
|
|
126 |
if ( $( this[ 0 ] ).is( "form" ) ) {
|
|
|
127 |
valid = this.validate().form();
|
|
|
128 |
} else {
|
|
|
129 |
errorList = [];
|
|
|
130 |
valid = true;
|
|
|
131 |
validator = $( this[ 0 ].form ).validate();
|
|
|
132 |
this.each( function() {
|
|
|
133 |
valid = validator.element( this ) && valid;
|
|
|
134 |
if ( !valid ) {
|
|
|
135 |
errorList = errorList.concat( validator.errorList );
|
|
|
136 |
}
|
|
|
137 |
} );
|
|
|
138 |
validator.errorList = errorList;
|
|
|
139 |
}
|
|
|
140 |
return valid;
|
|
|
141 |
},
|
|
|
142 |
|
|
|
143 |
// https://jqueryvalidation.org/rules/
|
|
|
144 |
rules: function( command, argument ) {
|
|
|
145 |
var element = this[ 0 ],
|
|
|
146 |
isContentEditable = typeof this.attr( "contenteditable" ) !== "undefined" && this.attr( "contenteditable" ) !== "false",
|
|
|
147 |
settings, staticRules, existingRules, data, param, filtered;
|
|
|
148 |
|
|
|
149 |
// If nothing is selected, return empty object; can't chain anyway
|
|
|
150 |
if ( element == null ) {
|
|
|
151 |
return;
|
|
|
152 |
}
|
|
|
153 |
|
|
|
154 |
if ( !element.form && isContentEditable ) {
|
|
|
155 |
element.form = this.closest( "form" )[ 0 ];
|
|
|
156 |
element.name = this.attr( "name" );
|
|
|
157 |
}
|
|
|
158 |
|
|
|
159 |
if ( element.form == null ) {
|
|
|
160 |
return;
|
|
|
161 |
}
|
|
|
162 |
|
|
|
163 |
if ( command ) {
|
|
|
164 |
settings = $.data( element.form, "validator" ).settings;
|
|
|
165 |
staticRules = settings.rules;
|
|
|
166 |
existingRules = $.validator.staticRules( element );
|
|
|
167 |
switch ( command ) {
|
|
|
168 |
case "add":
|
|
|
169 |
$.extend( existingRules, $.validator.normalizeRule( argument ) );
|
|
|
170 |
|
|
|
171 |
// Remove messages from rules, but allow them to be set separately
|
|
|
172 |
delete existingRules.messages;
|
|
|
173 |
staticRules[ element.name ] = existingRules;
|
|
|
174 |
if ( argument.messages ) {
|
|
|
175 |
settings.messages[ element.name ] = $.extend( settings.messages[ element.name ], argument.messages );
|
|
|
176 |
}
|
|
|
177 |
break;
|
|
|
178 |
case "remove":
|
|
|
179 |
if ( !argument ) {
|
|
|
180 |
delete staticRules[ element.name ];
|
|
|
181 |
return existingRules;
|
|
|
182 |
}
|
|
|
183 |
filtered = {};
|
|
|
184 |
$.each( argument.split( /\s/ ), function( index, method ) {
|
|
|
185 |
filtered[ method ] = existingRules[ method ];
|
|
|
186 |
delete existingRules[ method ];
|
|
|
187 |
} );
|
|
|
188 |
return filtered;
|
|
|
189 |
}
|
|
|
190 |
}
|
|
|
191 |
|
|
|
192 |
data = $.validator.normalizeRules(
|
|
|
193 |
$.extend(
|
|
|
194 |
{},
|
|
|
195 |
$.validator.classRules( element ),
|
|
|
196 |
$.validator.attributeRules( element ),
|
|
|
197 |
$.validator.dataRules( element ),
|
|
|
198 |
$.validator.staticRules( element )
|
|
|
199 |
), element );
|
|
|
200 |
|
|
|
201 |
// Make sure required is at front
|
|
|
202 |
if ( data.required ) {
|
|
|
203 |
param = data.required;
|
|
|
204 |
delete data.required;
|
|
|
205 |
data = $.extend( { required: param }, data );
|
|
|
206 |
}
|
|
|
207 |
|
|
|
208 |
// Make sure remote is at back
|
|
|
209 |
if ( data.remote ) {
|
|
|
210 |
param = data.remote;
|
|
|
211 |
delete data.remote;
|
|
|
212 |
data = $.extend( data, { remote: param } );
|
|
|
213 |
}
|
|
|
214 |
|
|
|
215 |
return data;
|
|
|
216 |
}
|
|
|
217 |
} );
|
|
|
218 |
|
|
|
219 |
// Custom selectors
|
|
|
220 |
$.extend( $.expr.pseudos || $.expr[ ":" ], { // '|| $.expr[ ":" ]' here enables backwards compatibility to jQuery 1.7. Can be removed when dropping jQ 1.7.x support
|
|
|
221 |
|
|
|
222 |
// https://jqueryvalidation.org/blank-selector/
|
|
|
223 |
blank: function( a ) {
|
|
|
224 |
return !$.trim( "" + $( a ).val() );
|
|
|
225 |
},
|
|
|
226 |
|
|
|
227 |
// https://jqueryvalidation.org/filled-selector/
|
|
|
228 |
filled: function( a ) {
|
|
|
229 |
var val = $( a ).val();
|
|
|
230 |
return val !== null && !!$.trim( "" + val );
|
|
|
231 |
},
|
|
|
232 |
|
|
|
233 |
// https://jqueryvalidation.org/unchecked-selector/
|
|
|
234 |
unchecked: function( a ) {
|
|
|
235 |
return !$( a ).prop( "checked" );
|
|
|
236 |
}
|
|
|
237 |
} );
|
|
|
238 |
|
|
|
239 |
// Constructor for validator
|
|
|
240 |
$.validator = function( options, form ) {
|
|
|
241 |
this.settings = $.extend( true, {}, $.validator.defaults, options );
|
|
|
242 |
this.currentForm = form;
|
|
|
243 |
this.init();
|
|
|
244 |
};
|
|
|
245 |
|
|
|
246 |
// https://jqueryvalidation.org/jQuery.validator.format/
|
|
|
247 |
$.validator.format = function( source, params ) {
|
|
|
248 |
if ( arguments.length === 1 ) {
|
|
|
249 |
return function() {
|
|
|
250 |
var args = $.makeArray( arguments );
|
|
|
251 |
args.unshift( source );
|
|
|
252 |
return $.validator.format.apply( this, args );
|
|
|
253 |
};
|
|
|
254 |
}
|
|
|
255 |
if ( params === undefined ) {
|
|
|
256 |
return source;
|
|
|
257 |
}
|
|
|
258 |
if ( arguments.length > 2 && params.constructor !== Array ) {
|
|
|
259 |
params = $.makeArray( arguments ).slice( 1 );
|
|
|
260 |
}
|
|
|
261 |
if ( params.constructor !== Array ) {
|
|
|
262 |
params = [ params ];
|
|
|
263 |
}
|
|
|
264 |
$.each( params, function( i, n ) {
|
|
|
265 |
source = source.replace( new RegExp( "\\{" + i + "\\}", "g" ), function() {
|
|
|
266 |
return n;
|
|
|
267 |
} );
|
|
|
268 |
} );
|
|
|
269 |
return source;
|
|
|
270 |
};
|
|
|
271 |
|
|
|
272 |
$.extend( $.validator, {
|
|
|
273 |
|
|
|
274 |
defaults: {
|
|
|
275 |
messages: {},
|
|
|
276 |
groups: {},
|
|
|
277 |
rules: {},
|
|
|
278 |
errorClass: "error",
|
|
|
279 |
pendingClass: "pending",
|
|
|
280 |
validClass: "valid",
|
|
|
281 |
errorElement: "label",
|
|
|
282 |
focusCleanup: false,
|
|
|
283 |
focusInvalid: true,
|
|
|
284 |
errorContainer: $( [] ),
|
|
|
285 |
errorLabelContainer: $( [] ),
|
|
|
286 |
onsubmit: true,
|
|
|
287 |
ignore: ":hidden",
|
|
|
288 |
ignoreTitle: false,
|
|
|
289 |
onfocusin: function( element ) {
|
|
|
290 |
this.lastActive = element;
|
|
|
291 |
|
|
|
292 |
// Hide error label and remove error class on focus if enabled
|
|
|
293 |
if ( this.settings.focusCleanup ) {
|
|
|
294 |
if ( this.settings.unhighlight ) {
|
|
|
295 |
this.settings.unhighlight.call( this, element, this.settings.errorClass, this.settings.validClass );
|
|
|
296 |
}
|
|
|
297 |
this.hideThese( this.errorsFor( element ) );
|
|
|
298 |
}
|
|
|
299 |
},
|
|
|
300 |
onfocusout: function( element ) {
|
|
|
301 |
if ( !this.checkable( element ) && ( element.name in this.submitted || !this.optional( element ) ) ) {
|
|
|
302 |
this.element( element );
|
|
|
303 |
}
|
|
|
304 |
},
|
|
|
305 |
onkeyup: function( element, event ) {
|
|
|
306 |
|
|
|
307 |
// Avoid revalidate the field when pressing one of the following keys
|
|
|
308 |
// Shift => 16
|
|
|
309 |
// Ctrl => 17
|
|
|
310 |
// Alt => 18
|
|
|
311 |
// Caps lock => 20
|
|
|
312 |
// End => 35
|
|
|
313 |
// Home => 36
|
|
|
314 |
// Left arrow => 37
|
|
|
315 |
// Up arrow => 38
|
|
|
316 |
// Right arrow => 39
|
|
|
317 |
// Down arrow => 40
|
|
|
318 |
// Insert => 45
|
|
|
319 |
// Num lock => 144
|
|
|
320 |
// AltGr key => 225
|
|
|
321 |
var excludedKeys = [
|
|
|
322 |
16, 17, 18, 20, 35, 36, 37,
|
|
|
323 |
38, 39, 40, 45, 144, 225
|
|
|
324 |
];
|
|
|
325 |
|
|
|
326 |
if ( event.which === 9 && this.elementValue( element ) === "" || $.inArray( event.keyCode, excludedKeys ) !== -1 ) {
|
|
|
327 |
return;
|
|
|
328 |
} else if ( element.name in this.submitted || element.name in this.invalid ) {
|
|
|
329 |
this.element( element );
|
|
|
330 |
}
|
|
|
331 |
},
|
|
|
332 |
onclick: function( element ) {
|
|
|
333 |
|
|
|
334 |
// Click on selects, radiobuttons and checkboxes
|
|
|
335 |
if ( element.name in this.submitted ) {
|
|
|
336 |
this.element( element );
|
|
|
337 |
|
|
|
338 |
// Or option elements, check parent select in that case
|
|
|
339 |
} else if ( element.parentNode.name in this.submitted ) {
|
|
|
340 |
this.element( element.parentNode );
|
|
|
341 |
}
|
|
|
342 |
},
|
|
|
343 |
highlight: function( element, errorClass, validClass ) {
|
|
|
344 |
if ( element.type === "radio" ) {
|
|
|
345 |
this.findByName( element.name ).addClass( errorClass ).removeClass( validClass );
|
|
|
346 |
} else {
|
|
|
347 |
$( element ).addClass( errorClass ).removeClass( validClass );
|
|
|
348 |
}
|
|
|
349 |
},
|
|
|
350 |
unhighlight: function( element, errorClass, validClass ) {
|
|
|
351 |
if ( element.type === "radio" ) {
|
|
|
352 |
this.findByName( element.name ).removeClass( errorClass ).addClass( validClass );
|
|
|
353 |
} else {
|
|
|
354 |
$( element ).removeClass( errorClass ).addClass( validClass );
|
|
|
355 |
}
|
|
|
356 |
}
|
|
|
357 |
},
|
|
|
358 |
|
|
|
359 |
// https://jqueryvalidation.org/jQuery.validator.setDefaults/
|
|
|
360 |
setDefaults: function( settings ) {
|
|
|
361 |
$.extend( $.validator.defaults, settings );
|
|
|
362 |
},
|
|
|
363 |
|
|
|
364 |
messages: {
|
|
|
365 |
required: "This field is required.",
|
|
|
366 |
remote: "Please fix this field.",
|
|
|
367 |
email: "Please enter a valid email address.",
|
|
|
368 |
url: "Please enter a valid URL.",
|
|
|
369 |
date: "Please enter a valid date.",
|
|
|
370 |
dateISO: "Please enter a valid date (ISO).",
|
|
|
371 |
number: "Please enter a valid number.",
|
|
|
372 |
digits: "Please enter only digits.",
|
|
|
373 |
equalTo: "Please enter the same value again.",
|
|
|
374 |
maxlength: $.validator.format( "Please enter no more than {0} characters." ),
|
|
|
375 |
minlength: $.validator.format( "Please enter at least {0} characters." ),
|
|
|
376 |
rangelength: $.validator.format( "Please enter a value between {0} and {1} characters long." ),
|
|
|
377 |
range: $.validator.format( "Please enter a value between {0} and {1}." ),
|
|
|
378 |
max: $.validator.format( "Please enter a value less than or equal to {0}." ),
|
|
|
379 |
min: $.validator.format( "Please enter a value greater than or equal to {0}." ),
|
|
|
380 |
step: $.validator.format( "Please enter a multiple of {0}." )
|
|
|
381 |
},
|
|
|
382 |
|
|
|
383 |
autoCreateRanges: false,
|
|
|
384 |
|
|
|
385 |
prototype: {
|
|
|
386 |
|
|
|
387 |
init: function() {
|
|
|
388 |
this.labelContainer = $( this.settings.errorLabelContainer );
|
|
|
389 |
this.errorContext = this.labelContainer.length && this.labelContainer || $( this.currentForm );
|
|
|
390 |
this.containers = $( this.settings.errorContainer ).add( this.settings.errorLabelContainer );
|
|
|
391 |
this.submitted = {};
|
|
|
392 |
this.valueCache = {};
|
|
|
393 |
this.pendingRequest = 0;
|
|
|
394 |
this.pending = {};
|
|
|
395 |
this.invalid = {};
|
|
|
396 |
this.reset();
|
|
|
397 |
|
|
|
398 |
var currentForm = this.currentForm,
|
|
|
399 |
groups = ( this.groups = {} ),
|
|
|
400 |
rules;
|
|
|
401 |
$.each( this.settings.groups, function( key, value ) {
|
|
|
402 |
if ( typeof value === "string" ) {
|
|
|
403 |
value = value.split( /\s/ );
|
|
|
404 |
}
|
|
|
405 |
$.each( value, function( index, name ) {
|
|
|
406 |
groups[ name ] = key;
|
|
|
407 |
} );
|
|
|
408 |
} );
|
|
|
409 |
rules = this.settings.rules;
|
|
|
410 |
$.each( rules, function( key, value ) {
|
|
|
411 |
rules[ key ] = $.validator.normalizeRule( value );
|
|
|
412 |
} );
|
|
|
413 |
|
|
|
414 |
function delegate( event ) {
|
|
|
415 |
var isContentEditable = typeof $( this ).attr( "contenteditable" ) !== "undefined" && $( this ).attr( "contenteditable" ) !== "false";
|
|
|
416 |
|
|
|
417 |
// Set form expando on contenteditable
|
|
|
418 |
if ( !this.form && isContentEditable ) {
|
|
|
419 |
this.form = $( this ).closest( "form" )[ 0 ];
|
|
|
420 |
this.name = $( this ).attr( "name" );
|
|
|
421 |
}
|
|
|
422 |
|
|
|
423 |
// Ignore the element if it belongs to another form. This will happen mainly
|
|
|
424 |
// when setting the `form` attribute of an input to the id of another form.
|
|
|
425 |
if ( currentForm !== this.form ) {
|
|
|
426 |
return;
|
|
|
427 |
}
|
|
|
428 |
|
|
|
429 |
var validator = $.data( this.form, "validator" ),
|
|
|
430 |
eventType = "on" + event.type.replace( /^validate/, "" ),
|
|
|
431 |
settings = validator.settings;
|
|
|
432 |
if ( settings[ eventType ] && !$( this ).is( settings.ignore ) ) {
|
|
|
433 |
settings[ eventType ].call( validator, this, event );
|
|
|
434 |
}
|
|
|
435 |
}
|
|
|
436 |
|
|
|
437 |
$( this.currentForm )
|
|
|
438 |
.on( "focusin.validate focusout.validate keyup.validate",
|
|
|
439 |
":text, [type='password'], [type='file'], select, textarea, [type='number'], [type='search'], " +
|
|
|
440 |
"[type='tel'], [type='url'], [type='email'], [type='datetime'], [type='date'], [type='month'], " +
|
|
|
441 |
"[type='week'], [type='time'], [type='datetime-local'], [type='range'], [type='color'], " +
|
|
|
442 |
"[type='radio'], [type='checkbox'], [contenteditable], [type='button']", delegate )
|
|
|
443 |
|
|
|
444 |
// Support: Chrome, oldIE
|
|
|
445 |
// "select" is provided as event.target when clicking a option
|
|
|
446 |
.on( "click.validate", "select, option, [type='radio'], [type='checkbox']", delegate );
|
|
|
447 |
|
|
|
448 |
if ( this.settings.invalidHandler ) {
|
|
|
449 |
$( this.currentForm ).on( "invalid-form.validate", this.settings.invalidHandler );
|
|
|
450 |
}
|
|
|
451 |
},
|
|
|
452 |
|
|
|
453 |
// https://jqueryvalidation.org/Validator.form/
|
|
|
454 |
form: function() {
|
|
|
455 |
this.checkForm();
|
|
|
456 |
$.extend( this.submitted, this.errorMap );
|
|
|
457 |
this.invalid = $.extend( {}, this.errorMap );
|
|
|
458 |
if ( !this.valid() ) {
|
|
|
459 |
$( this.currentForm ).triggerHandler( "invalid-form", [ this ] );
|
|
|
460 |
}
|
|
|
461 |
this.showErrors();
|
|
|
462 |
return this.valid();
|
|
|
463 |
},
|
|
|
464 |
|
|
|
465 |
checkForm: function() {
|
|
|
466 |
this.prepareForm();
|
|
|
467 |
for ( var i = 0, elements = ( this.currentElements = this.elements() ); elements[ i ]; i++ ) {
|
|
|
468 |
this.check( elements[ i ] );
|
|
|
469 |
}
|
|
|
470 |
return this.valid();
|
|
|
471 |
},
|
|
|
472 |
|
|
|
473 |
// https://jqueryvalidation.org/Validator.element/
|
|
|
474 |
element: function( element ) {
|
|
|
475 |
var cleanElement = this.clean( element ),
|
|
|
476 |
checkElement = this.validationTargetFor( cleanElement ),
|
|
|
477 |
v = this,
|
|
|
478 |
result = true,
|
|
|
479 |
rs, group;
|
|
|
480 |
|
|
|
481 |
if ( checkElement === undefined ) {
|
|
|
482 |
delete this.invalid[ cleanElement.name ];
|
|
|
483 |
} else {
|
|
|
484 |
this.prepareElement( checkElement );
|
|
|
485 |
this.currentElements = $( checkElement );
|
|
|
486 |
|
|
|
487 |
// If this element is grouped, then validate all group elements already
|
|
|
488 |
// containing a value
|
|
|
489 |
group = this.groups[ checkElement.name ];
|
|
|
490 |
if ( group ) {
|
|
|
491 |
$.each( this.groups, function( name, testgroup ) {
|
|
|
492 |
if ( testgroup === group && name !== checkElement.name ) {
|
|
|
493 |
cleanElement = v.validationTargetFor( v.clean( v.findByName( name ) ) );
|
|
|
494 |
if ( cleanElement && cleanElement.name in v.invalid ) {
|
|
|
495 |
v.currentElements.push( cleanElement );
|
|
|
496 |
result = v.check( cleanElement ) && result;
|
|
|
497 |
}
|
|
|
498 |
}
|
|
|
499 |
} );
|
|
|
500 |
}
|
|
|
501 |
|
|
|
502 |
rs = this.check( checkElement ) !== false;
|
|
|
503 |
result = result && rs;
|
|
|
504 |
if ( rs ) {
|
|
|
505 |
this.invalid[ checkElement.name ] = false;
|
|
|
506 |
} else {
|
|
|
507 |
this.invalid[ checkElement.name ] = true;
|
|
|
508 |
}
|
|
|
509 |
|
|
|
510 |
if ( !this.numberOfInvalids() ) {
|
|
|
511 |
|
|
|
512 |
// Hide error containers on last error
|
|
|
513 |
this.toHide = this.toHide.add( this.containers );
|
|
|
514 |
}
|
|
|
515 |
this.showErrors();
|
|
|
516 |
|
|
|
517 |
// Add aria-invalid status for screen readers
|
|
|
518 |
$( element ).attr( "aria-invalid", !rs );
|
|
|
519 |
}
|
|
|
520 |
|
|
|
521 |
return result;
|
|
|
522 |
},
|
|
|
523 |
|
|
|
524 |
// https://jqueryvalidation.org/Validator.showErrors/
|
|
|
525 |
showErrors: function( errors ) {
|
|
|
526 |
if ( errors ) {
|
|
|
527 |
var validator = this;
|
|
|
528 |
|
|
|
529 |
// Add items to error list and map
|
|
|
530 |
$.extend( this.errorMap, errors );
|
|
|
531 |
this.errorList = $.map( this.errorMap, function( message, name ) {
|
|
|
532 |
return {
|
|
|
533 |
message: message,
|
|
|
534 |
element: validator.findByName( name )[ 0 ]
|
|
|
535 |
};
|
|
|
536 |
} );
|
|
|
537 |
|
|
|
538 |
// Remove items from success list
|
|
|
539 |
this.successList = $.grep( this.successList, function( element ) {
|
|
|
540 |
return !( element.name in errors );
|
|
|
541 |
} );
|
|
|
542 |
}
|
|
|
543 |
if ( this.settings.showErrors ) {
|
|
|
544 |
this.settings.showErrors.call( this, this.errorMap, this.errorList );
|
|
|
545 |
} else {
|
|
|
546 |
this.defaultShowErrors();
|
|
|
547 |
}
|
|
|
548 |
},
|
|
|
549 |
|
|
|
550 |
// https://jqueryvalidation.org/Validator.resetForm/
|
|
|
551 |
resetForm: function() {
|
|
|
552 |
if ( $.fn.resetForm ) {
|
|
|
553 |
$( this.currentForm ).resetForm();
|
|
|
554 |
}
|
|
|
555 |
this.invalid = {};
|
|
|
556 |
this.submitted = {};
|
|
|
557 |
this.prepareForm();
|
|
|
558 |
this.hideErrors();
|
|
|
559 |
var elements = this.elements()
|
|
|
560 |
.removeData( "previousValue" )
|
|
|
561 |
.removeAttr( "aria-invalid" );
|
|
|
562 |
|
|
|
563 |
this.resetElements( elements );
|
|
|
564 |
},
|
|
|
565 |
|
|
|
566 |
resetElements: function( elements ) {
|
|
|
567 |
var i;
|
|
|
568 |
|
|
|
569 |
if ( this.settings.unhighlight ) {
|
|
|
570 |
for ( i = 0; elements[ i ]; i++ ) {
|
|
|
571 |
this.settings.unhighlight.call( this, elements[ i ],
|
|
|
572 |
this.settings.errorClass, "" );
|
|
|
573 |
this.findByName( elements[ i ].name ).removeClass( this.settings.validClass );
|
|
|
574 |
}
|
|
|
575 |
} else {
|
|
|
576 |
elements
|
|
|
577 |
.removeClass( this.settings.errorClass )
|
|
|
578 |
.removeClass( this.settings.validClass );
|
|
|
579 |
}
|
|
|
580 |
},
|
|
|
581 |
|
|
|
582 |
numberOfInvalids: function() {
|
|
|
583 |
return this.objectLength( this.invalid );
|
|
|
584 |
},
|
|
|
585 |
|
|
|
586 |
objectLength: function( obj ) {
|
|
|
587 |
/* jshint unused: false */
|
|
|
588 |
var count = 0,
|
|
|
589 |
i;
|
|
|
590 |
for ( i in obj ) {
|
|
|
591 |
|
|
|
592 |
// This check allows counting elements with empty error
|
|
|
593 |
// message as invalid elements
|
|
|
594 |
if ( obj[ i ] !== undefined && obj[ i ] !== null && obj[ i ] !== false ) {
|
|
|
595 |
count++;
|
|
|
596 |
}
|
|
|
597 |
}
|
|
|
598 |
return count;
|
|
|
599 |
},
|
|
|
600 |
|
|
|
601 |
hideErrors: function() {
|
|
|
602 |
this.hideThese( this.toHide );
|
|
|
603 |
},
|
|
|
604 |
|
|
|
605 |
hideThese: function( errors ) {
|
|
|
606 |
errors.not( this.containers ).text( "" );
|
|
|
607 |
this.addWrapper( errors ).hide();
|
|
|
608 |
},
|
|
|
609 |
|
|
|
610 |
valid: function() {
|
|
|
611 |
return this.size() === 0;
|
|
|
612 |
},
|
|
|
613 |
|
|
|
614 |
size: function() {
|
|
|
615 |
return this.errorList.length;
|
|
|
616 |
},
|
|
|
617 |
|
|
|
618 |
focusInvalid: function() {
|
|
|
619 |
if ( this.settings.focusInvalid ) {
|
|
|
620 |
try {
|
|
|
621 |
$( this.findLastActive() || this.errorList.length && this.errorList[ 0 ].element || [] )
|
|
|
622 |
.filter( ":visible" )
|
|
|
623 |
.focus()
|
|
|
624 |
|
|
|
625 |
// Manually trigger focusin event; without it, focusin handler isn't called, findLastActive won't have anything to find
|
|
|
626 |
.trigger( "focusin" );
|
|
|
627 |
} catch ( e ) {
|
|
|
628 |
|
|
|
629 |
// Ignore IE throwing errors when focusing hidden elements
|
|
|
630 |
}
|
|
|
631 |
}
|
|
|
632 |
},
|
|
|
633 |
|
|
|
634 |
findLastActive: function() {
|
|
|
635 |
var lastActive = this.lastActive;
|
|
|
636 |
return lastActive && $.grep( this.errorList, function( n ) {
|
|
|
637 |
return n.element.name === lastActive.name;
|
|
|
638 |
} ).length === 1 && lastActive;
|
|
|
639 |
},
|
|
|
640 |
|
|
|
641 |
elements: function() {
|
|
|
642 |
var validator = this,
|
|
|
643 |
rulesCache = {};
|
|
|
644 |
|
|
|
645 |
// Select all valid inputs inside the form (no submit or reset buttons)
|
|
|
646 |
return $( this.currentForm )
|
|
|
647 |
.find( "input, select, textarea, [contenteditable]" )
|
|
|
648 |
.not( ":submit, :reset, :image, :disabled" )
|
|
|
649 |
.not( this.settings.ignore )
|
|
|
650 |
.filter( function() {
|
|
|
651 |
var name = this.name || $( this ).attr( "name" ); // For contenteditable
|
|
|
652 |
var isContentEditable = typeof $( this ).attr( "contenteditable" ) !== "undefined" && $( this ).attr( "contenteditable" ) !== "false";
|
|
|
653 |
|
|
|
654 |
if ( !name && validator.settings.debug && window.console ) {
|
|
|
655 |
console.error( "%o has no name assigned", this );
|
|
|
656 |
}
|
|
|
657 |
|
|
|
658 |
// Set form expando on contenteditable
|
|
|
659 |
if ( isContentEditable ) {
|
|
|
660 |
this.form = $( this ).closest( "form" )[ 0 ];
|
|
|
661 |
this.name = name;
|
|
|
662 |
}
|
|
|
663 |
|
|
|
664 |
// Ignore elements that belong to other/nested forms
|
|
|
665 |
if ( this.form !== validator.currentForm ) {
|
|
|
666 |
return false;
|
|
|
667 |
}
|
|
|
668 |
|
|
|
669 |
// Select only the first element for each name, and only those with rules specified
|
|
|
670 |
if ( name in rulesCache || !validator.objectLength( $( this ).rules() ) ) {
|
|
|
671 |
return false;
|
|
|
672 |
}
|
|
|
673 |
|
|
|
674 |
rulesCache[ name ] = true;
|
|
|
675 |
return true;
|
|
|
676 |
} );
|
|
|
677 |
},
|
|
|
678 |
|
|
|
679 |
clean: function( selector ) {
|
|
|
680 |
return $( selector )[ 0 ];
|
|
|
681 |
},
|
|
|
682 |
|
|
|
683 |
errors: function() {
|
|
|
684 |
var errorClass = this.settings.errorClass.split( " " ).join( "." );
|
|
|
685 |
return $( this.settings.errorElement + "." + errorClass, this.errorContext );
|
|
|
686 |
},
|
|
|
687 |
|
|
|
688 |
resetInternals: function() {
|
|
|
689 |
this.successList = [];
|
|
|
690 |
this.errorList = [];
|
|
|
691 |
this.errorMap = {};
|
|
|
692 |
this.toShow = $( [] );
|
|
|
693 |
this.toHide = $( [] );
|
|
|
694 |
},
|
|
|
695 |
|
|
|
696 |
reset: function() {
|
|
|
697 |
this.resetInternals();
|
|
|
698 |
this.currentElements = $( [] );
|
|
|
699 |
},
|
|
|
700 |
|
|
|
701 |
prepareForm: function() {
|
|
|
702 |
this.reset();
|
|
|
703 |
this.toHide = this.errors().add( this.containers );
|
|
|
704 |
},
|
|
|
705 |
|
|
|
706 |
prepareElement: function( element ) {
|
|
|
707 |
this.reset();
|
|
|
708 |
this.toHide = this.errorsFor( element );
|
|
|
709 |
},
|
|
|
710 |
|
|
|
711 |
elementValue: function( element ) {
|
|
|
712 |
var $element = $( element ),
|
|
|
713 |
type = element.type,
|
|
|
714 |
isContentEditable = typeof $element.attr( "contenteditable" ) !== "undefined" && $element.attr( "contenteditable" ) !== "false",
|
|
|
715 |
val, idx;
|
|
|
716 |
|
|
|
717 |
if ( type === "radio" || type === "checkbox" ) {
|
|
|
718 |
return this.findByName( element.name ).filter( ":checked" ).val();
|
|
|
719 |
} else if ( type === "number" && typeof element.validity !== "undefined" ) {
|
|
|
720 |
return element.validity.badInput ? "NaN" : $element.val();
|
|
|
721 |
}
|
|
|
722 |
|
|
|
723 |
if ( isContentEditable ) {
|
|
|
724 |
val = $element.text();
|
|
|
725 |
} else {
|
|
|
726 |
val = $element.val();
|
|
|
727 |
}
|
|
|
728 |
|
|
|
729 |
if ( type === "file" ) {
|
|
|
730 |
|
|
|
731 |
// Modern browser (chrome & safari)
|
|
|
732 |
if ( val.substr( 0, 12 ) === "C:\\fakepath\\" ) {
|
|
|
733 |
return val.substr( 12 );
|
|
|
734 |
}
|
|
|
735 |
|
|
|
736 |
// Legacy browsers
|
|
|
737 |
// Unix-based path
|
|
|
738 |
idx = val.lastIndexOf( "/" );
|
|
|
739 |
if ( idx >= 0 ) {
|
|
|
740 |
return val.substr( idx + 1 );
|
|
|
741 |
}
|
|
|
742 |
|
|
|
743 |
// Windows-based path
|
|
|
744 |
idx = val.lastIndexOf( "\\" );
|
|
|
745 |
if ( idx >= 0 ) {
|
|
|
746 |
return val.substr( idx + 1 );
|
|
|
747 |
}
|
|
|
748 |
|
|
|
749 |
// Just the file name
|
|
|
750 |
return val;
|
|
|
751 |
}
|
|
|
752 |
|
|
|
753 |
if ( typeof val === "string" ) {
|
|
|
754 |
return val.replace( /\r/g, "" );
|
|
|
755 |
}
|
|
|
756 |
return val;
|
|
|
757 |
},
|
|
|
758 |
|
|
|
759 |
check: function( element ) {
|
|
|
760 |
element = this.validationTargetFor( this.clean( element ) );
|
|
|
761 |
|
|
|
762 |
var rules = $( element ).rules(),
|
|
|
763 |
rulesCount = $.map( rules, function( n, i ) {
|
|
|
764 |
return i;
|
|
|
765 |
} ).length,
|
|
|
766 |
dependencyMismatch = false,
|
|
|
767 |
val = this.elementValue( element ),
|
|
|
768 |
result, method, rule, normalizer;
|
|
|
769 |
|
|
|
770 |
// Prioritize the local normalizer defined for this element over the global one
|
|
|
771 |
// if the former exists, otherwise user the global one in case it exists.
|
|
|
772 |
if ( typeof rules.normalizer === "function" ) {
|
|
|
773 |
normalizer = rules.normalizer;
|
|
|
774 |
} else if ( typeof this.settings.normalizer === "function" ) {
|
|
|
775 |
normalizer = this.settings.normalizer;
|
|
|
776 |
}
|
|
|
777 |
|
|
|
778 |
// If normalizer is defined, then call it to retreive the changed value instead
|
|
|
779 |
// of using the real one.
|
|
|
780 |
// Note that `this` in the normalizer is `element`.
|
|
|
781 |
if ( normalizer ) {
|
|
|
782 |
val = normalizer.call( element, val );
|
|
|
783 |
|
|
|
784 |
// Delete the normalizer from rules to avoid treating it as a pre-defined method.
|
|
|
785 |
delete rules.normalizer;
|
|
|
786 |
}
|
|
|
787 |
|
|
|
788 |
for ( method in rules ) {
|
|
|
789 |
rule = { method: method, parameters: rules[ method ] };
|
|
|
790 |
try {
|
|
|
791 |
result = $.validator.methods[ method ].call( this, val, element, rule.parameters );
|
|
|
792 |
|
|
|
793 |
// If a method indicates that the field is optional and therefore valid,
|
|
|
794 |
// don't mark it as valid when there are no other rules
|
|
|
795 |
if ( result === "dependency-mismatch" && rulesCount === 1 ) {
|
|
|
796 |
dependencyMismatch = true;
|
|
|
797 |
continue;
|
|
|
798 |
}
|
|
|
799 |
dependencyMismatch = false;
|
|
|
800 |
|
|
|
801 |
if ( result === "pending" ) {
|
|
|
802 |
this.toHide = this.toHide.not( this.errorsFor( element ) );
|
|
|
803 |
return;
|
|
|
804 |
}
|
|
|
805 |
|
|
|
806 |
if ( !result ) {
|
|
|
807 |
this.formatAndAdd( element, rule );
|
|
|
808 |
return false;
|
|
|
809 |
}
|
|
|
810 |
} catch ( e ) {
|
|
|
811 |
if ( this.settings.debug && window.console ) {
|
|
|
812 |
console.log( "Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.", e );
|
|
|
813 |
}
|
|
|
814 |
if ( e instanceof TypeError ) {
|
|
|
815 |
e.message += ". Exception occurred when checking element " + element.id + ", check the '" + rule.method + "' method.";
|
|
|
816 |
}
|
|
|
817 |
|
|
|
818 |
throw e;
|
|
|
819 |
}
|
|
|
820 |
}
|
|
|
821 |
if ( dependencyMismatch ) {
|
|
|
822 |
return;
|
|
|
823 |
}
|
|
|
824 |
if ( this.objectLength( rules ) ) {
|
|
|
825 |
this.successList.push( element );
|
|
|
826 |
}
|
|
|
827 |
return true;
|
|
|
828 |
},
|
|
|
829 |
|
|
|
830 |
// Return the custom message for the given element and validation method
|
|
|
831 |
// specified in the element's HTML5 data attribute
|
|
|
832 |
// return the generic message if present and no method specific message is present
|
|
|
833 |
customDataMessage: function( element, method ) {
|
|
|
834 |
return $( element ).data( "msg" + method.charAt( 0 ).toUpperCase() +
|
|
|
835 |
method.substring( 1 ).toLowerCase() ) || $( element ).data( "msg" );
|
|
|
836 |
},
|
|
|
837 |
|
|
|
838 |
// Return the custom message for the given element name and validation method
|
|
|
839 |
customMessage: function( name, method ) {
|
|
|
840 |
var m = this.settings.messages[ name ];
|
|
|
841 |
return m && ( m.constructor === String ? m : m[ method ] );
|
|
|
842 |
},
|
|
|
843 |
|
|
|
844 |
// Return the first defined argument, allowing empty strings
|
|
|
845 |
findDefined: function() {
|
|
|
846 |
for ( var i = 0; i < arguments.length; i++ ) {
|
|
|
847 |
if ( arguments[ i ] !== undefined ) {
|
|
|
848 |
return arguments[ i ];
|
|
|
849 |
}
|
|
|
850 |
}
|
|
|
851 |
return undefined;
|
|
|
852 |
},
|
|
|
853 |
|
|
|
854 |
// The second parameter 'rule' used to be a string, and extended to an object literal
|
|
|
855 |
// of the following form:
|
|
|
856 |
// rule = {
|
|
|
857 |
// method: "method name",
|
|
|
858 |
// parameters: "the given method parameters"
|
|
|
859 |
// }
|
|
|
860 |
//
|
|
|
861 |
// The old behavior still supported, kept to maintain backward compatibility with
|
|
|
862 |
// old code, and will be removed in the next major release.
|
|
|
863 |
defaultMessage: function( element, rule ) {
|
|
|
864 |
if ( typeof rule === "string" ) {
|
|
|
865 |
rule = { method: rule };
|
|
|
866 |
}
|
|
|
867 |
|
|
|
868 |
var message = this.findDefined(
|
|
|
869 |
this.customMessage( element.name, rule.method ),
|
|
|
870 |
this.customDataMessage( element, rule.method ),
|
|
|
871 |
|
|
|
872 |
// 'title' is never undefined, so handle empty string as undefined
|
|
|
873 |
!this.settings.ignoreTitle && element.title || undefined,
|
|
|
874 |
$.validator.messages[ rule.method ],
|
|
|
875 |
"<strong>Warning: No message defined for " + element.name + "</strong>"
|
|
|
876 |
),
|
|
|
877 |
theregex = /\$?\{(\d+)\}/g;
|
|
|
878 |
if ( typeof message === "function" ) {
|
|
|
879 |
message = message.call( this, rule.parameters, element );
|
|
|
880 |
} else if ( theregex.test( message ) ) {
|
|
|
881 |
message = $.validator.format( message.replace( theregex, "{$1}" ), rule.parameters );
|
|
|
882 |
}
|
|
|
883 |
|
|
|
884 |
return message;
|
|
|
885 |
},
|
|
|
886 |
|
|
|
887 |
formatAndAdd: function( element, rule ) {
|
|
|
888 |
var message = this.defaultMessage( element, rule );
|
|
|
889 |
|
|
|
890 |
this.errorList.push( {
|
|
|
891 |
message: message,
|
|
|
892 |
element: element,
|
|
|
893 |
method: rule.method
|
|
|
894 |
} );
|
|
|
895 |
|
|
|
896 |
this.errorMap[ element.name ] = message;
|
|
|
897 |
this.submitted[ element.name ] = message;
|
|
|
898 |
},
|
|
|
899 |
|
|
|
900 |
addWrapper: function( toToggle ) {
|
|
|
901 |
if ( this.settings.wrapper ) {
|
|
|
902 |
toToggle = toToggle.add( toToggle.parent( this.settings.wrapper ) );
|
|
|
903 |
}
|
|
|
904 |
return toToggle;
|
|
|
905 |
},
|
|
|
906 |
|
|
|
907 |
defaultShowErrors: function() {
|
|
|
908 |
var i, elements, error;
|
|
|
909 |
for ( i = 0; this.errorList[ i ]; i++ ) {
|
|
|
910 |
error = this.errorList[ i ];
|
|
|
911 |
if ( this.settings.highlight ) {
|
|
|
912 |
this.settings.highlight.call( this, error.element, this.settings.errorClass, this.settings.validClass );
|
|
|
913 |
}
|
|
|
914 |
this.showLabel( error.element, error.message );
|
|
|
915 |
}
|
|
|
916 |
if ( this.errorList.length ) {
|
|
|
917 |
this.toShow = this.toShow.add( this.containers );
|
|
|
918 |
}
|
|
|
919 |
if ( this.settings.success ) {
|
|
|
920 |
for ( i = 0; this.successList[ i ]; i++ ) {
|
|
|
921 |
this.showLabel( this.successList[ i ] );
|
|
|
922 |
}
|
|
|
923 |
}
|
|
|
924 |
if ( this.settings.unhighlight ) {
|
|
|
925 |
for ( i = 0, elements = this.validElements(); elements[ i ]; i++ ) {
|
|
|
926 |
this.settings.unhighlight.call( this, elements[ i ], this.settings.errorClass, this.settings.validClass );
|
|
|
927 |
}
|
|
|
928 |
}
|
|
|
929 |
this.toHide = this.toHide.not( this.toShow );
|
|
|
930 |
this.hideErrors();
|
|
|
931 |
this.addWrapper( this.toShow ).show();
|
|
|
932 |
},
|
|
|
933 |
|
|
|
934 |
validElements: function() {
|
|
|
935 |
return this.currentElements.not( this.invalidElements() );
|
|
|
936 |
},
|
|
|
937 |
|
|
|
938 |
invalidElements: function() {
|
|
|
939 |
return $( this.errorList ).map( function() {
|
|
|
940 |
return this.element;
|
|
|
941 |
} );
|
|
|
942 |
},
|
|
|
943 |
|
|
|
944 |
showLabel: function( element, message ) {
|
|
|
945 |
var place, group, errorID, v,
|
|
|
946 |
error = this.errorsFor( element ),
|
|
|
947 |
elementID = this.idOrName( element ),
|
|
|
948 |
describedBy = $( element ).attr( "aria-describedby" );
|
|
|
949 |
|
|
|
950 |
if ( error.length ) {
|
|
|
951 |
|
|
|
952 |
// Refresh error/success class
|
|
|
953 |
error.removeClass( this.settings.validClass ).addClass( this.settings.errorClass );
|
|
|
954 |
|
|
|
955 |
// Replace message on existing label
|
|
|
956 |
error.html( message );
|
|
|
957 |
} else {
|
|
|
958 |
|
|
|
959 |
// Create error element
|
|
|
960 |
error = $( "<" + this.settings.errorElement + ">" )
|
|
|
961 |
.attr( "id", elementID + "-error" )
|
|
|
962 |
.addClass( this.settings.errorClass )
|
|
|
963 |
.html( message || "" );
|
|
|
964 |
|
|
|
965 |
// Maintain reference to the element to be placed into the DOM
|
|
|
966 |
place = error;
|
|
|
967 |
if ( this.settings.wrapper ) {
|
|
|
968 |
|
|
|
969 |
// Make sure the element is visible, even in IE
|
|
|
970 |
// actually showing the wrapped element is handled elsewhere
|
|
|
971 |
place = error.hide().show().wrap( "<" + this.settings.wrapper + "/>" ).parent();
|
|
|
972 |
}
|
|
|
973 |
if ( this.labelContainer.length ) {
|
|
|
974 |
this.labelContainer.append( place );
|
|
|
975 |
} else if ( this.settings.errorPlacement ) {
|
|
|
976 |
this.settings.errorPlacement.call( this, place, $( element ) );
|
|
|
977 |
} else {
|
|
|
978 |
place.insertAfter( element );
|
|
|
979 |
}
|
|
|
980 |
|
|
|
981 |
// Link error back to the element
|
|
|
982 |
if ( error.is( "label" ) ) {
|
|
|
983 |
|
|
|
984 |
// If the error is a label, then associate using 'for'
|
|
|
985 |
error.attr( "for", elementID );
|
|
|
986 |
|
|
|
987 |
// If the element is not a child of an associated label, then it's necessary
|
|
|
988 |
// to explicitly apply aria-describedby
|
|
|
989 |
} else if ( error.parents( "label[for='" + this.escapeCssMeta( elementID ) + "']" ).length === 0 ) {
|
|
|
990 |
errorID = error.attr( "id" );
|
|
|
991 |
|
|
|
992 |
// Respect existing non-error aria-describedby
|
|
|
993 |
if ( !describedBy ) {
|
|
|
994 |
describedBy = errorID;
|
|
|
995 |
} else if ( !describedBy.match( new RegExp( "\\b" + this.escapeCssMeta( errorID ) + "\\b" ) ) ) {
|
|
|
996 |
|
|
|
997 |
// Add to end of list if not already present
|
|
|
998 |
describedBy += " " + errorID;
|
|
|
999 |
}
|
|
|
1000 |
$( element ).attr( "aria-describedby", describedBy );
|
|
|
1001 |
|
|
|
1002 |
// If this element is grouped, then assign to all elements in the same group
|
|
|
1003 |
group = this.groups[ element.name ];
|
|
|
1004 |
if ( group ) {
|
|
|
1005 |
v = this;
|
|
|
1006 |
$.each( v.groups, function( name, testgroup ) {
|
|
|
1007 |
if ( testgroup === group ) {
|
|
|
1008 |
$( "[name='" + v.escapeCssMeta( name ) + "']", v.currentForm )
|
|
|
1009 |
.attr( "aria-describedby", error.attr( "id" ) );
|
|
|
1010 |
}
|
|
|
1011 |
} );
|
|
|
1012 |
}
|
|
|
1013 |
}
|
|
|
1014 |
}
|
|
|
1015 |
if ( !message && this.settings.success ) {
|
|
|
1016 |
error.text( "" );
|
|
|
1017 |
if ( typeof this.settings.success === "string" ) {
|
|
|
1018 |
error.addClass( this.settings.success );
|
|
|
1019 |
} else {
|
|
|
1020 |
this.settings.success( error, element );
|
|
|
1021 |
}
|
|
|
1022 |
}
|
|
|
1023 |
this.toShow = this.toShow.add( error );
|
|
|
1024 |
},
|
|
|
1025 |
|
|
|
1026 |
errorsFor: function( element ) {
|
|
|
1027 |
var name = this.escapeCssMeta( this.idOrName( element ) ),
|
|
|
1028 |
describer = $( element ).attr( "aria-describedby" ),
|
|
|
1029 |
selector = "label[for='" + name + "'], label[for='" + name + "'] *";
|
|
|
1030 |
|
|
|
1031 |
// 'aria-describedby' should directly reference the error element
|
|
|
1032 |
if ( describer ) {
|
|
|
1033 |
selector = selector + ", #" + this.escapeCssMeta( describer )
|
|
|
1034 |
.replace( /\s+/g, ", #" );
|
|
|
1035 |
}
|
|
|
1036 |
|
|
|
1037 |
return this
|
|
|
1038 |
.errors()
|
|
|
1039 |
.filter( selector );
|
|
|
1040 |
},
|
|
|
1041 |
|
|
|
1042 |
// See https://api.jquery.com/category/selectors/, for CSS
|
|
|
1043 |
// meta-characters that should be escaped in order to be used with JQuery
|
|
|
1044 |
// as a literal part of a name/id or any selector.
|
|
|
1045 |
escapeCssMeta: function( string ) {
|
|
|
1046 |
return string.replace( /([\\!"#$%&'()*+,./:;<=>?@\[\]^`{|}~])/g, "\\$1" );
|
|
|
1047 |
},
|
|
|
1048 |
|
|
|
1049 |
idOrName: function( element ) {
|
|
|
1050 |
return this.groups[ element.name ] || ( this.checkable( element ) ? element.name : element.id || element.name );
|
|
|
1051 |
},
|
|
|
1052 |
|
|
|
1053 |
validationTargetFor: function( element ) {
|
|
|
1054 |
|
|
|
1055 |
// If radio/checkbox, validate first element in group instead
|
|
|
1056 |
if ( this.checkable( element ) ) {
|
|
|
1057 |
element = this.findByName( element.name );
|
|
|
1058 |
}
|
|
|
1059 |
|
|
|
1060 |
// Always apply ignore filter
|
|
|
1061 |
return $( element ).not( this.settings.ignore )[ 0 ];
|
|
|
1062 |
},
|
|
|
1063 |
|
|
|
1064 |
checkable: function( element ) {
|
|
|
1065 |
return ( /radio|checkbox/i ).test( element.type );
|
|
|
1066 |
},
|
|
|
1067 |
|
|
|
1068 |
findByName: function( name ) {
|
|
|
1069 |
return $( this.currentForm ).find( "[name='" + this.escapeCssMeta( name ) + "']" );
|
|
|
1070 |
},
|
|
|
1071 |
|
|
|
1072 |
getLength: function( value, element ) {
|
|
|
1073 |
switch ( element.nodeName.toLowerCase() ) {
|
|
|
1074 |
case "select":
|
|
|
1075 |
return $( "option:selected", element ).length;
|
|
|
1076 |
case "input":
|
|
|
1077 |
if ( this.checkable( element ) ) {
|
|
|
1078 |
return this.findByName( element.name ).filter( ":checked" ).length;
|
|
|
1079 |
}
|
|
|
1080 |
}
|
|
|
1081 |
return value.length;
|
|
|
1082 |
},
|
|
|
1083 |
|
|
|
1084 |
depend: function( param, element ) {
|
|
|
1085 |
return this.dependTypes[ typeof param ] ? this.dependTypes[ typeof param ]( param, element ) : true;
|
|
|
1086 |
},
|
|
|
1087 |
|
|
|
1088 |
dependTypes: {
|
|
|
1089 |
"boolean": function( param ) {
|
|
|
1090 |
return param;
|
|
|
1091 |
},
|
|
|
1092 |
"string": function( param, element ) {
|
|
|
1093 |
return !!$( param, element.form ).length;
|
|
|
1094 |
},
|
|
|
1095 |
"function": function( param, element ) {
|
|
|
1096 |
return param( element );
|
|
|
1097 |
}
|
|
|
1098 |
},
|
|
|
1099 |
|
|
|
1100 |
optional: function( element ) {
|
|
|
1101 |
var val = this.elementValue( element );
|
|
|
1102 |
return !$.validator.methods.required.call( this, val, element ) && "dependency-mismatch";
|
|
|
1103 |
},
|
|
|
1104 |
|
|
|
1105 |
startRequest: function( element ) {
|
|
|
1106 |
if ( !this.pending[ element.name ] ) {
|
|
|
1107 |
this.pendingRequest++;
|
|
|
1108 |
$( element ).addClass( this.settings.pendingClass );
|
|
|
1109 |
this.pending[ element.name ] = true;
|
|
|
1110 |
}
|
|
|
1111 |
},
|
|
|
1112 |
|
|
|
1113 |
stopRequest: function( element, valid ) {
|
|
|
1114 |
this.pendingRequest--;
|
|
|
1115 |
|
|
|
1116 |
// Sometimes synchronization fails, make sure pendingRequest is never < 0
|
|
|
1117 |
if ( this.pendingRequest < 0 ) {
|
|
|
1118 |
this.pendingRequest = 0;
|
|
|
1119 |
}
|
|
|
1120 |
delete this.pending[ element.name ];
|
|
|
1121 |
$( element ).removeClass( this.settings.pendingClass );
|
|
|
1122 |
if ( valid && this.pendingRequest === 0 && this.formSubmitted && this.form() ) {
|
|
|
1123 |
$( this.currentForm ).submit();
|
|
|
1124 |
|
|
|
1125 |
// Remove the hidden input that was used as a replacement for the
|
|
|
1126 |
// missing submit button. The hidden input is added by `handle()`
|
|
|
1127 |
// to ensure that the value of the used submit button is passed on
|
|
|
1128 |
// for scripted submits triggered by this method
|
|
|
1129 |
if ( this.submitButton ) {
|
|
|
1130 |
$( "input:hidden[name='" + this.submitButton.name + "']", this.currentForm ).remove();
|
|
|
1131 |
}
|
|
|
1132 |
|
|
|
1133 |
this.formSubmitted = false;
|
|
|
1134 |
} else if ( !valid && this.pendingRequest === 0 && this.formSubmitted ) {
|
|
|
1135 |
$( this.currentForm ).triggerHandler( "invalid-form", [ this ] );
|
|
|
1136 |
this.formSubmitted = false;
|
|
|
1137 |
}
|
|
|
1138 |
},
|
|
|
1139 |
|
|
|
1140 |
previousValue: function( element, method ) {
|
|
|
1141 |
method = typeof method === "string" && method || "remote";
|
|
|
1142 |
|
|
|
1143 |
return $.data( element, "previousValue" ) || $.data( element, "previousValue", {
|
|
|
1144 |
old: null,
|
|
|
1145 |
valid: true,
|
|
|
1146 |
message: this.defaultMessage( element, { method: method } )
|
|
|
1147 |
} );
|
|
|
1148 |
},
|
|
|
1149 |
|
|
|
1150 |
// Cleans up all forms and elements, removes validator-specific events
|
|
|
1151 |
destroy: function() {
|
|
|
1152 |
this.resetForm();
|
|
|
1153 |
|
|
|
1154 |
$( this.currentForm )
|
|
|
1155 |
.off( ".validate" )
|
|
|
1156 |
.removeData( "validator" )
|
|
|
1157 |
.find( ".validate-equalTo-blur" )
|
|
|
1158 |
.off( ".validate-equalTo" )
|
|
|
1159 |
.removeClass( "validate-equalTo-blur" )
|
|
|
1160 |
.find( ".validate-lessThan-blur" )
|
|
|
1161 |
.off( ".validate-lessThan" )
|
|
|
1162 |
.removeClass( "validate-lessThan-blur" )
|
|
|
1163 |
.find( ".validate-lessThanEqual-blur" )
|
|
|
1164 |
.off( ".validate-lessThanEqual" )
|
|
|
1165 |
.removeClass( "validate-lessThanEqual-blur" )
|
|
|
1166 |
.find( ".validate-greaterThanEqual-blur" )
|
|
|
1167 |
.off( ".validate-greaterThanEqual" )
|
|
|
1168 |
.removeClass( "validate-greaterThanEqual-blur" )
|
|
|
1169 |
.find( ".validate-greaterThan-blur" )
|
|
|
1170 |
.off( ".validate-greaterThan" )
|
|
|
1171 |
.removeClass( "validate-greaterThan-blur" );
|
|
|
1172 |
}
|
|
|
1173 |
|
|
|
1174 |
},
|
|
|
1175 |
|
|
|
1176 |
classRuleSettings: {
|
|
|
1177 |
required: { required: true },
|
|
|
1178 |
email: { email: true },
|
|
|
1179 |
url: { url: true },
|
|
|
1180 |
date: { date: true },
|
|
|
1181 |
dateISO: { dateISO: true },
|
|
|
1182 |
number: { number: true },
|
|
|
1183 |
digits: { digits: true },
|
|
|
1184 |
creditcard: { creditcard: true }
|
|
|
1185 |
},
|
|
|
1186 |
|
|
|
1187 |
addClassRules: function( className, rules ) {
|
|
|
1188 |
if ( className.constructor === String ) {
|
|
|
1189 |
this.classRuleSettings[ className ] = rules;
|
|
|
1190 |
} else {
|
|
|
1191 |
$.extend( this.classRuleSettings, className );
|
|
|
1192 |
}
|
|
|
1193 |
},
|
|
|
1194 |
|
|
|
1195 |
classRules: function( element ) {
|
|
|
1196 |
var rules = {},
|
|
|
1197 |
classes = $( element ).attr( "class" );
|
|
|
1198 |
|
|
|
1199 |
if ( classes ) {
|
|
|
1200 |
$.each( classes.split( " " ), function() {
|
|
|
1201 |
if ( this in $.validator.classRuleSettings ) {
|
|
|
1202 |
$.extend( rules, $.validator.classRuleSettings[ this ] );
|
|
|
1203 |
}
|
|
|
1204 |
} );
|
|
|
1205 |
}
|
|
|
1206 |
return rules;
|
|
|
1207 |
},
|
|
|
1208 |
|
|
|
1209 |
normalizeAttributeRule: function( rules, type, method, value ) {
|
|
|
1210 |
|
|
|
1211 |
// Convert the value to a number for number inputs, and for text for backwards compability
|
|
|
1212 |
// allows type="date" and others to be compared as strings
|
|
|
1213 |
if ( /min|max|step/.test( method ) && ( type === null || /number|range|text/.test( type ) ) ) {
|
|
|
1214 |
value = Number( value );
|
|
|
1215 |
|
|
|
1216 |
// Support Opera Mini, which returns NaN for undefined minlength
|
|
|
1217 |
if ( isNaN( value ) ) {
|
|
|
1218 |
value = undefined;
|
|
|
1219 |
}
|
|
|
1220 |
}
|
|
|
1221 |
|
|
|
1222 |
if ( value || value === 0 ) {
|
|
|
1223 |
rules[ method ] = value;
|
|
|
1224 |
} else if ( type === method && type !== "range" ) {
|
|
|
1225 |
|
|
|
1226 |
// Exception: the jquery validate 'range' method
|
|
|
1227 |
// does not test for the html5 'range' type
|
|
|
1228 |
rules[ method ] = true;
|
|
|
1229 |
}
|
|
|
1230 |
},
|
|
|
1231 |
|
|
|
1232 |
attributeRules: function( element ) {
|
|
|
1233 |
var rules = {},
|
|
|
1234 |
$element = $( element ),
|
|
|
1235 |
type = element.getAttribute( "type" ),
|
|
|
1236 |
method, value;
|
|
|
1237 |
|
|
|
1238 |
for ( method in $.validator.methods ) {
|
|
|
1239 |
|
|
|
1240 |
// Support for <input required> in both html5 and older browsers
|
|
|
1241 |
if ( method === "required" ) {
|
|
|
1242 |
value = element.getAttribute( method );
|
|
|
1243 |
|
|
|
1244 |
// Some browsers return an empty string for the required attribute
|
|
|
1245 |
// and non-HTML5 browsers might have required="" markup
|
|
|
1246 |
if ( value === "" ) {
|
|
|
1247 |
value = true;
|
|
|
1248 |
}
|
|
|
1249 |
|
|
|
1250 |
// Force non-HTML5 browsers to return bool
|
|
|
1251 |
value = !!value;
|
|
|
1252 |
} else {
|
|
|
1253 |
value = $element.attr( method );
|
|
|
1254 |
}
|
|
|
1255 |
|
|
|
1256 |
this.normalizeAttributeRule( rules, type, method, value );
|
|
|
1257 |
}
|
|
|
1258 |
|
|
|
1259 |
// 'maxlength' may be returned as -1, 2147483647 ( IE ) and 524288 ( safari ) for text inputs
|
|
|
1260 |
if ( rules.maxlength && /-1|2147483647|524288/.test( rules.maxlength ) ) {
|
|
|
1261 |
delete rules.maxlength;
|
|
|
1262 |
}
|
|
|
1263 |
|
|
|
1264 |
return rules;
|
|
|
1265 |
},
|
|
|
1266 |
|
|
|
1267 |
dataRules: function( element ) {
|
|
|
1268 |
var rules = {},
|
|
|
1269 |
$element = $( element ),
|
|
|
1270 |
type = element.getAttribute( "type" ),
|
|
|
1271 |
method, value;
|
|
|
1272 |
|
|
|
1273 |
for ( method in $.validator.methods ) {
|
|
|
1274 |
value = $element.data( "rule" + method.charAt( 0 ).toUpperCase() + method.substring( 1 ).toLowerCase() );
|
|
|
1275 |
|
|
|
1276 |
// Cast empty attributes like `data-rule-required` to `true`
|
|
|
1277 |
if ( value === "" ) {
|
|
|
1278 |
value = true;
|
|
|
1279 |
}
|
|
|
1280 |
|
|
|
1281 |
this.normalizeAttributeRule( rules, type, method, value );
|
|
|
1282 |
}
|
|
|
1283 |
return rules;
|
|
|
1284 |
},
|
|
|
1285 |
|
|
|
1286 |
staticRules: function( element ) {
|
|
|
1287 |
var rules = {},
|
|
|
1288 |
validator = $.data( element.form, "validator" );
|
|
|
1289 |
|
|
|
1290 |
if ( validator.settings.rules ) {
|
|
|
1291 |
rules = $.validator.normalizeRule( validator.settings.rules[ element.name ] ) || {};
|
|
|
1292 |
}
|
|
|
1293 |
return rules;
|
|
|
1294 |
},
|
|
|
1295 |
|
|
|
1296 |
normalizeRules: function( rules, element ) {
|
|
|
1297 |
|
|
|
1298 |
// Handle dependency check
|
|
|
1299 |
$.each( rules, function( prop, val ) {
|
|
|
1300 |
|
|
|
1301 |
// Ignore rule when param is explicitly false, eg. required:false
|
|
|
1302 |
if ( val === false ) {
|
|
|
1303 |
delete rules[ prop ];
|
|
|
1304 |
return;
|
|
|
1305 |
}
|
|
|
1306 |
if ( val.param || val.depends ) {
|
|
|
1307 |
var keepRule = true;
|
|
|
1308 |
switch ( typeof val.depends ) {
|
|
|
1309 |
case "string":
|
|
|
1310 |
keepRule = !!$( val.depends, element.form ).length;
|
|
|
1311 |
break;
|
|
|
1312 |
case "function":
|
|
|
1313 |
keepRule = val.depends.call( element, element );
|
|
|
1314 |
break;
|
|
|
1315 |
}
|
|
|
1316 |
if ( keepRule ) {
|
|
|
1317 |
rules[ prop ] = val.param !== undefined ? val.param : true;
|
|
|
1318 |
} else {
|
|
|
1319 |
$.data( element.form, "validator" ).resetElements( $( element ) );
|
|
|
1320 |
delete rules[ prop ];
|
|
|
1321 |
}
|
|
|
1322 |
}
|
|
|
1323 |
} );
|
|
|
1324 |
|
|
|
1325 |
// Evaluate parameters
|
|
|
1326 |
$.each( rules, function( rule, parameter ) {
|
|
|
1327 |
rules[ rule ] = $.isFunction( parameter ) && rule !== "normalizer" ? parameter( element ) : parameter;
|
|
|
1328 |
} );
|
|
|
1329 |
|
|
|
1330 |
// Clean number parameters
|
|
|
1331 |
$.each( [ "minlength", "maxlength" ], function() {
|
|
|
1332 |
if ( rules[ this ] ) {
|
|
|
1333 |
rules[ this ] = Number( rules[ this ] );
|
|
|
1334 |
}
|
|
|
1335 |
} );
|
|
|
1336 |
$.each( [ "rangelength", "range" ], function() {
|
|
|
1337 |
var parts;
|
|
|
1338 |
if ( rules[ this ] ) {
|
|
|
1339 |
if ( $.isArray( rules[ this ] ) ) {
|
|
|
1340 |
rules[ this ] = [ Number( rules[ this ][ 0 ] ), Number( rules[ this ][ 1 ] ) ];
|
|
|
1341 |
} else if ( typeof rules[ this ] === "string" ) {
|
|
|
1342 |
parts = rules[ this ].replace( /[\[\]]/g, "" ).split( /[\s,]+/ );
|
|
|
1343 |
rules[ this ] = [ Number( parts[ 0 ] ), Number( parts[ 1 ] ) ];
|
|
|
1344 |
}
|
|
|
1345 |
}
|
|
|
1346 |
} );
|
|
|
1347 |
|
|
|
1348 |
if ( $.validator.autoCreateRanges ) {
|
|
|
1349 |
|
|
|
1350 |
// Auto-create ranges
|
|
|
1351 |
if ( rules.min != null && rules.max != null ) {
|
|
|
1352 |
rules.range = [ rules.min, rules.max ];
|
|
|
1353 |
delete rules.min;
|
|
|
1354 |
delete rules.max;
|
|
|
1355 |
}
|
|
|
1356 |
if ( rules.minlength != null && rules.maxlength != null ) {
|
|
|
1357 |
rules.rangelength = [ rules.minlength, rules.maxlength ];
|
|
|
1358 |
delete rules.minlength;
|
|
|
1359 |
delete rules.maxlength;
|
|
|
1360 |
}
|
|
|
1361 |
}
|
|
|
1362 |
|
|
|
1363 |
return rules;
|
|
|
1364 |
},
|
|
|
1365 |
|
|
|
1366 |
// Converts a simple string to a {string: true} rule, e.g., "required" to {required:true}
|
|
|
1367 |
normalizeRule: function( data ) {
|
|
|
1368 |
if ( typeof data === "string" ) {
|
|
|
1369 |
var transformed = {};
|
|
|
1370 |
$.each( data.split( /\s/ ), function() {
|
|
|
1371 |
transformed[ this ] = true;
|
|
|
1372 |
} );
|
|
|
1373 |
data = transformed;
|
|
|
1374 |
}
|
|
|
1375 |
return data;
|
|
|
1376 |
},
|
|
|
1377 |
|
|
|
1378 |
// https://jqueryvalidation.org/jQuery.validator.addMethod/
|
|
|
1379 |
addMethod: function( name, method, message ) {
|
|
|
1380 |
$.validator.methods[ name ] = method;
|
|
|
1381 |
$.validator.messages[ name ] = message !== undefined ? message : $.validator.messages[ name ];
|
|
|
1382 |
if ( method.length < 3 ) {
|
|
|
1383 |
$.validator.addClassRules( name, $.validator.normalizeRule( name ) );
|
|
|
1384 |
}
|
|
|
1385 |
},
|
|
|
1386 |
|
|
|
1387 |
// https://jqueryvalidation.org/jQuery.validator.methods/
|
|
|
1388 |
methods: {
|
|
|
1389 |
|
|
|
1390 |
// https://jqueryvalidation.org/required-method/
|
|
|
1391 |
required: function( value, element, param ) {
|
|
|
1392 |
|
|
|
1393 |
// Check if dependency is met
|
|
|
1394 |
if ( !this.depend( param, element ) ) {
|
|
|
1395 |
return "dependency-mismatch";
|
|
|
1396 |
}
|
|
|
1397 |
if ( element.nodeName.toLowerCase() === "select" ) {
|
|
|
1398 |
|
|
|
1399 |
// Could be an array for select-multiple or a string, both are fine this way
|
|
|
1400 |
var val = $( element ).val();
|
|
|
1401 |
return val && val.length > 0;
|
|
|
1402 |
}
|
|
|
1403 |
if ( this.checkable( element ) ) {
|
|
|
1404 |
return this.getLength( value, element ) > 0;
|
|
|
1405 |
}
|
|
|
1406 |
return value !== undefined && value !== null && value.length > 0;
|
|
|
1407 |
},
|
|
|
1408 |
|
|
|
1409 |
// https://jqueryvalidation.org/email-method/
|
|
|
1410 |
email: function( value, element ) {
|
|
|
1411 |
|
|
|
1412 |
// From https://html.spec.whatwg.org/multipage/forms.html#valid-e-mail-address
|
|
|
1413 |
// Retrieved 2014-01-14
|
|
|
1414 |
// If you have a problem with this implementation, report a bug against the above spec
|
|
|
1415 |
// Or use custom methods to implement your own email validation
|
|
|
1416 |
return this.optional( element ) || /^[a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.test( value );
|
|
|
1417 |
},
|
|
|
1418 |
|
|
|
1419 |
// https://jqueryvalidation.org/url-method/
|
|
|
1420 |
url: function( value, element ) {
|
|
|
1421 |
|
|
|
1422 |
// Copyright (c) 2010-2013 Diego Perini, MIT licensed
|
|
|
1423 |
// https://gist.github.com/dperini/729294
|
|
|
1424 |
// see also https://mathiasbynens.be/demo/url-regex
|
|
|
1425 |
// modified to allow protocol-relative URLs
|
|
|
1426 |
return this.optional( element ) || /^(?:(?:(?:https?|ftp):)?\/\/)(?:\S+(?::\S*)?@)?(?:(?!(?:10|127)(?:\.\d{1,3}){3})(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)(?:\.(?:[a-z\u00a1-\uffff0-9]-*)*[a-z\u00a1-\uffff0-9]+)*(?:\.(?:[a-z\u00a1-\uffff]{2,})).?)(?::\d{2,5})?(?:[/?#]\S*)?$/i.test( value );
|
|
|
1427 |
},
|
|
|
1428 |
|
|
|
1429 |
// https://jqueryvalidation.org/date-method/
|
|
|
1430 |
date: ( function() {
|
|
|
1431 |
var called = false;
|
|
|
1432 |
|
|
|
1433 |
return function( value, element ) {
|
|
|
1434 |
if ( !called ) {
|
|
|
1435 |
called = true;
|
|
|
1436 |
if ( this.settings.debug && window.console ) {
|
|
|
1437 |
console.warn(
|
|
|
1438 |
"The `date` method is deprecated and will be removed in version '2.0.0'.\n" +
|
|
|
1439 |
"Please don't use it, since it relies on the Date constructor, which\n" +
|
|
|
1440 |
"behaves very differently across browsers and locales. Use `dateISO`\n" +
|
|
|
1441 |
"instead or one of the locale specific methods in `localizations/`\n" +
|
|
|
1442 |
"and `additional-methods.js`."
|
|
|
1443 |
);
|
|
|
1444 |
}
|
|
|
1445 |
}
|
|
|
1446 |
|
|
|
1447 |
return this.optional( element ) || !/Invalid|NaN/.test( new Date( value ).toString() );
|
|
|
1448 |
};
|
|
|
1449 |
}() ),
|
|
|
1450 |
|
|
|
1451 |
// https://jqueryvalidation.org/dateISO-method/
|
|
|
1452 |
dateISO: function( value, element ) {
|
|
|
1453 |
return this.optional( element ) || /^\d{4}[\/\-](0?[1-9]|1[012])[\/\-](0?[1-9]|[12][0-9]|3[01])$/.test( value );
|
|
|
1454 |
},
|
|
|
1455 |
|
|
|
1456 |
// https://jqueryvalidation.org/number-method/
|
|
|
1457 |
number: function( value, element ) {
|
|
|
1458 |
return this.optional( element ) || /^(?:-?\d+|-?\d{1,3}(?:,\d{3})+)?(?:\.\d+)?$/.test( value );
|
|
|
1459 |
},
|
|
|
1460 |
|
|
|
1461 |
// https://jqueryvalidation.org/digits-method/
|
|
|
1462 |
digits: function( value, element ) {
|
|
|
1463 |
return this.optional( element ) || /^\d+$/.test( value );
|
|
|
1464 |
},
|
|
|
1465 |
|
|
|
1466 |
// https://jqueryvalidation.org/minlength-method/
|
|
|
1467 |
minlength: function( value, element, param ) {
|
|
|
1468 |
var length = $.isArray( value ) ? value.length : this.getLength( value, element );
|
|
|
1469 |
return this.optional( element ) || length >= param;
|
|
|
1470 |
},
|
|
|
1471 |
|
|
|
1472 |
// https://jqueryvalidation.org/maxlength-method/
|
|
|
1473 |
maxlength: function( value, element, param ) {
|
|
|
1474 |
var length = $.isArray( value ) ? value.length : this.getLength( value, element );
|
|
|
1475 |
return this.optional( element ) || length <= param;
|
|
|
1476 |
},
|
|
|
1477 |
|
|
|
1478 |
// https://jqueryvalidation.org/rangelength-method/
|
|
|
1479 |
rangelength: function( value, element, param ) {
|
|
|
1480 |
var length = $.isArray( value ) ? value.length : this.getLength( value, element );
|
|
|
1481 |
return this.optional( element ) || ( length >= param[ 0 ] && length <= param[ 1 ] );
|
|
|
1482 |
},
|
|
|
1483 |
|
|
|
1484 |
// https://jqueryvalidation.org/min-method/
|
|
|
1485 |
min: function( value, element, param ) {
|
|
|
1486 |
return this.optional( element ) || value >= param;
|
|
|
1487 |
},
|
|
|
1488 |
|
|
|
1489 |
// https://jqueryvalidation.org/max-method/
|
|
|
1490 |
max: function( value, element, param ) {
|
|
|
1491 |
return this.optional( element ) || value <= param;
|
|
|
1492 |
},
|
|
|
1493 |
|
|
|
1494 |
// https://jqueryvalidation.org/range-method/
|
|
|
1495 |
range: function( value, element, param ) {
|
|
|
1496 |
return this.optional( element ) || ( value >= param[ 0 ] && value <= param[ 1 ] );
|
|
|
1497 |
},
|
|
|
1498 |
|
|
|
1499 |
// https://jqueryvalidation.org/step-method/
|
|
|
1500 |
step: function( value, element, param ) {
|
|
|
1501 |
var type = $( element ).attr( "type" ),
|
|
|
1502 |
errorMessage = "Step attribute on input type " + type + " is not supported.",
|
|
|
1503 |
supportedTypes = [ "text", "number", "range" ],
|
|
|
1504 |
re = new RegExp( "\\b" + type + "\\b" ),
|
|
|
1505 |
notSupported = type && !re.test( supportedTypes.join() ),
|
|
|
1506 |
decimalPlaces = function( num ) {
|
|
|
1507 |
var match = ( "" + num ).match( /(?:\.(\d+))?$/ );
|
|
|
1508 |
if ( !match ) {
|
|
|
1509 |
return 0;
|
|
|
1510 |
}
|
|
|
1511 |
|
|
|
1512 |
// Number of digits right of decimal point.
|
|
|
1513 |
return match[ 1 ] ? match[ 1 ].length : 0;
|
|
|
1514 |
},
|
|
|
1515 |
toInt = function( num ) {
|
|
|
1516 |
return Math.round( num * Math.pow( 10, decimals ) );
|
|
|
1517 |
},
|
|
|
1518 |
valid = true,
|
|
|
1519 |
decimals;
|
|
|
1520 |
|
|
|
1521 |
// Works only for text, number and range input types
|
|
|
1522 |
// TODO find a way to support input types date, datetime, datetime-local, month, time and week
|
|
|
1523 |
if ( notSupported ) {
|
|
|
1524 |
throw new Error( errorMessage );
|
|
|
1525 |
}
|
|
|
1526 |
|
|
|
1527 |
decimals = decimalPlaces( param );
|
|
|
1528 |
|
|
|
1529 |
// Value can't have too many decimals
|
|
|
1530 |
if ( decimalPlaces( value ) > decimals || toInt( value ) % toInt( param ) !== 0 ) {
|
|
|
1531 |
valid = false;
|
|
|
1532 |
}
|
|
|
1533 |
|
|
|
1534 |
return this.optional( element ) || valid;
|
|
|
1535 |
},
|
|
|
1536 |
|
|
|
1537 |
// https://jqueryvalidation.org/equalTo-method/
|
|
|
1538 |
equalTo: function( value, element, param ) {
|
|
|
1539 |
|
|
|
1540 |
// Bind to the blur event of the target in order to revalidate whenever the target field is updated
|
|
|
1541 |
var target = $( param );
|
|
|
1542 |
if ( this.settings.onfocusout && target.not( ".validate-equalTo-blur" ).length ) {
|
|
|
1543 |
target.addClass( "validate-equalTo-blur" ).on( "blur.validate-equalTo", function() {
|
|
|
1544 |
$( element ).valid();
|
|
|
1545 |
} );
|
|
|
1546 |
}
|
|
|
1547 |
return value === target.val();
|
|
|
1548 |
},
|
|
|
1549 |
|
|
|
1550 |
// https://jqueryvalidation.org/remote-method/
|
|
|
1551 |
remote: function( value, element, param, method ) {
|
|
|
1552 |
if ( this.optional( element ) ) {
|
|
|
1553 |
return "dependency-mismatch";
|
|
|
1554 |
}
|
|
|
1555 |
|
|
|
1556 |
method = typeof method === "string" && method || "remote";
|
|
|
1557 |
|
|
|
1558 |
var previous = this.previousValue( element, method ),
|
|
|
1559 |
validator, data, optionDataString;
|
|
|
1560 |
|
|
|
1561 |
if ( !this.settings.messages[ element.name ] ) {
|
|
|
1562 |
this.settings.messages[ element.name ] = {};
|
|
|
1563 |
}
|
|
|
1564 |
previous.originalMessage = previous.originalMessage || this.settings.messages[ element.name ][ method ];
|
|
|
1565 |
this.settings.messages[ element.name ][ method ] = previous.message;
|
|
|
1566 |
|
|
|
1567 |
param = typeof param === "string" && { url: param } || param;
|
|
|
1568 |
optionDataString = $.param( $.extend( { data: value }, param.data ) );
|
|
|
1569 |
if ( previous.old === optionDataString ) {
|
|
|
1570 |
return previous.valid;
|
|
|
1571 |
}
|
|
|
1572 |
|
|
|
1573 |
previous.old = optionDataString;
|
|
|
1574 |
validator = this;
|
|
|
1575 |
this.startRequest( element );
|
|
|
1576 |
data = {};
|
|
|
1577 |
data[ element.name ] = value;
|
|
|
1578 |
$.ajax( $.extend( true, {
|
|
|
1579 |
mode: "abort",
|
|
|
1580 |
port: "validate" + element.name,
|
|
|
1581 |
dataType: "json",
|
|
|
1582 |
data: data,
|
|
|
1583 |
context: validator.currentForm,
|
|
|
1584 |
success: function( response ) {
|
|
|
1585 |
var valid = response === true || response === "true",
|
|
|
1586 |
errors, message, submitted;
|
|
|
1587 |
|
|
|
1588 |
validator.settings.messages[ element.name ][ method ] = previous.originalMessage;
|
|
|
1589 |
if ( valid ) {
|
|
|
1590 |
submitted = validator.formSubmitted;
|
|
|
1591 |
validator.resetInternals();
|
|
|
1592 |
validator.toHide = validator.errorsFor( element );
|
|
|
1593 |
validator.formSubmitted = submitted;
|
|
|
1594 |
validator.successList.push( element );
|
|
|
1595 |
validator.invalid[ element.name ] = false;
|
|
|
1596 |
validator.showErrors();
|
|
|
1597 |
} else {
|
|
|
1598 |
errors = {};
|
|
|
1599 |
message = response || validator.defaultMessage( element, { method: method, parameters: value } );
|
|
|
1600 |
errors[ element.name ] = previous.message = message;
|
|
|
1601 |
validator.invalid[ element.name ] = true;
|
|
|
1602 |
validator.showErrors( errors );
|
|
|
1603 |
}
|
|
|
1604 |
previous.valid = valid;
|
|
|
1605 |
validator.stopRequest( element, valid );
|
|
|
1606 |
}
|
|
|
1607 |
}, param ) );
|
|
|
1608 |
return "pending";
|
|
|
1609 |
}
|
|
|
1610 |
}
|
|
|
1611 |
|
|
|
1612 |
} );
|
|
|
1613 |
|
|
|
1614 |
// Ajax mode: abort
|
|
|
1615 |
// usage: $.ajax({ mode: "abort"[, port: "uniqueport"]});
|
|
|
1616 |
// if mode:"abort" is used, the previous request on that port (port can be undefined) is aborted via XMLHttpRequest.abort()
|
|
|
1617 |
|
|
|
1618 |
var pendingRequests = {},
|
|
|
1619 |
ajax;
|
|
|
1620 |
|
|
|
1621 |
// Use a prefilter if available (1.5+)
|
|
|
1622 |
if ( $.ajaxPrefilter ) {
|
|
|
1623 |
$.ajaxPrefilter( function( settings, _, xhr ) {
|
|
|
1624 |
var port = settings.port;
|
|
|
1625 |
if ( settings.mode === "abort" ) {
|
|
|
1626 |
if ( pendingRequests[ port ] ) {
|
|
|
1627 |
pendingRequests[ port ].abort();
|
|
|
1628 |
}
|
|
|
1629 |
pendingRequests[ port ] = xhr;
|
|
|
1630 |
}
|
|
|
1631 |
} );
|
|
|
1632 |
} else {
|
|
|
1633 |
|
|
|
1634 |
// Proxy ajax
|
|
|
1635 |
ajax = $.ajax;
|
|
|
1636 |
$.ajax = function( settings ) {
|
|
|
1637 |
var mode = ( "mode" in settings ? settings : $.ajaxSettings ).mode,
|
|
|
1638 |
port = ( "port" in settings ? settings : $.ajaxSettings ).port;
|
|
|
1639 |
if ( mode === "abort" ) {
|
|
|
1640 |
if ( pendingRequests[ port ] ) {
|
|
|
1641 |
pendingRequests[ port ].abort();
|
|
|
1642 |
}
|
|
|
1643 |
pendingRequests[ port ] = ajax.apply( this, arguments );
|
|
|
1644 |
return pendingRequests[ port ];
|
|
|
1645 |
}
|
|
|
1646 |
return ajax.apply( this, arguments );
|
|
|
1647 |
};
|
|
|
1648 |
}
|
|
|
1649 |
return $;
|
|
|
1650 |
}));
|