218 lines
12 KiB
JavaScript
218 lines
12 KiB
JavaScript
|
/*
|
||
|
|
Input Mask plugin extensions
|
||
|
|
http://github.com/RobinHerbots/jquery.inputmask
|
||
|
|
Copyright (c) 2010 - Robin Herbots
|
||
|
|
Licensed under the MIT license (http://www.opensource.org/licenses/mit-license.php)
|
||
|
|
Version: 0.0.0-dev
|
||
|
|
|
||
|
|
Regex extensions on the jquery.inputmask base
|
||
|
|
Allows for using regular expressions as a mask
|
||
|
|
|
||
|
|
This file is only for legacy support
|
||
|
|
*/
|
||
|
|
(function (factory) {
|
||
|
|
if (typeof define === "function" && define.amd) {
|
||
|
|
define(["./dependencyLibs/inputmask.dependencyLib", "./inputmask"], factory);
|
||
|
|
} else if (typeof exports === "object") {
|
||
|
|
module.exports = factory(require("./dependencyLibs/inputmask.dependencyLib"), require("./inputmask"));
|
||
|
|
} else {
|
||
|
|
factory(window.dependencyLib || jQuery, window.Inputmask);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
(function ($, Inputmask) {
|
||
|
|
Inputmask.extendAliases({ // $(selector).inputmask("Regex", { regex: "[0-9]*"}
|
||
|
|
"Regex": {
|
||
|
|
mask: "r",
|
||
|
|
greedy: false,
|
||
|
|
repeat: "*",
|
||
|
|
regex: null,
|
||
|
|
regexTokens: null,
|
||
|
|
//Thx to https://github.com/slevithan/regex-colorizer for the tokenizer regex
|
||
|
|
tokenizer: /\[\^?]?(?:[^\\\]]+|\\[\S\s]?)*]?|\\(?:0(?:[0-3][0-7]{0,2}|[4-7][0-7]?)?|[1-9][0-9]*|x[0-9A-Fa-f]{2}|u[0-9A-Fa-f]{4}|c[A-Za-z]|[\S\s]?)|\((?:\?[:=!]?)?|(?:[?*+]|\{[0-9]+(?:,[0-9]*)?\})\??|[^.?*+^${[()|\\]+|./g,
|
||
|
|
quantifierFilter: /[0-9]+[^,]/,
|
||
|
|
isComplete: function (buffer, opts) {
|
||
|
|
return new RegExp(opts.regex, opts.casing ? "i" : "").test(buffer.join(""));
|
||
|
|
},
|
||
|
|
definitions: {
|
||
|
|
"r": {
|
||
|
|
validator: function (chrs, maskset, pos, strict, opts) {
|
||
|
|
var cbuffer = maskset.buffer.slice(),
|
||
|
|
bufferStr,
|
||
|
|
regexPart = "",
|
||
|
|
isValid = false,
|
||
|
|
openGroupCount = 0,
|
||
|
|
groupToken;
|
||
|
|
|
||
|
|
function RegexToken(isGroup, isQuantifier) {
|
||
|
|
this.matches = [];
|
||
|
|
this.isGroup = isGroup || false;
|
||
|
|
this.isQuantifier = isQuantifier || false;
|
||
|
|
this.quantifier = {
|
||
|
|
min: 1,
|
||
|
|
max: 1
|
||
|
|
};
|
||
|
|
this.repeaterPart = undefined;
|
||
|
|
}
|
||
|
|
|
||
|
|
function analyseRegex() {
|
||
|
|
var currentToken = new RegexToken(),
|
||
|
|
match, m, opengroups = [];
|
||
|
|
|
||
|
|
opts.regexTokens = [];
|
||
|
|
|
||
|
|
// The tokenizer regex does most of the tokenization grunt work
|
||
|
|
while (match = opts.tokenizer.exec(opts.regex)) {
|
||
|
|
m = match[0];
|
||
|
|
switch (m.charAt(0)) {
|
||
|
|
case "(": // Group opening
|
||
|
|
opengroups.push(new RegexToken(true));
|
||
|
|
break;
|
||
|
|
case ")": // Group closing
|
||
|
|
groupToken = opengroups.pop();
|
||
|
|
if (opengroups.length > 0) {
|
||
|
|
opengroups[opengroups.length - 1].matches.push(groupToken);
|
||
|
|
} else {
|
||
|
|
currentToken.matches.push(groupToken);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
case "{":
|
||
|
|
case "+":
|
||
|
|
case "*": //Quantifier
|
||
|
|
var quantifierToken = new RegexToken(false, true);
|
||
|
|
m = m.replace(/[{}]/g, "");
|
||
|
|
var mq = m.split(","),
|
||
|
|
mq0 = isNaN(mq[0]) ? mq[0] : parseInt(mq[0]),
|
||
|
|
mq1 = mq.length === 1 ? mq0 : (isNaN(mq[1]) ? mq[1] : parseInt(mq[1]));
|
||
|
|
quantifierToken.quantifier = {
|
||
|
|
min: mq0,
|
||
|
|
max: mq1
|
||
|
|
};
|
||
|
|
if (opengroups.length > 0) {
|
||
|
|
var matches = opengroups[opengroups.length - 1].matches;
|
||
|
|
match = matches.pop();
|
||
|
|
if (!match.isGroup) {
|
||
|
|
groupToken = new RegexToken(true);
|
||
|
|
groupToken.matches.push(match);
|
||
|
|
match = groupToken;
|
||
|
|
}
|
||
|
|
matches.push(match);
|
||
|
|
matches.push(quantifierToken);
|
||
|
|
} else {
|
||
|
|
match = currentToken.matches.pop();
|
||
|
|
if (!match.isGroup) {
|
||
|
|
groupToken = new RegexToken(true);
|
||
|
|
groupToken.matches.push(match);
|
||
|
|
match = groupToken;
|
||
|
|
}
|
||
|
|
currentToken.matches.push(match);
|
||
|
|
currentToken.matches.push(quantifierToken);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
if (opengroups.length > 0) {
|
||
|
|
opengroups[opengroups.length - 1].matches.push(m);
|
||
|
|
} else {
|
||
|
|
currentToken.matches.push(m);
|
||
|
|
}
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (currentToken.matches.length > 0) {
|
||
|
|
opts.regexTokens.push(currentToken);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function validateRegexToken(token, fromGroup) {
|
||
|
|
var isvalid = false;
|
||
|
|
if (fromGroup) {
|
||
|
|
regexPart += "(";
|
||
|
|
openGroupCount++;
|
||
|
|
}
|
||
|
|
for (var mndx = 0; mndx < token.matches.length; mndx++) {
|
||
|
|
var matchToken = token.matches[mndx];
|
||
|
|
if (matchToken.isGroup === true) {
|
||
|
|
isvalid = validateRegexToken(matchToken, true);
|
||
|
|
} else if (matchToken.isQuantifier === true) {
|
||
|
|
var crrntndx = $.inArray(matchToken, token.matches),
|
||
|
|
matchGroup = token.matches[crrntndx - 1];
|
||
|
|
var regexPartBak = regexPart;
|
||
|
|
if (isNaN(matchToken.quantifier.max)) {
|
||
|
|
while (matchToken.repeaterPart && matchToken.repeaterPart !== regexPart && matchToken.repeaterPart.length > regexPart.length) {
|
||
|
|
isvalid = validateRegexToken(matchGroup, true);
|
||
|
|
if (isvalid) break;
|
||
|
|
}
|
||
|
|
isvalid = isvalid || validateRegexToken(matchGroup, true);
|
||
|
|
if (isvalid) matchToken.repeaterPart = regexPart;
|
||
|
|
regexPart = regexPartBak + matchToken.quantifier.max;
|
||
|
|
} else {
|
||
|
|
for (var i = 0, qm = matchToken.quantifier.max - 1; i < qm; i++) {
|
||
|
|
isvalid = validateRegexToken(matchGroup, true);
|
||
|
|
if (isvalid) break;
|
||
|
|
}
|
||
|
|
regexPart = regexPartBak + "{" + matchToken.quantifier.min + "," + matchToken.quantifier.max + "}";
|
||
|
|
}
|
||
|
|
} else if (matchToken.matches !== undefined) {
|
||
|
|
for (var k = 0; k < matchToken.length; k++) {
|
||
|
|
isvalid = validateRegexToken(matchToken[k], fromGroup);
|
||
|
|
if (isvalid) break;
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
var testExp;
|
||
|
|
if (matchToken.charAt(0) == "[") {
|
||
|
|
testExp = regexPart;
|
||
|
|
testExp += matchToken;
|
||
|
|
for (var j = 0; j < openGroupCount; j++) {
|
||
|
|
testExp += ")";
|
||
|
|
}
|
||
|
|
var exp = new RegExp("^(" + testExp + ")$", opts.casing ? "i" : "");
|
||
|
|
isvalid = exp.test(bufferStr);
|
||
|
|
} else {
|
||
|
|
for (var l = 0, tl = matchToken.length; l < tl; l++) {
|
||
|
|
if (matchToken.charAt(l) === "\\") continue;
|
||
|
|
testExp = regexPart;
|
||
|
|
testExp += matchToken.substr(0, l + 1);
|
||
|
|
testExp = testExp.replace(/\|$/, "");
|
||
|
|
for (var j = 0; j < openGroupCount; j++) {
|
||
|
|
testExp += ")";
|
||
|
|
}
|
||
|
|
var exp = new RegExp("^(" + testExp + ")$", opts.casing ? "i" : "");
|
||
|
|
isvalid = exp.test(bufferStr);
|
||
|
|
if (isvalid) break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
regexPart += matchToken;
|
||
|
|
}
|
||
|
|
if (isvalid) break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (fromGroup) {
|
||
|
|
regexPart += ")";
|
||
|
|
openGroupCount--;
|
||
|
|
}
|
||
|
|
|
||
|
|
return isvalid;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (opts.regexTokens === null) {
|
||
|
|
analyseRegex();
|
||
|
|
}
|
||
|
|
|
||
|
|
cbuffer.splice(pos, 0, chrs);
|
||
|
|
bufferStr = cbuffer.join("");
|
||
|
|
for (var i = 0; i < opts.regexTokens.length; i++) {
|
||
|
|
var regexToken = opts.regexTokens[i];
|
||
|
|
isValid = validateRegexToken(regexToken, regexToken.isGroup);
|
||
|
|
if (isValid) break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return isValid;
|
||
|
|
},
|
||
|
|
cardinality: 1
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return Inputmask;
|
||
|
|
}));
|