david
e93adbdd4e
- Registro, activación y entrada de usuarios git-svn-id: https://192.168.0.254/svn/Rodax.factuges_web/trunk@2 e455b18d-f7fe-5245-9c43-e2c35af70a32
2058 lines
106 KiB
JavaScript
2058 lines
106 KiB
JavaScript
/**
|
|
* @license Input Mask plugin for jquery
|
|
* http://github.com/RobinHerbots/jquery.inputmask
|
|
* Copyright (c) 2010 - 2013 Robin Herbots
|
|
* Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
|
|
* Version: 2.2.2
|
|
*/
|
|
|
|
(function ($) {
|
|
if ($.fn.inputmask == undefined) {
|
|
$.inputmask = {
|
|
//options default
|
|
defaults: {
|
|
placeholder: "_",
|
|
optionalmarker: {
|
|
start: "[",
|
|
end: "]"
|
|
},
|
|
escapeChar: "\\",
|
|
mask: null,
|
|
oncomplete: $.noop, //executes when the mask is complete
|
|
onincomplete: $.noop, //executes when the mask is incomplete and focus is lost
|
|
oncleared: $.noop, //executes when the mask is cleared
|
|
repeat: 0, //repetitions of the mask
|
|
greedy: true, //true: allocated buffer for the mask and repetitions - false: allocate only if needed
|
|
autoUnmask: false, //automatically unmask when retrieving the value with $.fn.val or value if the browser supports __lookupGetter__ or getOwnPropertyDescriptor
|
|
clearMaskOnLostFocus: true,
|
|
insertMode: true, //insert the input or overwrite the input
|
|
clearIncomplete: false, //clear the incomplete input on blur
|
|
aliases: {}, //aliases definitions => see jquery.inputmask.extensions.js
|
|
onKeyUp: $.noop, //override to implement autocomplete on certain keys for example
|
|
onKeyDown: $.noop, //override to implement autocomplete on certain keys for example
|
|
showMaskOnFocus: true, //show the mask-placeholder when the input has focus
|
|
showMaskOnHover: true, //show the mask-placeholder when hovering the empty input
|
|
onKeyValidation: $.noop, //executes on every key-press with the result of isValid
|
|
skipOptionalPartCharacter: " ", //a character which can be used to skip an optional part of a mask
|
|
//numeric basic properties
|
|
numericInput: false, //numericInput input direction style (input shifts to the left while holding the caret position)
|
|
radixPoint: "", //".", // | ","
|
|
rightAlignNumerics: true, //align numerics to the right
|
|
//numeric basic properties
|
|
definitions: {
|
|
'9': {
|
|
validator: "[0-9]",
|
|
cardinality: 1
|
|
},
|
|
'a': {
|
|
validator: "[A-Za-z\u0410-\u044F\u0401\u0451]",
|
|
cardinality: 1
|
|
},
|
|
'*': {
|
|
validator: "[A-Za-z\u0410-\u044F\u0401\u04510-9]",
|
|
cardinality: 1
|
|
}
|
|
},
|
|
keyCode: {
|
|
ALT: 18, BACKSPACE: 8, CAPS_LOCK: 20, COMMA: 188, COMMAND: 91, COMMAND_LEFT: 91, COMMAND_RIGHT: 93, CONTROL: 17, DELETE: 46, DOWN: 40, END: 35, ENTER: 13, ESCAPE: 27, HOME: 36, INSERT: 45, LEFT: 37, MENU: 93, NUMPAD_ADD: 107, NUMPAD_DECIMAL: 110, NUMPAD_DIVIDE: 111, NUMPAD_ENTER: 108,
|
|
NUMPAD_MULTIPLY: 106, NUMPAD_SUBTRACT: 109, PAGE_DOWN: 34, PAGE_UP: 33, PERIOD: 190, RIGHT: 39, SHIFT: 16, SPACE: 32, TAB: 9, UP: 38, WINDOWS: 91
|
|
},
|
|
//specify keycodes which should not be considered in the keypress event, otherwise the preventDefault will stop their default behavior especially in FF
|
|
ignorables: [9, 13, 19, 27, 33, 34, 35, 36, 37, 38, 39, 40, 45, 46, 93, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123],
|
|
getMaskLength: function (buffer, greedy, repeat, currentBuffer, opts) {
|
|
var calculatedLength = buffer.length;
|
|
if (!greedy && repeat > 1) {
|
|
calculatedLength += (buffer.length * (repeat - 1));
|
|
}
|
|
return calculatedLength;
|
|
}
|
|
},
|
|
val: $.fn.val, //store the original jquery val function
|
|
escapeRegex: function (str) {
|
|
var specials = ['/', '.', '*', '+', '?', '|', '(', ')', '[', ']', '{', '}', '\\'];
|
|
return str.replace(new RegExp('(\\' + specials.join('|\\') + ')', 'gim'), '\\$1');
|
|
}
|
|
};
|
|
|
|
$.fn.inputmask = function (fn, options) {
|
|
var opts = $.extend(true, {}, $.inputmask.defaults, options);
|
|
var pasteEvent = isInputEventSupported('paste') ? 'paste' : 'input';
|
|
|
|
var iphone = navigator.userAgent.match(/iphone/i) != null;
|
|
var android = navigator.userAgent.match(/android.*safari.*/i) != null,
|
|
android533;
|
|
if (android) {
|
|
var browser = navigator.userAgent.match(/safari.*/i);
|
|
var version = parseInt(new RegExp(/[0-9]+/).exec(browser));
|
|
android533 = (version <= 533);
|
|
//android534 = (533 < version) && (version <= 534);
|
|
}
|
|
|
|
var masksets,
|
|
activeMasksetIndex = 0;
|
|
if (typeof fn == "string") {
|
|
switch (fn) {
|
|
case "mask":
|
|
//resolve possible aliases given by options
|
|
resolveAlias(opts.alias, options);
|
|
masksets = generateMaskSets();
|
|
|
|
return this.each(function () {
|
|
mask(this);
|
|
});
|
|
break;
|
|
case "unmaskedvalue":
|
|
masksets = this.data('inputmask')['masksets'];
|
|
activeMasksetIndex = this.data('inputmask')['activeMasksetIndex'];
|
|
opts.definitions = this.data('inputmask')['definitions'];
|
|
return unmaskedvalue(this);
|
|
break;
|
|
case "remove":
|
|
return this.each(function () {
|
|
var $input = $(this), input = this;
|
|
setTimeout(function () {
|
|
if ($input.data('inputmask')) {
|
|
masksets = $input.data('inputmask')['masksets'];
|
|
activeMasksetIndex = $input.data('inputmask')['activeMasksetIndex'];
|
|
opts.definitions = $input.data('inputmask')['definitions'];
|
|
//writeout the unmaskedvalue
|
|
input._valueSet(unmaskedvalue($input, true));
|
|
//clear data
|
|
$input.removeData('inputmask');
|
|
//unbind all events
|
|
$input.unbind(".inputmask");
|
|
$input.removeClass('focus.inputmask');
|
|
//restore the value property
|
|
var valueProperty;
|
|
if (Object.getOwnPropertyDescriptor)
|
|
valueProperty = Object.getOwnPropertyDescriptor(input, "value");
|
|
if (valueProperty && valueProperty.get) {
|
|
if (input._valueGet) {
|
|
Object.defineProperty(input, "value", {
|
|
get: input._valueGet,
|
|
set: input._valueSet
|
|
});
|
|
}
|
|
} else if (document.__lookupGetter__ && input.__lookupGetter__("value")) {
|
|
if (input._valueGet) {
|
|
input.__defineGetter__("value", input._valueGet);
|
|
input.__defineSetter__("value", input._valueSet);
|
|
}
|
|
}
|
|
delete input._valueGet;
|
|
delete input._valueSet;
|
|
}
|
|
}, 0);
|
|
});
|
|
break;
|
|
case "getemptymask": //return the default (empty) mask value, usefull for setting the default value in validation
|
|
if (this.data('inputmask')) {
|
|
masksets = this.data('inputmask')['masksets'];
|
|
activeMasksetIndex = this.data('inputmask')['activeMasksetIndex'];
|
|
return masksets[activeMasksetIndex]['_buffer'].join('');
|
|
}
|
|
else return "";
|
|
case "hasMaskedValue": //check wheter the returned value is masked or not; currently only works reliable when using jquery.val fn to retrieve the value
|
|
return this.data('inputmask') ? !this.data('inputmask')['autoUnmask'] : false;
|
|
case "isComplete":
|
|
masksets = this.data('inputmask')['masksets'];
|
|
activeMasksetIndex = this.data('inputmask')['activeMasksetIndex'];
|
|
opts.definitions = this.data('inputmask')['definitions'];
|
|
return isComplete(this[0].split(''));
|
|
default:
|
|
//check if the fn is an alias
|
|
if (!resolveAlias(fn, options)) {
|
|
//maybe fn is a mask so we try
|
|
//set mask
|
|
opts.mask = fn;
|
|
}
|
|
masksets = generateMaskSets();
|
|
|
|
return this.each(function () {
|
|
mask(this);
|
|
});
|
|
|
|
break;
|
|
}
|
|
} else if (typeof fn == "object") {
|
|
opts = $.extend(true, {}, $.inputmask.defaults, fn);
|
|
|
|
resolveAlias(opts.alias, fn); //resolve aliases
|
|
masksets = generateMaskSets();
|
|
|
|
return this.each(function () {
|
|
mask(this);
|
|
});
|
|
} else if (fn == undefined) {
|
|
//look for data-inputmask atribute - the attribute should only contain optipns
|
|
return this.each(function () {
|
|
var attrOptions = $(this).attr("data-inputmask");
|
|
if (attrOptions && attrOptions != "") {
|
|
try {
|
|
attrOptions = attrOptions.replace(new RegExp("'", "g"), '"');
|
|
var options = $.parseJSON("{" + attrOptions + "}");
|
|
opts = $.extend(true, {}, $.inputmask.defaults, options);
|
|
resolveAlias(opts.alias, options);
|
|
opts.alias = undefined;
|
|
$(this).inputmask(opts);
|
|
} catch (ex) { } //need a more relax parseJSON
|
|
}
|
|
});
|
|
}
|
|
|
|
//helper functions
|
|
function isInputEventSupported(eventName) {
|
|
var el = document.createElement('input'),
|
|
eventName = 'on' + eventName,
|
|
isSupported = (eventName in el);
|
|
if (!isSupported) {
|
|
el.setAttribute(eventName, 'return;');
|
|
isSupported = typeof el[eventName] == 'function';
|
|
}
|
|
el = null;
|
|
return isSupported;
|
|
}
|
|
|
|
function resolveAlias(aliasStr, options) {
|
|
var aliasDefinition = opts.aliases[aliasStr];
|
|
if (aliasDefinition) {
|
|
if (aliasDefinition.alias) resolveAlias(aliasDefinition.alias); //alias is another alias
|
|
$.extend(true, opts, aliasDefinition); //merge alias definition in the options
|
|
$.extend(true, opts, options); //reapply extra given options
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
function getMaskTemplate(mask) {
|
|
var escaped = false, outCount = 0, greedy = opts.greedy, repeat = opts.repeat;
|
|
if (mask.length == 1 && greedy == false) { opts.placeholder = ""; } //hide placeholder with single non-greedy mask
|
|
var singleMask = $.map(mask.split(""), function (element, index) {
|
|
var outElem = [];
|
|
if (element == opts.escapeChar) {
|
|
escaped = true;
|
|
}
|
|
else if ((element != opts.optionalmarker.start && element != opts.optionalmarker.end) || escaped) {
|
|
var maskdef = opts.definitions[element];
|
|
if (maskdef && !escaped) {
|
|
for (var i = 0; i < maskdef.cardinality; i++) {
|
|
outElem.push(getPlaceHolder(outCount + i));
|
|
}
|
|
} else {
|
|
outElem.push(element);
|
|
escaped = false;
|
|
}
|
|
outCount += outElem.length;
|
|
return outElem;
|
|
}
|
|
});
|
|
|
|
//allocate repetitions
|
|
var repeatedMask = singleMask.slice();
|
|
for (var i = 1; i < repeat && greedy; i++) {
|
|
repeatedMask = repeatedMask.concat(singleMask.slice());
|
|
}
|
|
|
|
return { "mask": repeatedMask, "repeat": repeat, "greedy": greedy };
|
|
}
|
|
|
|
//test definition => {fn: RegExp/function, cardinality: int, optionality: bool, newBlockMarker: bool, offset: int, casing: null/upper/lower, def: definitionSymbol}
|
|
function getTestingChain(mask) {
|
|
var isOptional = false, escaped = false;
|
|
var newBlockMarker = false; //indicates wheter the begin/ending of a block should be indicated
|
|
|
|
return $.map(mask.split(""), function (element, index) {
|
|
var outElem = [];
|
|
|
|
if (element == opts.escapeChar) {
|
|
escaped = true;
|
|
} else if (element == opts.optionalmarker.start && !escaped) {
|
|
isOptional = true;
|
|
newBlockMarker = true;
|
|
}
|
|
else if (element == opts.optionalmarker.end && !escaped) {
|
|
isOptional = false;
|
|
newBlockMarker = true;
|
|
}
|
|
else {
|
|
var maskdef = opts.definitions[element];
|
|
if (maskdef && !escaped) {
|
|
var prevalidators = maskdef["prevalidator"], prevalidatorsL = prevalidators ? prevalidators.length : 0;
|
|
for (var i = 1; i < maskdef.cardinality; i++) {
|
|
var prevalidator = prevalidatorsL >= i ? prevalidators[i - 1] : [], validator = prevalidator["validator"], cardinality = prevalidator["cardinality"];
|
|
outElem.push({ fn: validator ? typeof validator == 'string' ? new RegExp(validator) : new function () { this.test = validator; } : new RegExp("."), cardinality: cardinality ? cardinality : 1, optionality: isOptional, newBlockMarker: isOptional == true ? newBlockMarker : false, offset: 0, casing: maskdef["casing"], def: maskdef["definitionSymbol"] | element });
|
|
if (isOptional == true) //reset newBlockMarker
|
|
newBlockMarker = false;
|
|
}
|
|
outElem.push({ fn: maskdef.validator ? typeof maskdef.validator == 'string' ? new RegExp(maskdef.validator) : new function () { this.test = maskdef.validator; } : new RegExp("."), cardinality: maskdef.cardinality, optionality: isOptional, newBlockMarker: newBlockMarker, offset: 0, casing: maskdef["casing"], def: maskdef["definitionSymbol"] | element });
|
|
} else {
|
|
outElem.push({ fn: null, cardinality: 0, optionality: isOptional, newBlockMarker: newBlockMarker, offset: 0, casing: null, def: element });
|
|
escaped = false;
|
|
}
|
|
//reset newBlockMarker
|
|
newBlockMarker = false;
|
|
return outElem;
|
|
}
|
|
});
|
|
}
|
|
|
|
function generateMaskSets() {
|
|
var ms = [];
|
|
function markOptional(maskPart) { //needed for the clearOptionalTail functionality
|
|
return opts.optionalmarker.start + maskPart + opts.optionalmarker.end;
|
|
}
|
|
function splitFirstOptionalEndPart(maskPart) {
|
|
var optionalStartMarkers = 0, optionalEndMarkers = 0, mpl = maskPart.length;
|
|
for (i = 0; i < mpl; i++) {
|
|
if (maskPart.charAt(i) == opts.optionalmarker.start) {
|
|
optionalStartMarkers++;
|
|
}
|
|
if (maskPart.charAt(i) == opts.optionalmarker.end) {
|
|
optionalEndMarkers++;
|
|
}
|
|
if (optionalStartMarkers > 0 && optionalStartMarkers == optionalEndMarkers)
|
|
break;
|
|
}
|
|
var maskParts = [maskPart.substring(0, i)];
|
|
if (i < mpl) {
|
|
maskParts.push(maskPart.substring(i + 1, mpl));
|
|
}
|
|
return maskParts;
|
|
}
|
|
function splitFirstOptionalStartPart(maskPart) {
|
|
var mpl = maskPart.length;
|
|
for (i = 0; i < mpl; i++) {
|
|
if (maskPart.charAt(i) == opts.optionalmarker.start) {
|
|
break;
|
|
}
|
|
}
|
|
var maskParts = [maskPart.substring(0, i)];
|
|
if (i < mpl) {
|
|
maskParts.push(maskPart.substring(i + 1, mpl));
|
|
}
|
|
return maskParts;
|
|
}
|
|
function generateMask(maskPrefix, maskPart) {
|
|
var maskParts = splitFirstOptionalEndPart(maskPart);
|
|
var newMask, maskTemplate;
|
|
|
|
var masks = splitFirstOptionalStartPart(maskParts[0]);
|
|
if (masks.length > 1) {
|
|
newMask = maskPrefix + masks[0] + markOptional(masks[1]) + (maskParts.length > 1 ? maskParts[1] : "");
|
|
maskTemplate = getMaskTemplate(newMask);
|
|
ms.push({
|
|
"mask": newMask,
|
|
"_buffer": maskTemplate["mask"],
|
|
"tests": getTestingChain(newMask),
|
|
"lastValidPosition": undefined,
|
|
"greedy": maskTemplate["greedy"],
|
|
"repeat": maskTemplate["repeat"]
|
|
});
|
|
newMask = maskPrefix + masks[0] + (maskParts.length > 1 ? maskParts[1] : "");
|
|
maskTemplate = getMaskTemplate(newMask);
|
|
ms.push({
|
|
"mask": newMask,
|
|
"_buffer": maskTemplate["mask"],
|
|
"tests": getTestingChain(newMask),
|
|
"lastValidPosition": undefined,
|
|
"greedy": maskTemplate["greedy"],
|
|
"repeat": maskTemplate["repeat"]
|
|
});
|
|
if (maskParts.length > 1 && maskParts[1].split(opts.optionalmarker.start).length > 1) {
|
|
generateMask(maskPrefix + masks[0] + markOptional(masks[1]), maskParts[1]);
|
|
generateMask(maskPrefix + masks[0], maskParts[1]);
|
|
}
|
|
}
|
|
else {
|
|
newMask = maskPrefix + maskParts;
|
|
maskTemplate = getMaskTemplate(newMask);
|
|
ms.push({
|
|
"mask" : newMask,
|
|
"_buffer": maskTemplate["mask"],
|
|
"tests": getTestingChain(newMask),
|
|
"lastValidPosition": undefined,
|
|
"greedy": maskTemplate["greedy"],
|
|
"repeat": maskTemplate["repeat"]
|
|
});
|
|
}
|
|
|
|
}
|
|
if ($.isArray(opts.mask)) {
|
|
$.each(opts.mask, function (ndx, lmnt) {
|
|
generateMask("", lmnt.toString());
|
|
});
|
|
} else generateMask("", opts.mask.toString());
|
|
|
|
return ms;
|
|
}
|
|
|
|
//maskset helperfunctions
|
|
function getActiveMaskSet() {
|
|
return masksets[activeMasksetIndex];
|
|
}
|
|
|
|
function getActiveTests() {
|
|
return getActiveMaskSet()['tests'];
|
|
}
|
|
|
|
function getActiveBuffer() {
|
|
return getActiveMaskSet()['_buffer'];
|
|
}
|
|
|
|
function isValid(pos, c, buffer, strict, isRTL) { //strict true ~ no correction or autofill
|
|
function _isValid(position, activeMaskset) {
|
|
var testPos = determineTestPosition(position), loopend = c ? 1 : 0, chrs = '';
|
|
for (var i = activeMaskset['tests'][testPos].cardinality; i > loopend; i--) {
|
|
chrs += getBufferElement(buffer, testPos - (i - 1));
|
|
}
|
|
|
|
if (c) {
|
|
chrs += c;
|
|
}
|
|
|
|
//return is false or a json object => { pos: ??, c: ??} or true
|
|
return activeMaskset['tests'][testPos].fn != null ? activeMaskset['tests'][testPos].fn.test(chrs, buffer, position, strict, opts) : false;
|
|
}
|
|
|
|
if (strict) return _isValid(pos, getActiveMaskSet()); //only check validity in current mask when validating strict
|
|
|
|
var results = [], result = false, currentActiveMasksetIndex = activeMasksetIndex;
|
|
$.each(masksets, function (index, value) {
|
|
var activeMaskset = this;
|
|
activeMasksetIndex = index;
|
|
|
|
var maskPos = pos;
|
|
if (currentActiveMasksetIndex != activeMasksetIndex && !isMask(pos)) {
|
|
if (c == activeMaskset['_buffer'][maskPos] || c == opts.skipOptionalPartCharacter) { //match non-mask item
|
|
results[index] = { "refresh": true }; //new command hack only rewrite buffer
|
|
activeMaskset['lastValidPosition'] = maskPos;
|
|
return false;
|
|
}
|
|
|
|
maskPos = isRTL ? seekPrevious(buffer, pos) : seekNext(buffer, pos);
|
|
}
|
|
if (activeMaskset['lastValidPosition'] == undefined || (isRTL || opts.numericInput) ? activeMaskset['lastValidPosition'] <= opts.numericInput ? getMaskLength(buffer) : seekNext(buffer, maskPos) : activeMaskset['lastValidPosition'] >= seekPrevious(buffer, maskPos)) {
|
|
if (maskPos >= 0 && maskPos < getMaskLength(buffer)) {
|
|
results[index] = _isValid(maskPos, activeMaskset);
|
|
if (results[index] !== false) {
|
|
if (results[index] === true) {
|
|
results[index] = { "pos": maskPos }; //always take a possible corrected maskposition into account
|
|
}
|
|
activeMaskset['lastValidPosition'] = results[index].pos || maskPos; //set new position from isValid
|
|
} else activeMaskset['lastValidPosition'] = isRTL ? pos == getMaskLength(buffer) ? undefined : seekNext(buffer, pos) : pos == 0 ? undefined : seekPrevious(buffer, pos); //autocorrect validposition from backspace etc
|
|
}
|
|
}
|
|
});
|
|
activeMasksetIndex = currentActiveMasksetIndex; //reset activeMasksetIndex
|
|
determineActiveMasksetIndex(buffer, pos, currentActiveMasksetIndex, isRTL);
|
|
result = results[activeMasksetIndex] || result;
|
|
setTimeout(function () { opts.onKeyValidation.call(this, result, opts); }, 0); //extra stuff to execute on keydown
|
|
return result;
|
|
}
|
|
|
|
function determineActiveMasksetIndex(buffer, pos, currentActiveMasksetIndex, isRTL) {
|
|
$.each(masksets, function (index, value) {
|
|
var activeMaskset = this;
|
|
if (activeMaskset['lastValidPosition'] && (isRTL || opts.numericInput) ? activeMaskset['lastValidPosition'] <= pos : activeMaskset['lastValidPosition'] >= pos) {
|
|
activeMasksetIndex = index;
|
|
//reset to correct masktemplate
|
|
if (activeMasksetIndex != currentActiveMasksetIndex) {
|
|
var abl = getMaskLength(buffer), bufTemplate = getActiveBuffer();
|
|
if (isRTL || opts.numericInput) {
|
|
buffer.reverse();
|
|
bufTemplate.reverse();
|
|
}
|
|
buffer.length = pos; //clearout beyond the current
|
|
for (var i = pos; i < abl; i++) {
|
|
var testPos = determineTestPosition(i);
|
|
setBufferElement(buffer, i, getBufferElement(bufTemplate, testPos));
|
|
}
|
|
if (isRTL) {
|
|
buffer.reverse();
|
|
}
|
|
}
|
|
return false; //breaks
|
|
}
|
|
});
|
|
}
|
|
|
|
function isMask(pos) {
|
|
var testPos = determineTestPosition(pos);
|
|
var test = getActiveTests()[testPos];
|
|
|
|
return test != undefined ? test.fn : false;
|
|
}
|
|
|
|
function determineTestPosition(pos) {
|
|
return pos % getActiveTests().length;
|
|
}
|
|
|
|
function getPlaceHolder(pos) {
|
|
return opts.placeholder.charAt(pos % opts.placeholder.length);
|
|
}
|
|
|
|
function getMaskLength(currentBuffer) {
|
|
return opts.getMaskLength(getActiveBuffer(), getActiveMaskSet()['greedy'], getActiveMaskSet()['repeat'], currentBuffer, opts);
|
|
}
|
|
|
|
//pos: from position
|
|
function seekNext(buffer, pos) {
|
|
var maskL = getMaskLength(buffer);
|
|
if (pos >= maskL) return maskL;
|
|
var position = pos;
|
|
while (++position < maskL && !isMask(position)) { };
|
|
return position;
|
|
}
|
|
//pos: from position
|
|
function seekPrevious(buffer, pos) {
|
|
var position = pos;
|
|
if (position <= 0) return 0;
|
|
|
|
while (--position > 0 && !isMask(position)) { };
|
|
return position;
|
|
}
|
|
|
|
function setBufferElement(buffer, position, element) {
|
|
//position = prepareBuffer(buffer, position);
|
|
|
|
var test = getActiveTests()[determineTestPosition(position)];
|
|
var elem = element;
|
|
if (elem != undefined) {
|
|
switch (test.casing) {
|
|
case "upper":
|
|
elem = element.toUpperCase();
|
|
break;
|
|
case "lower":
|
|
elem = element.toLowerCase();
|
|
break;
|
|
}
|
|
}
|
|
|
|
buffer[position] = elem;
|
|
}
|
|
function getBufferElement(buffer, position, autoPrepare) {
|
|
if (autoPrepare) position = prepareBuffer(buffer, position);
|
|
return buffer[position];
|
|
}
|
|
|
|
//needed to handle the non-greedy mask repetitions
|
|
function prepareBuffer(buffer, position, isRTL) {
|
|
var j;
|
|
if (isRTL) {
|
|
while (position < 0 && buffer.length < getMaskLength(buffer)) {
|
|
j = getActiveBuffer().length - 1;
|
|
position = getActiveBuffer().length;
|
|
while (getActiveBuffer()[j] !== undefined) {
|
|
buffer.unshift(getActiveBuffer()[j--]);
|
|
}
|
|
}
|
|
} else {
|
|
while (buffer[position] == undefined && buffer.length < getMaskLength(buffer)) {
|
|
j = 0;
|
|
while (getActiveBuffer()[j] !== undefined) { //add a new buffer
|
|
buffer.push(getActiveBuffer()[j++]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return position;
|
|
}
|
|
|
|
function writeBuffer(input, buffer, caretPos) {
|
|
input._valueSet(buffer.join(''));
|
|
if (caretPos != undefined) {
|
|
caret(input, caretPos);
|
|
}
|
|
};
|
|
function clearBuffer(buffer, start, end) {
|
|
for (var i = start, maskL = getMaskLength(buffer) ; i < end && i < maskL; i++) {
|
|
setBufferElement(buffer, i, getBufferElement(getActiveBuffer().slice(), i));
|
|
}
|
|
};
|
|
|
|
function setReTargetPlaceHolder(buffer, pos) {
|
|
var testPos = determineTestPosition(pos);
|
|
setBufferElement(buffer, pos, getBufferElement(getActiveBuffer(), testPos));
|
|
}
|
|
|
|
function checkVal(input, buffer, clearInvalid, skipRadixHandling) {
|
|
var isRTL = $(input).data('inputmask')['isRTL'],
|
|
inputValue = truncateInput(input._valueGet(), isRTL).split('');
|
|
|
|
var maskL = getMaskLength(buffer);
|
|
if (isRTL) { //align inputValue for RTL/numeric input
|
|
var inputValueRev = inputValue.reverse(); inputValueRev.length = maskL;
|
|
|
|
for (var i = 0; i < maskL; i++) {
|
|
var targetPosition = determineTestPosition(maskL - (i + 1));
|
|
if (getActiveTests()[targetPosition].fn == null && inputValueRev[i] != getBufferElement(getActiveBuffer(), targetPosition)) {
|
|
inputValueRev.splice(i, 0, getBufferElement(getActiveBuffer(), targetPosition));
|
|
inputValueRev.length = maskL;
|
|
} else {
|
|
inputValueRev[i] = inputValueRev[i] || getBufferElement(getActiveBuffer(), targetPosition);
|
|
}
|
|
}
|
|
inputValue = inputValueRev.reverse();
|
|
}
|
|
clearBuffer(buffer, 0, buffer.length);
|
|
buffer.length = getActiveBuffer().length;
|
|
var lastMatch = -1, checkPosition = -1, np, ivl = inputValue.length, rtlMatch = ivl == 0 ? maskL : -1;
|
|
for (var i = 0; i < ivl; i++) {
|
|
for (var pos = checkPosition + 1; pos < maskL; pos++) {
|
|
if (isMask(pos)) {
|
|
var c = inputValue[i];
|
|
if ((np = isValid(pos, c, buffer, !clearInvalid, isRTL)) !== false) {
|
|
if (np !== true) {
|
|
pos = np.pos != undefined ? np.pos : pos; //set new position from isValid
|
|
c = np.c != undefined ? np.c : c; //set new char from isValid
|
|
}
|
|
setBufferElement(buffer, pos, c);
|
|
lastMatch = checkPosition = pos;
|
|
} else {
|
|
setReTargetPlaceHolder(buffer, pos);
|
|
if (c == getPlaceHolder(pos)) {
|
|
checkPosition = pos;
|
|
rtlMatch = pos;
|
|
}
|
|
}
|
|
break;
|
|
} else { //nonmask
|
|
setReTargetPlaceHolder(buffer, pos);
|
|
if (lastMatch == checkPosition) //once outsync the nonmask cannot be the lastmatch
|
|
lastMatch = pos;
|
|
checkPosition = pos;
|
|
if (inputValue[i] == getBufferElement(buffer, pos))
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//Truncate buffer when using non-greedy masks
|
|
if (getActiveMaskSet()['greedy'] == false) {
|
|
var newBuffer = truncateInput(buffer.join(''), isRTL).split(''), nbL = newBuffer.length;
|
|
for (var ndx = 0; ndx < nbL; ndx++) { //map changes into the original buffer
|
|
buffer[ndx] = newBuffer[ndx];
|
|
}
|
|
buffer.length = newBuffer.length;
|
|
}
|
|
|
|
if (clearInvalid) {
|
|
writeBuffer(input, buffer);
|
|
}
|
|
return isRTL ? (opts.numericInput ? (opts.radixPoint != "" && $.inArray(opts.radixPoint, buffer) != -1 && skipRadixHandling !== true ? $.inArray(opts.radixPoint, buffer) : seekNext(buffer, maskL)) : seekNext(buffer, rtlMatch)) : seekNext(buffer, lastMatch);
|
|
}
|
|
|
|
function escapeRegex(str) {
|
|
return $.inputmask.escapeRegex.call(this, str);
|
|
}
|
|
|
|
function truncateInput(inputValue, rtl) {
|
|
return rtl ? inputValue.replace(new RegExp("^(" + escapeRegex(getActiveBuffer().join('')) + ")*"), "") : inputValue.replace(new RegExp("(" + escapeRegex(getActiveBuffer().join('')) + ")*$"), "");
|
|
}
|
|
|
|
function clearOptionalTail(input, buffer) {
|
|
checkVal(input, buffer, false);
|
|
var tmpBuffer = buffer.slice(), testPos, pos;
|
|
if ($(input).data('inputmask')['isRTL']) {
|
|
for (var pos = 0; pos <= tmpBuffer.length - 1; pos++) {
|
|
var testPos = determineTestPosition(pos);
|
|
if (getActiveTests()[testPos].optionality) {
|
|
if (!isMask(pos) || !isValid(pos, buffer[pos], buffer, true))
|
|
tmpBuffer.splice(0, 1);
|
|
else break;
|
|
} else break;
|
|
}
|
|
} else {
|
|
for (var pos = tmpBuffer.length - 1; pos >= 0; pos--) {
|
|
var testPos = determineTestPosition(pos);
|
|
if (getActiveTests()[testPos].optionality) {
|
|
if (!isMask(pos) || !isValid(pos, buffer[pos], buffer, true))
|
|
tmpBuffer.pop();
|
|
else break;
|
|
} else break;
|
|
}
|
|
}
|
|
writeBuffer(input, tmpBuffer);
|
|
}
|
|
|
|
//functionality fn
|
|
function unmaskedvalue($input, skipDatepickerCheck) {
|
|
var input = $input[0];
|
|
if (getActiveTests() && (skipDatepickerCheck === true || !$input.hasClass('hasDatepicker'))) {
|
|
var buffer = getActiveBuffer().slice();
|
|
checkVal(input, buffer);
|
|
return $.map(buffer, function (element, index) {
|
|
return isMask(index) && isValid(index, element, buffer, true) ? element : null;
|
|
}).join('');
|
|
}
|
|
else {
|
|
return input._valueGet();
|
|
}
|
|
}
|
|
|
|
var caretSavePoint;
|
|
function caret(input, begin, end) {
|
|
var npt = input.jquery && input.length > 0 ? input[0] : input, rabge;
|
|
if (typeof begin == 'number') {
|
|
if (!$(input).is(':visible')) {
|
|
return;
|
|
}
|
|
end = (typeof end == 'number') ? end : begin;
|
|
if (opts.insertMode == false && begin == end) end++; //set visualization for insert/overwrite mode
|
|
if (npt.setSelectionRange) {
|
|
if (android) {
|
|
setTimeout(function () {
|
|
npt.selectionStart = begin;
|
|
npt.selectionEnd = android ? begin : end;
|
|
}, 10);
|
|
caretSavePoint = { "begin": begin, "end": end };
|
|
}
|
|
else {
|
|
npt.selectionStart = begin;
|
|
npt.selectionEnd = end;
|
|
}
|
|
} else if (npt.createTextRange) {
|
|
range = npt.createTextRange();
|
|
range.collapse(true);
|
|
range.moveEnd('character', end);
|
|
range.moveStart('character', begin);
|
|
range.select();
|
|
}
|
|
} else {
|
|
if (!$(input).is(':visible')) {
|
|
return { "begin": 0, "end": 0 };
|
|
}
|
|
if (npt.setSelectionRange) {
|
|
begin = npt.selectionStart;
|
|
end = npt.selectionEnd;
|
|
} else if (document.selection && document.selection.createRange) {
|
|
range = document.selection.createRange();
|
|
begin = 0 - range.duplicate().moveStart('character', -100000);
|
|
end = begin + range.text.length;
|
|
}
|
|
return { "begin": begin, "end": end };
|
|
}
|
|
};
|
|
|
|
function isComplete(buffer) {
|
|
var complete = false, highestValidPosition = 0, currentActiveMasksetIndex = activeMasksetIndex;
|
|
$.each(masksets, function (ndx, ms) {
|
|
activeMasksetIndex = ndx;
|
|
var aml = getMaskLength(buffer);
|
|
if (ms["lastValidPosition"] && ms["lastValidPosition"] >= highestValidPosition && ms["lastValidPosition"] == (aml - 1)) {
|
|
var msComplete = true;
|
|
for (var i = 0; i < aml; i++) {
|
|
var mask = isMask(i);
|
|
if ((mask && buffer[i] == getPlaceHolder(i)) || (!mask && buffer[i] != getActiveBuffer()[i])) {
|
|
msComplete = false;
|
|
break;
|
|
}
|
|
}
|
|
complete = complete || msComplete;
|
|
if (complete) //break loop
|
|
return false;
|
|
}
|
|
highestValidPosition = ms["lastValidPosition"];
|
|
});
|
|
activeMasksetIndex = currentActiveMasksetIndex; //reset activeMaskset
|
|
return complete;
|
|
}
|
|
|
|
function mask(el) {
|
|
var $input = $(el);
|
|
if (!$input.is(":input")) return;
|
|
|
|
var buffer = getActiveBuffer().slice();
|
|
|
|
//correct greedy setting if needed
|
|
getActiveMaskSet()['greedy'] = getActiveMaskSet()['greedy'] ? getActiveMaskSet()['greedy'] : getActiveMaskSet()['repeat'] == 0;
|
|
|
|
//handle maxlength attribute
|
|
var maxLength = $input.prop('maxLength');
|
|
if (getMaskLength(buffer) > maxLength && maxLength > -1) { //FF sets no defined max length to -1
|
|
if (maxLength < getActiveBuffer().length) getActiveBuffer().length = maxLength;
|
|
if (getActiveMaskSet()['greedy'] == false) {
|
|
getActiveMaskSet()['repeat'] = Math.round(maxLength / getActiveBuffer().length);
|
|
}
|
|
$input.prop('maxLength', getMaskLength(buffer) * 2);
|
|
}
|
|
|
|
//store tests & original buffer in the input element - used to get the unmasked value
|
|
$input.data('inputmask', {
|
|
'masksets': masksets,
|
|
'activeMasksetIndex': activeMasksetIndex,
|
|
'autoUnmask': opts.autoUnmask,
|
|
'definitions': opts.definitions,
|
|
'isRTL': false
|
|
});
|
|
|
|
patchValueProperty(el);
|
|
|
|
//init vars
|
|
var buffer = getActiveBuffer().slice(),
|
|
undoBuffer = el._valueGet(),
|
|
|
|
skipKeyPressEvent = false, //Safari 5.1.x - modal dialog fires keypress twice workaround
|
|
ignorable = false,
|
|
lastPosition = -1,
|
|
firstMaskPos = seekNext(buffer, -1),
|
|
lastMaskPos = seekPrevious(buffer, getMaskLength(buffer)),
|
|
isRTL = false;
|
|
if (el.dir == "rtl" || opts.numericInput) {
|
|
if (el.dir == "rtl" || (opts.numericInput && opts.rightAlignNumerics))
|
|
$input.css("text-align", "right");
|
|
el.dir = "ltr";
|
|
$input.removeAttr("dir");
|
|
var inputData = $input.data('inputmask');
|
|
inputData['isRTL'] = true;
|
|
$input.data('inputmask', inputData);
|
|
isRTL = true;
|
|
}
|
|
|
|
//unbind all events - to make sure that no other mask will interfere when re-masking
|
|
$input.unbind(".inputmask");
|
|
$input.removeClass('focus.inputmask');
|
|
//bind events
|
|
$input.bind("mouseenter.inputmask", function () {
|
|
var $input = $(this), input = this;
|
|
if (!$input.hasClass('focus.inputmask') && opts.showMaskOnHover) {
|
|
var nptL = input._valueGet().length;
|
|
if (nptL < buffer.length) {
|
|
if (nptL == 0)
|
|
buffer = getActiveBuffer().slice();
|
|
writeBuffer(input, buffer);
|
|
}
|
|
}
|
|
}).bind("blur.inputmask", function () {
|
|
var $input = $(this), input = this, nptValue = input._valueGet();
|
|
$input.removeClass('focus.inputmask');
|
|
if (nptValue != undoBuffer) {
|
|
$input.change();
|
|
}
|
|
if (opts.clearMaskOnLostFocus && nptValue != '') {
|
|
if (nptValue == getActiveBuffer().join(''))
|
|
input._valueSet('');
|
|
else { //clearout optional tail of the mask
|
|
clearOptionalTail(input, buffer);
|
|
}
|
|
}
|
|
if (!isComplete(buffer)) {
|
|
$input.trigger("incomplete");
|
|
if (opts.clearIncomplete) {
|
|
if (opts.clearMaskOnLostFocus)
|
|
input._valueSet('');
|
|
else {
|
|
buffer = getActiveBuffer().slice();
|
|
writeBuffer(input, buffer);
|
|
}
|
|
}
|
|
}
|
|
}).bind("focus.inputmask", function () {
|
|
var $input = $(this), input = this, nptValue = input._valueGet();
|
|
if (opts.showMaskOnFocus && !$input.hasClass('focus.inputmask') && (!opts.showMaskOnHover || (opts.showMaskOnHover && nptValue == ''))) {
|
|
var nptL = nptValue.length;
|
|
if (nptL < buffer.length) {
|
|
if (nptL == 0)
|
|
buffer = getActiveBuffer().slice();
|
|
caret(input, checkVal(input, buffer, true));
|
|
}
|
|
}
|
|
$input.addClass('focus.inputmask');
|
|
undoBuffer = input._valueGet();
|
|
}).bind("mouseleave.inputmask", function () {
|
|
var $input = $(this), input = this;
|
|
if (opts.clearMaskOnLostFocus) {
|
|
if (!$input.hasClass('focus.inputmask')) {
|
|
if (input._valueGet() == getActiveBuffer().join('') || input._valueGet() == '')
|
|
input._valueSet('');
|
|
else { //clearout optional tail of the mask
|
|
clearOptionalTail(input, buffer);
|
|
}
|
|
}
|
|
}
|
|
}).bind("click.inputmask", function () {
|
|
var input = this;
|
|
setTimeout(function () {
|
|
var selectedCaret = caret(input);
|
|
if (selectedCaret.begin == selectedCaret.end) {
|
|
var clickPosition = selectedCaret.begin;
|
|
lastPosition = checkVal(input, buffer, false);
|
|
determineInputDirection(input, selectedCaret);
|
|
if (isRTL)
|
|
caret(input, clickPosition > lastPosition && (isValid(clickPosition, buffer[clickPosition], buffer, true, isRTL) !== false || !isMask(clickPosition)) ? clickPosition : lastPosition);
|
|
else
|
|
caret(input, clickPosition < lastPosition && (isValid(clickPosition, buffer[clickPosition], buffer, true, isRTL) !== false || !isMask(clickPosition)) ? clickPosition : lastPosition);
|
|
}
|
|
}, 0);
|
|
}).bind('dblclick.inputmask', function () {
|
|
var input = this;
|
|
setTimeout(function () {
|
|
caret(input, 0, lastPosition);
|
|
}, 0);
|
|
}).bind("keydown.inputmask", keydownEvent
|
|
).bind("keypress.inputmask", keypressEvent
|
|
).bind("keyup.inputmask", keyupEvent
|
|
).bind(pasteEvent + ".inputmask dragdrop.inputmask drop.inputmask", function () {
|
|
var input = this;
|
|
setTimeout(function () {
|
|
caret(input, checkVal(input, buffer, true));
|
|
if (isComplete(buffer))
|
|
$input.trigger("complete");
|
|
}, 0);
|
|
}).bind('setvalue.inputmask', function () {
|
|
var input = this;
|
|
undoBuffer = input._valueGet();
|
|
checkVal(input, buffer, true);
|
|
if (input._valueGet() == getActiveBuffer().join(''))
|
|
input._valueSet('');
|
|
}).bind('complete.inputmask', opts.oncomplete)
|
|
.bind('incomplete.inputmask', opts.onincomplete)
|
|
.bind('cleared.inputmask', opts.oncleared);
|
|
|
|
//apply mask
|
|
lastPosition = checkVal(el, buffer, true);
|
|
|
|
// Wrap document.activeElement in a try/catch block since IE9 throw "Unspecified error" if document.activeElement is undefined when we are in an IFrame.
|
|
var activeElement;
|
|
try {
|
|
activeElement = document.activeElement;
|
|
} catch (e) { }
|
|
if (activeElement === el) { //position the caret when in focus
|
|
$input.addClass('focus.inputmask');
|
|
caret(el, lastPosition);
|
|
} else if (opts.clearMaskOnLostFocus) {
|
|
if (el._valueGet() == getActiveBuffer().join('')) {
|
|
el._valueSet('');
|
|
} else {
|
|
clearOptionalTail(el, buffer);
|
|
}
|
|
}
|
|
|
|
installEventRuler(el);
|
|
|
|
//private functions
|
|
function installEventRuler(npt) {
|
|
var events = $._data(npt).events;
|
|
|
|
$.each(events, function (eventType, eventHandlers) {
|
|
$.each(eventHandlers, function (ndx, eventHandler) {
|
|
if (eventHandler.namespace == "inputmask") {
|
|
var handler = eventHandler.handler;
|
|
eventHandler.handler = function () {
|
|
if (this.readOnly || this.disabled)
|
|
return false;
|
|
return handler.apply(this, arguments);
|
|
};
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
function patchValueProperty(npt) {
|
|
var valueProperty;
|
|
if (Object.getOwnPropertyDescriptor)
|
|
valueProperty = Object.getOwnPropertyDescriptor(npt, "value");
|
|
if (valueProperty && valueProperty.get) {
|
|
if (!npt._valueGet) {
|
|
|
|
npt._valueGet = valueProperty.get;
|
|
npt._valueSet = valueProperty.set;
|
|
|
|
Object.defineProperty(npt, "value", {
|
|
get: function () {
|
|
var $self = $(this), inputData = $(this).data('inputmask'), masksets = inputData['masksets'],
|
|
activeMasksetIndex = inputData['activeMasksetIndex'];
|
|
return inputData && inputData['autoUnmask'] ? $self.inputmask('unmaskedvalue') : this._valueGet() != masksets[activeMasksetIndex]['_buffer'].join('') ? this._valueGet() : '';
|
|
},
|
|
set: function (value) {
|
|
this._valueSet(value); $(this).triggerHandler('setvalue.inputmask');
|
|
}
|
|
});
|
|
}
|
|
} else if (document.__lookupGetter__ && npt.__lookupGetter__("value")) {
|
|
if (!npt._valueGet) {
|
|
npt._valueGet = npt.__lookupGetter__("value");
|
|
npt._valueSet = npt.__lookupSetter__("value");
|
|
|
|
npt.__defineGetter__("value", function () {
|
|
var $self = $(this), inputData = $(this).data('inputmask'), masksets = inputData['masksets'],
|
|
activeMasksetIndex = inputData['activeMasksetIndex'];
|
|
return inputData && inputData['autoUnmask'] ? $self.inputmask('unmaskedvalue') : this._valueGet() != masksets[activeMasksetIndex]['_buffer'].join('') ? this._valueGet() : '';
|
|
});
|
|
npt.__defineSetter__("value", function (value) {
|
|
this._valueSet(value); $(this).triggerHandler('setvalue.inputmask');
|
|
});
|
|
}
|
|
} else {
|
|
if (!npt._valueGet) {
|
|
npt._valueGet = function () { return this.value; }
|
|
npt._valueSet = function (value) { this.value = value; }
|
|
}
|
|
if ($.fn.val.inputmaskpatch != true) {
|
|
$.fn.val = function () {
|
|
if (arguments.length == 0) {
|
|
var $self = $(this);
|
|
if ($self.data('inputmask')) {
|
|
if ($self.data('inputmask')['autoUnmask'])
|
|
return $self.inputmask('unmaskedvalue');
|
|
else {
|
|
var result = $.inputmask.val.apply($self);
|
|
var inputData = $(this).data('inputmask'), masksets = inputData['masksets'],
|
|
activeMasksetIndex = inputData['activeMasksetIndex'];
|
|
return result != masksets[activeMasksetIndex]['_buffer'].join('') ? result : '';
|
|
}
|
|
} else return $.inputmask.val.apply($self);
|
|
} else {
|
|
var args = arguments;
|
|
return this.each(function () {
|
|
var $self = $(this);
|
|
var result = $.inputmask.val.apply($self, args);
|
|
if ($self.data('inputmask')) $self.triggerHandler('setvalue.inputmask');
|
|
return result;
|
|
});
|
|
}
|
|
};
|
|
$.extend($.fn.val, {
|
|
inputmaskpatch: true
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
function determineInputDirection(input, pos) {
|
|
//set input direction according the position to the radixPoint
|
|
if (opts.numericInput && opts.radixPoint != "") {
|
|
var nptStr = input._valueGet();
|
|
var radixPosition = nptStr.indexOf(opts.radixPoint);
|
|
isRTL = pos.begin <= radixPosition || pos.end <= radixPosition || radixPosition == -1;
|
|
}
|
|
}
|
|
|
|
//shift chars to left from start to end and put c at end position if defined
|
|
function shiftL(start, end, c) {
|
|
while (!isMask(start) && start - 1 >= 0) start--;
|
|
for (var i = start; i < end && i < getMaskLength(buffer) ; i++) {
|
|
if (isMask(i)) {
|
|
setReTargetPlaceHolder(buffer, i);
|
|
var j = seekNext(buffer, i);
|
|
var p = getBufferElement(buffer, j);
|
|
if (p != getPlaceHolder(j)) {
|
|
if (j < getMaskLength(buffer) && isValid(i, p, buffer, true, isRTL) !== false && getActiveTests()[determineTestPosition(i)].def == getActiveTests()[determineTestPosition(j)].def) {
|
|
setBufferElement(buffer, i, getBufferElement(buffer, j));
|
|
setReTargetPlaceHolder(buffer, j); //cleanup next position
|
|
} else {
|
|
if (isMask(i))
|
|
break;
|
|
}
|
|
} else if (c == undefined) break;
|
|
} else {
|
|
setReTargetPlaceHolder(buffer, i);
|
|
}
|
|
}
|
|
if (c != undefined)
|
|
setBufferElement(buffer, isRTL ? end : seekPrevious(buffer, end), c);
|
|
|
|
buffer = truncateInput(buffer.join(''), isRTL).split('');
|
|
if (buffer.length == 0) buffer = getActiveBuffer().slice();
|
|
|
|
return start; //return the used start position
|
|
}
|
|
function shiftR(start, end, c, full) { //full => behave like a push right ~ do not stop on placeholders
|
|
for (var i = start; i <= end && i < getMaskLength(buffer) ; i++) {
|
|
if (isMask(i)) {
|
|
var t = getBufferElement(buffer, i);
|
|
setBufferElement(buffer, i, c);
|
|
if (t != getPlaceHolder(i)) {
|
|
var j = seekNext(buffer, i);
|
|
if (j < getMaskLength(buffer)) {
|
|
if (isValid(j, t, buffer, true, isRTL) !== false && getActiveTests()[determineTestPosition(i)].def == getActiveTests()[determineTestPosition(j)].def)
|
|
c = t;
|
|
else {
|
|
if (isMask(j))
|
|
break;
|
|
else c = t;
|
|
}
|
|
} else break;
|
|
} else if (full !== true) break;
|
|
} else
|
|
setReTargetPlaceHolder(buffer, i);
|
|
}
|
|
var lengthBefore = buffer.length;
|
|
buffer = truncateInput(buffer.join(''), isRTL).split('');
|
|
if (buffer.length == 0) buffer = getActiveBuffer().slice();
|
|
|
|
return end - (lengthBefore - buffer.length); //return new start position
|
|
};
|
|
|
|
function keydownEvent(e) {
|
|
//Safari 5.1.x - modal dialog fires keypress twice workaround
|
|
skipKeyPressEvent = false;
|
|
|
|
var input = this, k = e.keyCode, pos = caret(input);
|
|
determineInputDirection(input, pos);
|
|
|
|
//backspace, delete, and escape get special treatment
|
|
if (k == opts.keyCode.BACKSPACE || k == opts.keyCode.DELETE || (iphone && k == 127)) {//backspace/delete
|
|
var maskL = getMaskLength(buffer);
|
|
if (pos.begin == 0 && pos.end == maskL) { //remove full selection
|
|
activeMasksetIndex = 0; //reset activemask
|
|
buffer = getActiveBuffer().slice();
|
|
writeBuffer(input, buffer);
|
|
caret(input, checkVal(input, buffer, false));
|
|
} else if ((pos.end - pos.begin) > 1 || ((pos.end - pos.begin) == 1 && opts.insertMode)) { //partial selection
|
|
clearBuffer(buffer, pos.begin, pos.end);
|
|
determineActiveMasksetIndex(buffer, pos.begin, activeMasksetIndex);
|
|
writeBuffer(input, buffer, isRTL ? checkVal(input, buffer, false) : pos.begin);
|
|
} else { //handle delete
|
|
var beginPos = android533 ? pos.end : pos.begin;
|
|
if (k == opts.keyCode.DELETE) {
|
|
if (beginPos < firstMaskPos)
|
|
beginPos = firstMaskPos;
|
|
if (beginPos < maskL) {
|
|
if (opts.numericInput && opts.radixPoint != "" && buffer[beginPos] == opts.radixPoint) {
|
|
beginPos = (buffer.length - 1 == beginPos) /* radixPoint is latest? delete it */ ? beginPos : seekNext(buffer, beginPos);
|
|
beginPos = shiftL(beginPos, maskL);
|
|
} else {
|
|
if (isRTL) {
|
|
beginPos = shiftR(firstMaskPos, beginPos, getPlaceHolder(beginPos), true);
|
|
beginPos = seekNext(buffer, beginPos);
|
|
} else {
|
|
beginPos = shiftL(beginPos, maskL);
|
|
}
|
|
}
|
|
determineActiveMasksetIndex(buffer, beginPos, activeMasksetIndex);
|
|
writeBuffer(input, buffer, beginPos);
|
|
}
|
|
} else if (k == opts.keyCode.BACKSPACE) { //handle backspace
|
|
if (beginPos > firstMaskPos) {
|
|
beginPos -= 1;
|
|
if (opts.numericInput && opts.radixPoint != "" && buffer[beginPos] == opts.radixPoint) {
|
|
beginPos = shiftR(firstMaskPos, (buffer.length - 1 == beginPos) /* radixPoint is latest? delete it */ ? beginPos : beginPos - 1, getPlaceHolder(beginPos), true);
|
|
beginPos++;
|
|
} else {
|
|
if (isRTL) {
|
|
beginPos = shiftR(firstMaskPos, beginPos, getPlaceHolder(beginPos), true);
|
|
beginPos = buffer[beginPos + 1] == opts.radixPoint ? beginPos + 1 : seekNext(buffer, beginPos);
|
|
} else {
|
|
beginPos = shiftL(beginPos, maskL);
|
|
}
|
|
}
|
|
determineActiveMasksetIndex(buffer, beginPos, activeMasksetIndex);
|
|
writeBuffer(input, buffer, beginPos);
|
|
}
|
|
}
|
|
}
|
|
if (input._valueGet() == getActiveBuffer().join(''))
|
|
$(input).trigger('cleared');
|
|
|
|
e.preventDefault(); //stop default action but allow propagation
|
|
} else if (k == opts.keyCode.END || k == opts.keyCode.PAGE_DOWN) { //when END or PAGE_DOWN pressed set position at lastmatch
|
|
setTimeout(function () {
|
|
var caretPos = checkVal(input, buffer, false, true);
|
|
if (!opts.insertMode && caretPos == getMaskLength(buffer) && !e.shiftKey) caretPos--;
|
|
caret(input, e.shiftKey ? pos.begin : caretPos, caretPos);
|
|
}, 0);
|
|
} else if ((k == opts.keyCode.HOME && !e.shiftKey) || k == opts.keyCode.PAGE_UP) {//Home or page_up
|
|
caret(input, 0, e.shiftKey ? pos.begin : 0);
|
|
}
|
|
else if (k == opts.keyCode.ESCAPE) {//escape
|
|
input._valueSet(undoBuffer);
|
|
caret(input, 0, checkVal(input, buffer));
|
|
} else if (k == opts.keyCode.INSERT) {//insert
|
|
opts.insertMode = !opts.insertMode;
|
|
caret(input, !opts.insertMode && pos.begin == getMaskLength(buffer) ? pos.begin - 1 : pos.begin);
|
|
} else if (e.ctrlKey && k == 88) {
|
|
setTimeout(function () {
|
|
caret(input, checkVal(input, buffer, true));
|
|
}, 0);
|
|
} else if (!opts.insertMode) { //overwritemode
|
|
if (k == opts.keyCode.RIGHT) {//right
|
|
var caretPos = pos.begin == pos.end ? pos.end + 1 : pos.end;
|
|
caretPos = caretPos < getMaskLength(buffer) ? caretPos : pos.end;
|
|
caret(input, e.shiftKey ? pos.begin : caretPos, e.shiftKey ? caretPos + 1 : caretPos);
|
|
} else if (k == opts.keyCode.LEFT) {//left
|
|
var caretPos = pos.begin - 1;
|
|
caretPos = caretPos > 0 ? caretPos : 0;
|
|
caret(input, caretPos, e.shiftKey ? pos.end : caretPos);
|
|
}
|
|
}
|
|
|
|
opts.onKeyDown.call(this, e, buffer, opts); //extra stuff to execute on keydown
|
|
ignorable = $.inArray(k, opts.ignorables) != -1;
|
|
}
|
|
|
|
function keypressEvent(e) {
|
|
//Safari 5.1.x - modal dialog fires keypress twice workaround
|
|
if (skipKeyPressEvent) return false;
|
|
skipKeyPressEvent = true;
|
|
|
|
var input = this, $input = $(input);
|
|
|
|
e = e || window.event;
|
|
var k = e.which || e.charCode || e.keyCode,
|
|
c = String.fromCharCode(k);
|
|
|
|
if (opts.numericInput && c == opts.radixPoint) {
|
|
var nptStr = input._valueGet();
|
|
var radixPosition = nptStr.indexOf(opts.radixPoint);
|
|
caret(input, seekNext(buffer, radixPosition != -1 ? radixPosition : getMaskLength(buffer)));
|
|
}
|
|
|
|
if (e.metaKey || ignorable) {
|
|
return true;
|
|
} else {
|
|
if (k) {
|
|
//$input.trigger('input');
|
|
|
|
var pos = caret(input), maskL = getMaskLength(buffer), writeOutBuffer = true;
|
|
clearBuffer(buffer, pos.begin, pos.end);
|
|
|
|
if (isRTL) {
|
|
var p = seekPrevious(buffer, pos.end), np;
|
|
if ((np = isValid(p == maskL || getBufferElement(buffer, p) == opts.radixPoint ? seekPrevious(buffer, p) : p, c, buffer, false, isRTL)) !== false) {
|
|
var refresh = false;
|
|
if (np !== true) {
|
|
refresh = np["refresh"]; //only rewrite buffer from isValid
|
|
p = np.pos != undefined ? np.pos : p; //set new position from isValid
|
|
c = np.c != undefined ? np.c : c; //set new char from isValid
|
|
}
|
|
if (refresh !== true) {
|
|
maskL = getMaskLength(buffer); //update masklength to include possible groupSeparator offset
|
|
var firstUnmaskedPosition = firstMaskPos;
|
|
if (opts.insertMode == true) {
|
|
if (getActiveMaskSet()['greedy'] == true) {
|
|
var bfrClone = buffer.slice();
|
|
while (getBufferElement(bfrClone, firstUnmaskedPosition, true) != getPlaceHolder(firstUnmaskedPosition) && firstUnmaskedPosition <= p) {
|
|
firstUnmaskedPosition = firstUnmaskedPosition == maskL ? (maskL + 1) : seekNext(buffer, firstUnmaskedPosition);
|
|
}
|
|
}
|
|
if (firstUnmaskedPosition <= p && (getActiveMaskSet()['greedy'] || buffer.length < maskL)) {
|
|
if (buffer[firstMaskPos] != getPlaceHolder(firstMaskPos) && buffer.length < maskL) {
|
|
var offset = prepareBuffer(buffer, -1, isRTL);
|
|
if (pos.end != 0) p = p + offset;
|
|
maskL = buffer.length;
|
|
}
|
|
shiftL(firstUnmaskedPosition, p, c);
|
|
} else writeOutBuffer = false;
|
|
} else setBufferElement(buffer, p, c);
|
|
}
|
|
|
|
if (writeOutBuffer) {
|
|
writeBuffer(input, buffer, opts.numericInput ? p + 1 : p);
|
|
setTimeout(function () { //timeout needed for IE
|
|
if (isComplete(buffer))
|
|
$input.trigger("complete");
|
|
}, 0);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
var p = seekNext(buffer, pos.begin - 1), np;
|
|
prepareBuffer(buffer, p, isRTL);
|
|
if ((np = isValid(p, c, buffer, false, isRTL)) !== false) {
|
|
var refresh = false;
|
|
if (np !== true) {
|
|
refresh = np["refresh"]; //only rewrite buffer from isValid
|
|
p = np.pos != undefined ? np.pos : p; //set new position from isValid
|
|
c = np.c != undefined ? np.c : c; //set new char from isValid
|
|
}
|
|
if (refresh !== true) {
|
|
if (opts.insertMode == true) {
|
|
var lastUnmaskedPosition = getMaskLength(buffer);
|
|
var bfrClone = buffer.slice();
|
|
while (getBufferElement(bfrClone, lastUnmaskedPosition, true) != getPlaceHolder(lastUnmaskedPosition) && lastUnmaskedPosition >= p) {
|
|
lastUnmaskedPosition = lastUnmaskedPosition == 0 ? -1 : seekPrevious(buffer, lastUnmaskedPosition);
|
|
}
|
|
if (lastUnmaskedPosition >= p)
|
|
shiftR(p, buffer.length, c);
|
|
else writeOutBuffer = false;
|
|
} else setBufferElement(buffer, p, c);
|
|
}
|
|
if (writeOutBuffer) {
|
|
var next = seekNext(buffer, p);
|
|
writeBuffer(input, buffer, next);
|
|
|
|
setTimeout(function () { //timeout needed for IE
|
|
if (isComplete(buffer))
|
|
$input.trigger("complete");
|
|
}, 0);
|
|
}
|
|
}
|
|
}
|
|
if (android) {
|
|
caret(input, caretSavePoint.begin, caretSavePoint.end);
|
|
}
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
}
|
|
|
|
function keyupEvent(e) {
|
|
var $input = $(this), input = this;
|
|
var k = e.keyCode;
|
|
opts.onKeyUp.call(this, e, buffer, opts); //extra stuff to execute on keyup
|
|
if (k == opts.keyCode.TAB && $input.hasClass('focus.inputmask') && input._valueGet().length == 0 && opts.showMaskOnFocus) {
|
|
buffer = getActiveBuffer().slice();
|
|
writeBuffer(input, buffer);
|
|
if (!isRTL) caret(input, 0);
|
|
undoBuffer = input._valueGet();
|
|
}
|
|
}
|
|
}
|
|
|
|
return this; //return this to expose publics
|
|
};
|
|
}
|
|
})(jQuery);
|
|
/*
|
|
Input Mask plugin extensions
|
|
http://github.com/RobinHerbots/jquery.inputmask
|
|
Copyright (c) 2010 - 2013 Robin Herbots
|
|
Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
|
|
Version: 2.2.2
|
|
|
|
Optional extensions on the jquery.inputmask base
|
|
*/
|
|
(function ($) {
|
|
//extra definitions
|
|
$.extend($.inputmask.defaults.definitions, {
|
|
'A': { //auto uppercasing
|
|
validator: "[A-Za-z]",
|
|
cardinality: 1,
|
|
casing: "upper"
|
|
},
|
|
'#': {
|
|
validator: "[A-Za-z\u0410-\u044F\u0401\u04510-9]",
|
|
cardinality: 1,
|
|
casing: "upper"
|
|
}
|
|
});
|
|
$.extend($.inputmask.defaults.aliases, {
|
|
'url': {
|
|
mask: "ir",
|
|
placeholder: "",
|
|
separator: "",
|
|
defaultPrefix: "http://",
|
|
regex: {
|
|
urlpre1: new RegExp("[fh]"),
|
|
urlpre2: new RegExp("(ft|ht)"),
|
|
urlpre3: new RegExp("(ftp|htt)"),
|
|
urlpre4: new RegExp("(ftp:|http|ftps)"),
|
|
urlpre5: new RegExp("(ftp:/|ftps:|http:|https)"),
|
|
urlpre6: new RegExp("(ftp://|ftps:/|http:/|https:)"),
|
|
urlpre7: new RegExp("(ftp://|ftps://|http://|https:/)"),
|
|
urlpre8: new RegExp("(ftp://|ftps://|http://|https://)")
|
|
},
|
|
definitions: {
|
|
'i': {
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
return true;
|
|
},
|
|
cardinality: 8,
|
|
prevalidator: (function () {
|
|
var result = [], prefixLimit = 8;
|
|
for (var i = 0; i < prefixLimit; i++) {
|
|
result[i] = (function () {
|
|
var j = i;
|
|
return {
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
if (opts.regex["urlpre" + (j + 1)]) {
|
|
var tmp = chrs, k;
|
|
if (((j + 1) - chrs.length) > 0) {
|
|
tmp = buffer.join('').substring(0, ((j + 1) - chrs.length)) + "" + tmp;
|
|
}
|
|
var isValid = opts.regex["urlpre" + (j + 1)].test(tmp);
|
|
if (!strict && !isValid) {
|
|
pos = pos - j;
|
|
for (k = 0; k < opts.defaultPrefix.length; k++) {
|
|
buffer[pos] = opts.defaultPrefix[k]; pos++;
|
|
}
|
|
for (k = 0; k < tmp.length - 1; k++) {
|
|
buffer[pos] = tmp[k]; pos++;
|
|
}
|
|
return { "pos": pos };
|
|
}
|
|
return isValid;
|
|
} else {
|
|
return false;
|
|
}
|
|
}, cardinality: j
|
|
};
|
|
})();
|
|
}
|
|
return result;
|
|
})()
|
|
}
|
|
},
|
|
insertMode: false,
|
|
autoUnmask: false
|
|
},
|
|
"ip": {
|
|
mask: "i.i.i.i",
|
|
definitions: {
|
|
'i': {
|
|
validator: "25[0-5]|2[0-4][0-9]|[01][0-9][0-9]",
|
|
cardinality: 3,
|
|
prevalidator: [
|
|
{ validator: "[0-2]", cardinality: 1 },
|
|
{ validator: "2[0-5]|[01][0-9]", cardinality: 2 }
|
|
]
|
|
}
|
|
}
|
|
}
|
|
});
|
|
})(jQuery);/*
|
|
Input Mask plugin extensions
|
|
http://github.com/RobinHerbots/jquery.inputmask
|
|
Copyright (c) 2010 - 2012 Robin Herbots
|
|
Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
|
|
Version: 2.2.2
|
|
|
|
Optional extensions on the jquery.inputmask base
|
|
*/
|
|
(function ($) {
|
|
//date & time aliases
|
|
$.extend($.inputmask.defaults.definitions, {
|
|
'h': { //hours
|
|
validator: "[01][0-9]|2[0-3]",
|
|
cardinality: 2,
|
|
prevalidator: [{ validator: "[0-2]", cardinality: 1 }]
|
|
},
|
|
's': { //seconds || minutes
|
|
validator: "[0-5][0-9]",
|
|
cardinality: 2,
|
|
prevalidator: [{ validator: "[0-5]", cardinality: 1 }]
|
|
},
|
|
'd': { //basic day
|
|
validator: "0[1-9]|[12][0-9]|3[01]",
|
|
cardinality: 2,
|
|
prevalidator: [{ validator: "[0-3]", cardinality: 1 }]
|
|
},
|
|
'm': { //basic month
|
|
validator: "0[1-9]|1[012]",
|
|
cardinality: 2,
|
|
prevalidator: [{ validator: "[01]", cardinality: 1 }]
|
|
},
|
|
'y': { //basic year
|
|
validator: "(19|20)\\d{2}",
|
|
cardinality: 4,
|
|
prevalidator: [
|
|
{ validator: "[12]", cardinality: 1 },
|
|
{ validator: "(19|20)", cardinality: 2 },
|
|
{ validator: "(19|20)\\d", cardinality: 3 }
|
|
]
|
|
}
|
|
});
|
|
$.extend($.inputmask.defaults.aliases, {
|
|
'dd/mm/yyyy': {
|
|
mask: "1/2/y",
|
|
placeholder: "dd/mm/yyyy",
|
|
regex: {
|
|
val1pre: new RegExp("[0-3]"), //daypre
|
|
val1: new RegExp("0[1-9]|[12][0-9]|3[01]"), //day
|
|
val2pre: function (separator) { var escapedSeparator = $.inputmask.escapeRegex.call(this, separator); return new RegExp("((0[1-9]|[12][0-9]|3[01])" + escapedSeparator + "[01])"); }, //monthpre
|
|
val2: function (separator) { var escapedSeparator = $.inputmask.escapeRegex.call(this, separator); return new RegExp("((0[1-9]|[12][0-9])" + escapedSeparator + "(0[1-9]|1[012]))|(30" + escapedSeparator + "(0[13-9]|1[012]))|(31" + escapedSeparator + "(0[13578]|1[02]))"); }//month
|
|
},
|
|
leapday: "29/02/",
|
|
separator: '/',
|
|
yearrange: { minyear: 1900, maxyear: 2099 },
|
|
isInYearRange: function (chrs, minyear, maxyear) {
|
|
var enteredyear = parseInt(chrs.concat(minyear.toString().slice(chrs.length)));
|
|
var enteredyear2 = parseInt(chrs.concat(maxyear.toString().slice(chrs.length)));
|
|
return (enteredyear != NaN ? minyear <= enteredyear && enteredyear <= maxyear : false) ||
|
|
(enteredyear2 != NaN ? minyear <= enteredyear2 && enteredyear2 <= maxyear : false);
|
|
},
|
|
determinebaseyear: function (minyear, maxyear) {
|
|
var currentyear = (new Date()).getFullYear();
|
|
if (minyear > currentyear) return minyear;
|
|
if (maxyear < currentyear) return maxyear;
|
|
|
|
return currentyear;
|
|
},
|
|
onKeyUp: function (e, buffer, opts) {
|
|
var $input = $(this);
|
|
if (e.ctrlKey && e.keyCode == opts.keyCode.RIGHT) {
|
|
var today = new Date();
|
|
$input.val(today.getDate().toString() + (today.getMonth() + 1).toString() + today.getFullYear().toString());
|
|
}
|
|
},
|
|
definitions: {
|
|
'1': { //val1 ~ day or month
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.val1.test(chrs);
|
|
if (!strict && !isValid) {
|
|
if (chrs.charAt(1) == opts.separator || "-./".indexOf(chrs.charAt(1)) != -1) {
|
|
isValid = opts.regex.val1.test("0" + chrs.charAt(0));
|
|
if (isValid) {
|
|
buffer[pos - 1] = "0";
|
|
return { "pos": pos, "c": chrs.charAt(0) };
|
|
}
|
|
}
|
|
}
|
|
return isValid;
|
|
},
|
|
cardinality: 2,
|
|
prevalidator: [{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.val1pre.test(chrs);
|
|
if (!strict && !isValid) {
|
|
isValid = opts.regex.val1.test("0" + chrs);
|
|
if (isValid) {
|
|
buffer[pos] = "0";
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 1
|
|
}]
|
|
},
|
|
'2': { //val2 ~ day or month
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var frontValue = buffer.join('').substr(0, 3);
|
|
var isValid = opts.regex.val2(opts.separator).test(frontValue + chrs);
|
|
if (!strict && !isValid) {
|
|
if (chrs.charAt(1) == opts.separator || "-./".indexOf(chrs.charAt(1)) != -1) {
|
|
isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs.charAt(0));
|
|
if (isValid) {
|
|
buffer[pos - 1] = "0";
|
|
return { "pos": pos, "c": chrs.charAt(0) };
|
|
}
|
|
}
|
|
}
|
|
return isValid;
|
|
},
|
|
cardinality: 2,
|
|
prevalidator: [{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var frontValue = buffer.join('').substr(0, 3);
|
|
var isValid = opts.regex.val2pre(opts.separator).test(frontValue + chrs);
|
|
if (!strict && !isValid) {
|
|
isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs);
|
|
if (isValid) {
|
|
buffer[pos] = "0";
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 1
|
|
}]
|
|
},
|
|
'y': { //year
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
if (opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear)) {
|
|
var dayMonthValue = buffer.join('').substr(0, 6);
|
|
if (dayMonthValue != opts.leapday)
|
|
return true;
|
|
else {
|
|
var year = parseInt(chrs, 10);//detect leap year
|
|
if (year % 4 === 0)
|
|
if (year % 100 === 0)
|
|
if (year % 400 === 0)
|
|
return true;
|
|
else return false;
|
|
else return true;
|
|
else return false;
|
|
}
|
|
} else return false;
|
|
},
|
|
cardinality: 4,
|
|
prevalidator: [
|
|
{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
if (!strict && !isValid) {
|
|
var yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear).toString().slice(0, 1);
|
|
|
|
isValid = opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
if (isValid) {
|
|
buffer[pos++] = yearPrefix[0];
|
|
return { "pos": pos };
|
|
}
|
|
yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear).toString().slice(0, 2);
|
|
|
|
isValid = opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
if (isValid) {
|
|
buffer[pos++] = yearPrefix[0];
|
|
buffer[pos++] = yearPrefix[1];
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
},
|
|
cardinality: 1
|
|
},
|
|
{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
if (!strict && !isValid) {
|
|
var yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear).toString().slice(0, 2);
|
|
|
|
isValid = opts.isInYearRange(chrs[0] + yearPrefix[1] + chrs[1], opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
if (isValid) {
|
|
buffer[pos++] = yearPrefix[1];
|
|
return { "pos": pos };
|
|
}
|
|
|
|
yearPrefix = opts.determinebaseyear(opts.yearrange.minyear, opts.yearrange.maxyear).toString().slice(0, 2);
|
|
if (opts.isInYearRange(yearPrefix + chrs, opts.yearrange.minyear, opts.yearrange.maxyear)) {
|
|
var dayMonthValue = buffer.join('').substr(0, 6);
|
|
if (dayMonthValue != opts.leapday)
|
|
isValid = true;
|
|
else {
|
|
var year = parseInt(chrs, 10);//detect leap year
|
|
if (year % 4 === 0)
|
|
if (year % 100 === 0)
|
|
if (year % 400 === 0)
|
|
isValid = true;
|
|
else isValid = false;
|
|
else isValid = true;
|
|
else isValid = false;
|
|
}
|
|
} else isValid = false;
|
|
if (isValid) {
|
|
buffer[pos - 1] = yearPrefix[0];
|
|
buffer[pos++] = yearPrefix[1];
|
|
buffer[pos++] = chrs[0];
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 2
|
|
},
|
|
{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
return opts.isInYearRange(chrs, opts.yearrange.minyear, opts.yearrange.maxyear);
|
|
}, cardinality: 3
|
|
}
|
|
]
|
|
}
|
|
},
|
|
insertMode: false,
|
|
autoUnmask: false
|
|
},
|
|
'mm/dd/yyyy': {
|
|
placeholder: "mm/dd/yyyy",
|
|
alias: "dd/mm/yyyy", //reuse functionality of dd/mm/yyyy alias
|
|
regex: {
|
|
val2pre: function (separator) { var escapedSeparator = $.inputmask.escapeRegex.call(this, separator); return new RegExp("((0[13-9]|1[012])" + escapedSeparator + "[0-3])|(02" + escapedSeparator + "[0-2])"); }, //daypre
|
|
val2: function (separator) { var escapedSeparator = $.inputmask.escapeRegex.call(this, separator); return new RegExp("((0[1-9]|1[012])" + escapedSeparator + "(0[1-9]|[12][0-9]))|((0[13-9]|1[012])" + escapedSeparator + "30)|((0[13578]|1[02])" + escapedSeparator + "31)"); }, //day
|
|
val1pre: new RegExp("[01]"), //monthpre
|
|
val1: new RegExp("0[1-9]|1[012]") //month
|
|
},
|
|
leapday: "02/29/",
|
|
onKeyUp: function (e, buffer, opts) {
|
|
var $input = $(this);
|
|
if (e.ctrlKey && e.keyCode == opts.keyCode.RIGHT) {
|
|
var today = new Date();
|
|
$input.val((today.getMonth() + 1).toString() + today.getDate().toString() + today.getFullYear().toString());
|
|
}
|
|
}
|
|
},
|
|
'yyyy/mm/dd': {
|
|
mask: "y/1/2",
|
|
placeholder: "yyyy/mm/dd",
|
|
alias: "mm/dd/yyyy",
|
|
leapday: "/02/29",
|
|
onKeyUp: function (e, buffer, opts) {
|
|
var $input = $(this);
|
|
if (e.ctrlKey && e.keyCode == opts.keyCode.RIGHT) {
|
|
var today = new Date();
|
|
$input.val(today.getFullYear().toString() + (today.getMonth() + 1).toString() + today.getDate().toString());
|
|
}
|
|
},
|
|
definitions: {
|
|
'2': { //val2 ~ day or month
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var frontValue = buffer.join('').substr(5, 3);
|
|
var isValid = opts.regex.val2(opts.separator).test(frontValue + chrs);
|
|
if (!strict && !isValid) {
|
|
if (chrs.charAt(1) == opts.separator || "-./".indexOf(chrs.charAt(1)) != -1) {
|
|
isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs.charAt(0));
|
|
if (isValid) {
|
|
buffer[pos - 1] = "0";
|
|
return { "pos": pos, "c": chrs.charAt(0) };
|
|
}
|
|
}
|
|
}
|
|
|
|
//check leap yeap
|
|
if (isValid) {
|
|
var dayMonthValue = buffer.join('').substr(4, 4) + chrs;
|
|
if (dayMonthValue != opts.leapday)
|
|
return true;
|
|
else {
|
|
var year = parseInt(buffer.join('').substr(0, 4), 10); //detect leap year
|
|
if (year % 4 === 0)
|
|
if (year % 100 === 0)
|
|
if (year % 400 === 0)
|
|
return true;
|
|
else return false;
|
|
else return true;
|
|
else return false;
|
|
}
|
|
}
|
|
|
|
return isValid;
|
|
},
|
|
cardinality: 2,
|
|
prevalidator: [{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var frontValue = buffer.join('').substr(5, 3);
|
|
var isValid = opts.regex.val2pre(opts.separator).test(frontValue + chrs);
|
|
if (!strict && !isValid) {
|
|
isValid = opts.regex.val2(opts.separator).test(frontValue + "0" + chrs);
|
|
if (isValid) {
|
|
buffer[pos] = "0";
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 1
|
|
}]
|
|
}
|
|
}
|
|
},
|
|
'dd.mm.yyyy': {
|
|
mask: "1.2.y",
|
|
placeholder: "dd.mm.yyyy",
|
|
leapday: "29.02.",
|
|
separator: '.',
|
|
alias: "dd/mm/yyyy"
|
|
},
|
|
'dd-mm-yyyy': {
|
|
mask: "1-2-y",
|
|
placeholder: "dd-mm-yyyy",
|
|
leapday: "29-02-",
|
|
separator: '-',
|
|
alias: "dd/mm/yyyy"
|
|
},
|
|
'mm.dd.yyyy': {
|
|
mask: "1.2.y",
|
|
placeholder: "mm.dd.yyyy",
|
|
leapday: "02.29.",
|
|
separator: '.',
|
|
alias: "mm/dd/yyyy"
|
|
},
|
|
'mm-dd-yyyy': {
|
|
mask: "1-2-y",
|
|
placeholder: "mm-dd-yyyy",
|
|
leapday: "02-29-",
|
|
separator: '-',
|
|
alias: "mm/dd/yyyy"
|
|
},
|
|
'yyyy.mm.dd': {
|
|
mask: "y.1.2",
|
|
placeholder: "yyyy.mm.dd",
|
|
leapday: ".02.29",
|
|
separator: '.',
|
|
alias: "yyyy/mm/dd"
|
|
},
|
|
'yyyy-mm-dd': {
|
|
mask: "y-1-2",
|
|
placeholder: "yyyy-mm-dd",
|
|
leapday: "-02-29",
|
|
separator: '-',
|
|
alias: "yyyy/mm/dd"
|
|
},
|
|
'datetime': {
|
|
mask: "1/2/y h:s",
|
|
placeholder: "dd/mm/yyyy hh:mm",
|
|
alias: "dd/mm/yyyy",
|
|
regex: {
|
|
hrspre: new RegExp("[012]"), //hours pre
|
|
hrs24: new RegExp("2[0-9]|1[3-9]"),
|
|
hrs: new RegExp("[01][0-9]|2[0-3]"), //hours
|
|
ampmpre: new RegExp("[apAP]"),
|
|
ampm: new RegExp("^[a|p|A|P][m|M]")
|
|
},
|
|
timeseparator: ':',
|
|
hourFormat: "24", // or 12
|
|
definitions: {
|
|
'h': { //hours
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.hrs.test(chrs);
|
|
if (!strict && !isValid) {
|
|
if (chrs.charAt(1) == opts.timeseparator || "-.:".indexOf(chrs.charAt(1)) != -1) {
|
|
isValid = opts.regex.hrs.test("0" + chrs.charAt(0));
|
|
if (isValid) {
|
|
buffer[pos - 1] = "0";
|
|
buffer[pos] = chrs.charAt(0);
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isValid && opts.hourFormat !== "24" && opts.regex.hrs24.test(chrs)) {
|
|
|
|
var tmp = parseInt(chrs, 10);
|
|
|
|
if (tmp == 24) {
|
|
buffer[pos + 5] = "a";
|
|
buffer[pos + 6] = "m";
|
|
} else {
|
|
buffer[pos + 5] = "p";
|
|
buffer[pos + 6] = "m";
|
|
}
|
|
|
|
tmp = tmp - 12;
|
|
|
|
if (tmp < 10) {
|
|
buffer[pos] = tmp.toString();
|
|
buffer[pos - 1] = "0";
|
|
} else {
|
|
buffer[pos] = tmp.toString().charAt(1);
|
|
buffer[pos - 1] = tmp.toString().charAt(0);
|
|
}
|
|
|
|
return { "pos": pos, "c": buffer[pos] };
|
|
}
|
|
|
|
return isValid;
|
|
},
|
|
cardinality: 2,
|
|
prevalidator: [{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.hrspre.test(chrs);
|
|
if (!strict && !isValid) {
|
|
isValid = opts.regex.hrs.test("0" + chrs);
|
|
if (isValid) {
|
|
buffer[pos] = "0";
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 1
|
|
}]
|
|
},
|
|
't': { //am/pm
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.ampm.test(chrs);
|
|
if (!strict && !isValid) {
|
|
isValid = opts.regex.ampm.test(chrs + 'm');
|
|
if (isValid) {
|
|
buffer[pos - 1] = chrs.charAt(0);
|
|
buffer[pos] = "m";
|
|
pos++;
|
|
return pos;
|
|
}
|
|
}
|
|
return isValid;
|
|
},
|
|
casing: "lower",
|
|
cardinality: 2,
|
|
prevalidator: [{
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
var isValid = opts.regex.ampmpre.test(chrs);
|
|
if (isValid) {
|
|
isValid = opts.regex.ampm.test(chrs + "m");
|
|
if (isValid) {
|
|
buffer[pos] = chrs;
|
|
buffer[pos + 1] = 'm';
|
|
return pos;
|
|
}
|
|
}
|
|
return isValid;
|
|
}, cardinality: 1
|
|
}]
|
|
}
|
|
},
|
|
insertMode: false,
|
|
autoUnmask: false
|
|
},
|
|
'datetime12': {
|
|
mask: "1/2/y h:s t",
|
|
placeholder: "dd/mm/yyyy hh:mm xm",
|
|
alias: "datetime",
|
|
hourFormat: "12"
|
|
},
|
|
'hh:mm t': {
|
|
mask: "h:s t",
|
|
placeholder: "hh:mm xm",
|
|
alias: "datetime",
|
|
hourFormat: "12"
|
|
},
|
|
'h:s t': {
|
|
mask: "h:s t",
|
|
placeholder: "hh:mm xm",
|
|
alias: "datetime",
|
|
hourFormat: "12"
|
|
},
|
|
'hh:mm:ss': {
|
|
mask: "h:s:s",
|
|
autoUnmask: false
|
|
},
|
|
'hh:mm': {
|
|
mask: "h:s",
|
|
autoUnmask: false
|
|
},
|
|
'date': {
|
|
alias: "dd/mm/yyyy" // "mm/dd/yyyy"
|
|
}
|
|
});
|
|
})(jQuery);/*
|
|
Input Mask plugin extensions
|
|
http://github.com/RobinHerbots/jquery.inputmask
|
|
Copyright (c) 2010 - 2013 Robin Herbots
|
|
Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
|
|
Version: 2.2.2
|
|
|
|
Optional extensions on the jquery.inputmask base
|
|
*/
|
|
(function ($) {
|
|
//number aliases
|
|
$.extend($.inputmask.defaults.aliases, {
|
|
'decimal': {
|
|
mask: "~",
|
|
placeholder: "",
|
|
repeat: 10,
|
|
greedy: false,
|
|
numericInput: true,
|
|
digits: "*", //numer of digits
|
|
groupSeparator: ",", // | "."
|
|
radixPoint: ".",
|
|
groupSize: 3,
|
|
autoGroup: false,
|
|
getMaskLength: function (buffer, greedy, repeat, currentBuffer, opts) { //custom getMaskLength to take the groupSeparator into account
|
|
var calculatedLength = buffer.length;
|
|
|
|
if (!greedy && repeat > 1) {
|
|
calculatedLength += (buffer.length * (repeat - 1));
|
|
}
|
|
|
|
var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, opts.groupSeparator);
|
|
var escapedRadixPoint = $.inputmask.escapeRegex.call(this, opts.radixPoint);
|
|
var currentBufferStr = currentBuffer.join(''), strippedBufferStr = currentBufferStr.replace(new RegExp(escapedGroupSeparator, "g"), "").replace(new RegExp(escapedRadixPoint), ""),
|
|
groupOffset = currentBufferStr.length - strippedBufferStr.length;
|
|
return calculatedLength + groupOffset;
|
|
},
|
|
postFormat: function (buffer, pos, reformatOnly, opts) {
|
|
var cbuf = buffer.slice();
|
|
if (!reformatOnly) cbuf.splice(pos, 0, "?"); //set position indicator
|
|
var bufVal = cbuf.join('');
|
|
if (opts.autoGroup || (reformatOnly && bufVal.indexOf(opts.groupSeparator) != -1)) {
|
|
bufVal = bufVal.replace(new RegExp("\\" + opts.groupSeparator, "g"), '');
|
|
var radixSplit = bufVal.split(opts.radixPoint);
|
|
bufVal = radixSplit[0];
|
|
var reg = new RegExp('([-\+]?[\\d\?]+)([\\d\?]{' + opts.groupSize + '})');
|
|
while (reg.test(bufVal)) {
|
|
bufVal = bufVal.replace(reg, '$1' + opts.groupSeparator + '$2');
|
|
bufVal = bufVal.replace(opts.groupSeparator + opts.groupSeparator, opts.groupSeparator);
|
|
}
|
|
if (radixSplit.length > 1)
|
|
bufVal += opts.radixPoint + radixSplit[1];
|
|
}
|
|
buffer.length = bufVal.length; //align the length
|
|
for (var i = 0, l = bufVal.length; i < l; i++) {
|
|
buffer[i] = bufVal.charAt(i);
|
|
}
|
|
var newPos = reformatOnly ? pos : $.inArray("?", buffer);
|
|
if (!reformatOnly) buffer.splice(newPos, 1);
|
|
|
|
return newPos;
|
|
},
|
|
regex: {
|
|
number: function (groupSeparator, groupSize, radixPoint, digits) {
|
|
var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, groupSeparator);
|
|
var escapedRadixPoint = $.inputmask.escapeRegex.call(this, radixPoint);
|
|
var digitExpression = isNaN(digits) ? digits : '{0,' + digits + '}';
|
|
return new RegExp("^[\+-]?(\\d+|\\d{1," + groupSize + "}((" + escapedGroupSeparator + "\\d{" + groupSize + "})?)+)(" + escapedRadixPoint + "\\d" + digitExpression + ")?$");
|
|
}
|
|
},
|
|
onKeyDown: function (e, buffer, opts) {
|
|
var $input = $(this), input = this;
|
|
if (e.keyCode == opts.keyCode.TAB) {
|
|
var radixPosition = $.inArray(opts.radixPoint, buffer);
|
|
if (radixPosition != -1) {
|
|
var masksets = $input.data('inputmask')['masksets'];
|
|
var activeMasksetIndex = $input.data('inputmask')['activeMasksetIndex'];
|
|
for (var i = 1; i <= opts.digits && i < opts.getMaskLength(masksets[activeMasksetIndex]["_buffer"], masksets[activeMasksetIndex]["greedy"], masksets[activeMasksetIndex]["repeat"], buffer, opts) ; i++) {
|
|
if (buffer[radixPosition + i] == undefined) buffer[radixPosition + i] = "0";
|
|
}
|
|
input._valueSet(buffer.join(''));
|
|
}
|
|
} else if (e.keyCode == opts.keyCode.DELETE || e.keyCode == opts.keyCode.BACKSPACE) {
|
|
opts.postFormat(buffer, 0, true, opts);
|
|
input._valueSet(buffer.join(''));
|
|
}
|
|
},
|
|
definitions: {
|
|
'~': { //real number
|
|
validator: function (chrs, buffer, pos, strict, opts) {
|
|
if (chrs == "") return false;
|
|
if (pos == 1 && buffer[0] === '0' && new RegExp("[\\d-]").test(chrs)) { //handle first char
|
|
buffer[0] = "";
|
|
return { "pos": 0 };
|
|
}
|
|
|
|
var cbuf = strict ? buffer.slice(0, pos) : buffer.slice();
|
|
|
|
cbuf.splice(pos + 1, 0, chrs);
|
|
var bufferStr = cbuf.join('');
|
|
if (opts.autoGroup && !strict) //strip groupseparator
|
|
bufferStr = bufferStr.replace(new RegExp("\\" + opts.groupSeparator, "g"), '');
|
|
var isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits).test(bufferStr);
|
|
if (!isValid) {
|
|
//let's help the regex a bit
|
|
bufferStr += "0";
|
|
isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits).test(bufferStr);
|
|
if (!isValid) {
|
|
//make a valid group
|
|
var lastGroupSeparator = bufferStr.lastIndexOf(opts.groupSeparator);
|
|
for (i = bufferStr.length - lastGroupSeparator; i <= 3; i++) {
|
|
bufferStr += "0";
|
|
}
|
|
|
|
isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits).test(bufferStr);
|
|
if (!isValid && !strict) {
|
|
if (chrs == opts.radixPoint) {
|
|
isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits).test("0" + bufferStr + "0");
|
|
if (isValid) {
|
|
buffer[pos] = "0";
|
|
pos++;
|
|
return { "pos": pos };
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isValid != false && !strict && chrs != opts.radixPoint) {
|
|
var newPos = opts.postFormat(buffer, pos + 1, false, opts);
|
|
return { "pos": newPos };
|
|
}
|
|
return isValid;
|
|
},
|
|
cardinality: 1,
|
|
prevalidator: null
|
|
}
|
|
},
|
|
insertMode: true,
|
|
autoUnmask: false
|
|
},
|
|
'non-negative-decimal': {
|
|
regex: {
|
|
number: function (groupSeparator, groupSize, radixPoint, digits) {
|
|
var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, groupSeparator);
|
|
var escapedRadixPoint = $.inputmask.escapeRegex.call(this, radixPoint);
|
|
var digitExpression = isNaN(digits) ? digits : '{0,' + digits + '}'
|
|
return new RegExp("^[\+]?(\\d+|\\d{1," + groupSize + "}((" + escapedGroupSeparator + "\\d{" + groupSize + "})?)+)(" + escapedRadixPoint + "\\d" + digitExpression + ")?$");
|
|
}
|
|
},
|
|
alias: "decimal"
|
|
},
|
|
'integer': {
|
|
regex: {
|
|
number: function (groupSeparator, groupSize) {
|
|
var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, groupSeparator);
|
|
return new RegExp("^[\+-]?(\\d+|\\d{1," + groupSize + "}((" + escapedGroupSeparator + "\\d{" + groupSize + "})?)+)$");
|
|
}
|
|
},
|
|
alias: "decimal"
|
|
}
|
|
});
|
|
})(jQuery);
|