mirror of
https://github.com/DanielnetoDotCom/YouPHPTube
synced 2025-10-03 09:49:28 +02:00
664 lines
24 KiB
JavaScript
664 lines
24 KiB
JavaScript
import {
|
|
determineTestTemplate,
|
|
getDecisionTaker,
|
|
getPlaceholder,
|
|
getTest,
|
|
getTests,
|
|
getTestTemplate
|
|
} from "./validation-tests";
|
|
import keyCode from "./keycode.json";
|
|
import {
|
|
determineLastRequiredPosition, determineNewCaretPosition,
|
|
getBuffer,
|
|
getLastValidPosition,
|
|
isMask,
|
|
resetMaskSet,
|
|
seekNext,
|
|
seekPrevious
|
|
} from "./positioning";
|
|
import { EventHandlers } from "./eventhandlers";
|
|
|
|
export { alternate, checkAlternationMatch, isComplete, isSelection, isValid, refreshFromBuffer, revalidateMask, handleRemove };
|
|
|
|
//tobe put on prototype?
|
|
function alternate(maskPos, c, strict, fromIsValid, rAltPos, selection) { //pos == true => generalize
|
|
const inputmask = this,
|
|
$ = this.dependencyLib,
|
|
opts = this.opts,
|
|
maskset = inputmask.maskset;
|
|
|
|
var validPsClone = $.extend(true, {}, maskset.validPositions),
|
|
tstClone = $.extend(true, {}, maskset.tests),
|
|
lastAlt,
|
|
alternation,
|
|
isValidRslt = false, returnRslt = false,
|
|
altPos, prevAltPos, i, validPos,
|
|
decisionPos,
|
|
lAltPos = rAltPos !== undefined ? rAltPos : getLastValidPosition.call(inputmask), nextPos, input, begin, end;
|
|
|
|
if (selection) {
|
|
begin = selection.begin;
|
|
end = selection.end;
|
|
if (selection.begin > selection.end) {
|
|
begin = selection.end;
|
|
end = selection.begin;
|
|
}
|
|
}
|
|
if (lAltPos === -1 && rAltPos === undefined) { //do not recurse when already paste the beginning
|
|
lastAlt = 0;
|
|
prevAltPos = getTest.call(inputmask, lastAlt);
|
|
alternation = prevAltPos.alternation;
|
|
} else {
|
|
//find last modified alternation
|
|
for (; lAltPos >= 0; lAltPos--) {
|
|
altPos = maskset.validPositions[lAltPos];
|
|
if (altPos && altPos.alternation !== undefined) {
|
|
if (prevAltPos && prevAltPos.locator[altPos.alternation] !== altPos.locator[altPos.alternation]) {
|
|
break;
|
|
}
|
|
lastAlt = lAltPos;
|
|
alternation = maskset.validPositions[lastAlt].alternation;
|
|
prevAltPos = altPos;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (alternation !== undefined) {
|
|
decisionPos = parseInt(lastAlt);
|
|
maskset.excludes[decisionPos] = maskset.excludes[decisionPos] || [];
|
|
if (maskPos !== true) { //generalize
|
|
maskset.excludes[decisionPos].push(getDecisionTaker(prevAltPos) + ":" + prevAltPos.alternation);
|
|
}
|
|
|
|
var validInputs = [], resultPos = -1;
|
|
for (i = decisionPos; i < getLastValidPosition.call(inputmask, undefined, true) + 1; i++) {
|
|
if (resultPos === -1 && maskPos <= i && c !== undefined) {
|
|
validInputs.push(c);
|
|
resultPos = validInputs.length - 1;
|
|
}
|
|
validPos = maskset.validPositions[i];
|
|
if (validPos && validPos.generatedInput !== true && (selection === undefined || (i < begin || i >= end))) {
|
|
validInputs.push(validPos.input);
|
|
}
|
|
delete maskset.validPositions[i];
|
|
}
|
|
if (resultPos === -1 && c !== undefined) {
|
|
validInputs.push(c);
|
|
resultPos = validInputs.length - 1;
|
|
}
|
|
|
|
while (maskset.excludes[decisionPos] !== undefined && maskset.excludes[decisionPos].length < 10) {
|
|
// maskset.tests[decisionPos] = undefined; //clear decisionPos
|
|
maskset.tests = {}; //clear all
|
|
resetMaskSet.call(inputmask, true); //clear getbuffer
|
|
isValidRslt = true;
|
|
for (i = 0; i < validInputs.length; i++) {
|
|
nextPos = isValidRslt.caret || (getLastValidPosition.call(inputmask, undefined, true) + 1);
|
|
input = validInputs[i];
|
|
// nextPos = translatePosition.call(inputmask, nextPos);
|
|
if (!(isValidRslt = isValid.call(inputmask, nextPos, input, false, fromIsValid, true))) {
|
|
break;
|
|
}
|
|
if (i === resultPos) {
|
|
returnRslt = isValidRslt;
|
|
}
|
|
if (maskPos == true && isValidRslt) { //return validposition on generalise
|
|
returnRslt = { caretPos: i };
|
|
}
|
|
}
|
|
if (!isValidRslt) {
|
|
resetMaskSet.call(inputmask);
|
|
prevAltPos = getTest.call(inputmask, decisionPos); //get the current decisionPos to exclude ~ needs to be before restoring the initial validation
|
|
//reset & revert
|
|
maskset.validPositions = $.extend(true, {}, validPsClone);
|
|
maskset.tests = $.extend(true, {}, tstClone); //refresh tests after possible alternating
|
|
if (maskset.excludes[decisionPos]) {
|
|
var decisionTaker = getDecisionTaker(prevAltPos);
|
|
if (maskset.excludes[decisionPos].indexOf(decisionTaker + ":" + prevAltPos.alternation) !== -1) {
|
|
returnRslt = alternate.call(inputmask, maskPos, c, strict, fromIsValid, decisionPos - 1, selection);
|
|
break;
|
|
}
|
|
maskset.excludes[decisionPos].push(decisionTaker + ":" + prevAltPos.alternation);
|
|
for (i = decisionPos; i < getLastValidPosition.call(inputmask, undefined, true) + 1; i++) delete maskset.validPositions[i];
|
|
} else { //latest alternation
|
|
returnRslt = alternate.call(inputmask, maskPos, c, strict, fromIsValid, decisionPos - 1, selection);
|
|
break;
|
|
}
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
//reset alternation excludes
|
|
if (!returnRslt || opts.keepStatic !== false) {
|
|
delete maskset.excludes[decisionPos];
|
|
}
|
|
return returnRslt;
|
|
}
|
|
|
|
function casing(elem, test, pos) {
|
|
const opts = this.opts,
|
|
maskset = this.maskset;
|
|
|
|
switch (opts.casing || test.casing) {
|
|
case "upper":
|
|
elem = elem.toUpperCase();
|
|
break;
|
|
case "lower":
|
|
elem = elem.toLowerCase();
|
|
break;
|
|
case "title":
|
|
var posBefore = maskset.validPositions[pos - 1];
|
|
if (pos === 0 || posBefore && posBefore.input === String.fromCharCode(keyCode.SPACE)) {
|
|
elem = elem.toUpperCase();
|
|
} else {
|
|
elem = elem.toLowerCase();
|
|
}
|
|
break;
|
|
default:
|
|
if (typeof opts.casing === "function") {
|
|
var args = Array.prototype.slice.call(arguments);
|
|
args.push(maskset.validPositions);
|
|
elem = opts.casing.apply(this, args);
|
|
}
|
|
}
|
|
|
|
return elem;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function checkAlternationMatch(altArr1, altArr2, na) {
|
|
const opts = this.opts;
|
|
|
|
var altArrC = opts.greedy ? altArr2 : altArr2.slice(0, 1),
|
|
isMatch = false,
|
|
naArr = na !== undefined ? na.split(",") : [],
|
|
naNdx;
|
|
|
|
//remove no alternate indexes from alternation array
|
|
for (var i = 0; i < naArr.length; i++) {
|
|
if ((naNdx = altArr1.indexOf(naArr[i])) !== -1) {
|
|
altArr1.splice(naNdx, 1);
|
|
}
|
|
}
|
|
|
|
for (var alndx = 0; alndx < altArr1.length; alndx++) {
|
|
if (altArrC.includes(altArr1[alndx])) {
|
|
isMatch = true;
|
|
break;
|
|
}
|
|
}
|
|
return isMatch;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function handleRemove(input, k, pos, strict, fromIsValid) {
|
|
const inputmask = this, maskset = this.maskset, opts = this.opts;
|
|
|
|
if (opts.numericInput || inputmask.isRTL) {
|
|
if (k === keyCode.BACKSPACE) {
|
|
k = keyCode.DELETE;
|
|
} else if (k === keyCode.DELETE) {
|
|
k = keyCode.BACKSPACE;
|
|
}
|
|
|
|
if (inputmask.isRTL) {
|
|
var pend = pos.end;
|
|
pos.end = pos.begin;
|
|
pos.begin = pend;
|
|
}
|
|
}
|
|
|
|
var lvp = getLastValidPosition.call(inputmask, undefined, true);
|
|
if (pos.end >= getBuffer.call(inputmask).length && lvp >= pos.end) { //handle numeric negate symbol offset, due to dynamic jit masking
|
|
pos.end = lvp + 1;
|
|
}
|
|
|
|
if (k === keyCode.BACKSPACE) {
|
|
if ((pos.end - pos.begin < 1)) {
|
|
pos.begin = seekPrevious.call(inputmask, pos.begin);
|
|
}
|
|
} else if (k === keyCode.DELETE) {
|
|
if (pos.begin === pos.end) {
|
|
pos.end = isMask.call(inputmask, pos.end, true, true) ? pos.end + 1 : seekNext.call(inputmask, pos.end) + 1;
|
|
}
|
|
}
|
|
var offset;
|
|
if ((offset = revalidateMask.call(inputmask, pos)) !== false) {
|
|
if (strict !== true && opts.keepStatic !== false || (opts.regex !== null && getTest.call(inputmask, pos.begin).match.def.indexOf("|") !== -1)) { //TODO NEEDS BETTER CHECK WHEN TO ALTERNATE ~ opts regex isn"t good enough
|
|
var result = alternate.call(inputmask, true);
|
|
if (result) {
|
|
var newPos = result.caret !== undefined ? result.caret : (result.pos ? seekNext.call(inputmask, result.pos.begin ? result.pos.begin : result.pos) : getLastValidPosition.call(inputmask, -1, true));
|
|
if (k !== keyCode.DELETE || pos.begin > newPos) {
|
|
pos.begin == newPos;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (strict !== true) {
|
|
maskset.p = k === keyCode.DELETE ? pos.begin + offset : pos.begin;
|
|
maskset.p = determineNewCaretPosition.call(inputmask, {
|
|
begin: maskset.p,
|
|
end: maskset.p
|
|
}, false, opts.insertMode === false && k === keyCode.BACKSPACE ? "none" : undefined).begin;
|
|
}
|
|
}
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function isComplete(buffer) { //return true / false / undefined (repeat *)
|
|
const inputmask = this, opts = this.opts, maskset = this.maskset;
|
|
|
|
if (typeof opts.isComplete === "function") return opts.isComplete(buffer, opts);
|
|
if (opts.repeat === "*") return undefined;
|
|
var complete = false,
|
|
lrp = determineLastRequiredPosition.call(inputmask, true),
|
|
aml = seekPrevious.call(inputmask, lrp.l);
|
|
|
|
if (lrp.def === undefined || lrp.def.newBlockMarker || lrp.def.optionality || lrp.def.optionalQuantifier) {
|
|
complete = true;
|
|
for (var i = 0; i <= aml; i++) {
|
|
var test = getTestTemplate.call(inputmask, i).match;
|
|
if ((test.static !== true && maskset.validPositions[i] === undefined && test.optionality !== true && test.optionalQuantifier !== true) || (test.static === true && buffer[i] !== getPlaceholder.call(inputmask, i, test))) {
|
|
complete = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return complete;
|
|
}
|
|
|
|
function isSelection(posObj) {
|
|
const inputmask = this,
|
|
opts = this.opts, insertModeOffset = opts.insertMode ? 0 : 1;
|
|
return inputmask.isRTL ? (posObj.begin - posObj.end) > insertModeOffset : (posObj.end - posObj.begin) > insertModeOffset;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function isValid(pos, c, strict, fromIsValid, fromAlternate, validateOnly, fromCheckval) { //strict true ~ no correction or autofill
|
|
const inputmask = this,
|
|
$ = this.dependencyLib,
|
|
opts = this.opts,
|
|
maskset = inputmask.maskset;
|
|
|
|
strict = strict === true; //always set a value to strict to prevent possible strange behavior in the extensions
|
|
|
|
var maskPos = pos;
|
|
if (pos.begin !== undefined) { //position was a position object - used to handle a delete by typing over a selection
|
|
maskPos = inputmask.isRTL ? pos.end : pos.begin;
|
|
}
|
|
|
|
function processCommandObject(commandObj) {
|
|
if (commandObj !== undefined) {
|
|
if (commandObj.remove !== undefined) { //remove position(s)
|
|
if (!Array.isArray(commandObj.remove)) commandObj.remove = [commandObj.remove];
|
|
commandObj.remove.sort(function (a, b) {
|
|
return b.pos - a.pos;
|
|
}).forEach(function (lmnt) {
|
|
revalidateMask.call(inputmask, { begin: lmnt, end: lmnt + 1 });
|
|
});
|
|
commandObj.remove = undefined;
|
|
}
|
|
if (commandObj.insert !== undefined) { //insert position(s)
|
|
if (!Array.isArray(commandObj.insert)) commandObj.insert = [commandObj.insert];
|
|
commandObj.insert.sort(function (a, b) {
|
|
return a.pos - b.pos;
|
|
}).forEach(function (lmnt) {
|
|
if (lmnt.c !== "") {
|
|
isValid.call(inputmask, lmnt.pos, lmnt.c, lmnt.strict !== undefined ? lmnt.strict : true, lmnt.fromIsValid !== undefined ? lmnt.fromIsValid : fromIsValid);
|
|
}
|
|
});
|
|
commandObj.insert = undefined;
|
|
}
|
|
|
|
if (commandObj.refreshFromBuffer && commandObj.buffer) {
|
|
var refresh = commandObj.refreshFromBuffer;
|
|
refreshFromBuffer.call(inputmask, refresh === true ? refresh : refresh.start, refresh.end, commandObj.buffer);
|
|
commandObj.refreshFromBuffer = undefined;
|
|
}
|
|
|
|
if (commandObj.rewritePosition !== undefined) {
|
|
maskPos = commandObj.rewritePosition;
|
|
// commandObj.rewritePosition = undefined;
|
|
commandObj = true;
|
|
}
|
|
}
|
|
return commandObj;
|
|
}
|
|
|
|
function _isValid(position, c, strict) {
|
|
var rslt = false;
|
|
getTests.call(inputmask, position).every(function (tst, ndx) {
|
|
var test = tst.match;
|
|
//make sure the buffer is set and correct
|
|
getBuffer.call(inputmask, true);
|
|
if (test.jit && maskset.validPositions[seekPrevious.call(inputmask, position)] === undefined) //ignore if jit is not desirable
|
|
{
|
|
rslt = false;
|
|
} else {
|
|
//return is false or a json object => { pos: ??, c: ??} or true
|
|
rslt = test.fn != null ?
|
|
test.fn.test(c, maskset, position, strict, opts, isSelection.call(inputmask, pos)) : (c === test.def || c === opts.skipOptionalPartCharacter) && test.def !== "" ? //non mask
|
|
{
|
|
c: getPlaceholder.call(inputmask, position, test, true) || test.def,
|
|
pos: position
|
|
} : false;
|
|
}
|
|
if (rslt !== false) {
|
|
var elem = rslt.c !== undefined ? rslt.c : c, validatedPos = position;
|
|
elem = (elem === opts.skipOptionalPartCharacter && test.static === true) ?
|
|
(getPlaceholder.call(inputmask, position, test, true) || test.def) : elem;
|
|
|
|
rslt = processCommandObject(rslt);
|
|
|
|
if (rslt !== true && rslt.pos !== undefined && rslt.pos !== position) { //their is a position offset
|
|
validatedPos = rslt.pos;
|
|
}
|
|
|
|
if (rslt !== true && rslt.pos === undefined && rslt.c === undefined) {
|
|
return false; //breakout if nothing to insert
|
|
}
|
|
|
|
if (revalidateMask.call(inputmask, pos, $.extend({}, tst, {
|
|
"input": casing.call(inputmask, elem, test, validatedPos)
|
|
}), fromIsValid, validatedPos) === false) {
|
|
rslt = false;
|
|
}
|
|
return false; //break from loop
|
|
}
|
|
|
|
return true;
|
|
});
|
|
return rslt;
|
|
}
|
|
|
|
var result = true,
|
|
positionsClone = $.extend(true, {}, maskset.validPositions); //clone the currentPositions
|
|
|
|
if (opts.keepStatic === false && maskset.excludes[maskPos] !== undefined && fromAlternate !== true && fromIsValid !== true) {
|
|
for (var i = maskPos; i < (inputmask.isRTL ? pos.begin : pos.end); i++) {
|
|
if (maskset.excludes[i] !== undefined) {
|
|
maskset.excludes[i] = undefined;
|
|
delete maskset.tests[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
if (typeof opts.preValidation === "function" && fromIsValid !== true && validateOnly !== true) {
|
|
result = opts.preValidation.call(inputmask, getBuffer.call(inputmask), maskPos, c, isSelection.call(inputmask, pos), opts, maskset, pos, strict || fromAlternate);
|
|
result = processCommandObject(result);
|
|
}
|
|
if (result === true) { //preValidation result
|
|
result = _isValid(maskPos, c, strict);
|
|
if ((!strict || fromIsValid === true) && result === false && validateOnly !== true) {
|
|
var currentPosValid = maskset.validPositions[maskPos];
|
|
if (currentPosValid && currentPosValid.match.static === true && (currentPosValid.match.def === c || c === opts.skipOptionalPartCharacter)) {
|
|
result = {
|
|
"caret": seekNext.call(inputmask, maskPos)
|
|
};
|
|
} else {
|
|
if (opts.insertMode || maskset.validPositions[seekNext.call(inputmask, maskPos)] === undefined || pos.end > maskPos) { //does the input match on a further position?
|
|
var skip = false;
|
|
if (maskset.jitOffset[maskPos] && maskset.validPositions[seekNext.call(inputmask, maskPos)] === undefined) {
|
|
result = isValid.call(inputmask, maskPos + maskset.jitOffset[maskPos], c, true, true);
|
|
if (result !== false) {
|
|
if (fromAlternate !== true) result.caret = maskPos;
|
|
skip = true;
|
|
}
|
|
}
|
|
if (pos.end > maskPos) {
|
|
maskset.validPositions[maskPos] = undefined;
|
|
}
|
|
if (!skip && !isMask.call(inputmask, maskPos, opts.keepStatic && maskPos === 0)) {
|
|
for (var nPos = maskPos + 1, snPos = seekNext.call(inputmask, maskPos, false, maskPos !== 0); nPos <= snPos; nPos++) {
|
|
// if (!isMask(nPos, true)) {
|
|
// continue;
|
|
// }
|
|
result = _isValid(nPos, c, strict);
|
|
if (result !== false) {
|
|
result = trackbackPositions.call(inputmask, maskPos, result.pos !== undefined ? result.pos : nPos) || result;
|
|
maskPos = nPos;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (result === false && opts.keepStatic && (isComplete.call(inputmask, getBuffer.call(inputmask)) || maskPos === 0) && !strict && fromAlternate !== true) { //try fuzzy alternator logic
|
|
result = alternate.call(inputmask, maskPos, c, strict, fromIsValid, undefined, pos);
|
|
} else if (isSelection.call(inputmask, pos) && maskset.tests[maskPos] && maskset.tests[maskPos].length > 1 && opts.keepStatic && !strict && fromAlternate !== true) { //selection clears an alternated keepstatic mask ~ #2189
|
|
result = alternate.call(inputmask, true);
|
|
}
|
|
|
|
if (result === true) {
|
|
result = {
|
|
"pos": maskPos
|
|
};
|
|
}
|
|
}
|
|
if (typeof opts.postValidation === "function" && fromIsValid !== true && validateOnly !== true) {
|
|
var postResult = opts.postValidation.call(inputmask, getBuffer.call(inputmask, true), pos.begin !== undefined ? (inputmask.isRTL ? pos.end : pos.begin) : pos, c, result, opts, maskset, strict, fromCheckval);
|
|
if (postResult !== undefined) {
|
|
result = postResult === true ? result : postResult;
|
|
}
|
|
}
|
|
|
|
if (result && result.pos === undefined) {
|
|
result.pos = maskPos;
|
|
}
|
|
|
|
if (result === false || validateOnly === true) {
|
|
resetMaskSet.call(inputmask, true);
|
|
maskset.validPositions = $.extend(true, {}, positionsClone); //revert validation changes
|
|
} else {
|
|
trackbackPositions.call(inputmask, undefined, maskPos, true);
|
|
}
|
|
|
|
var endResult = processCommandObject(result);
|
|
// console.log("returned result " + JSON.stringify(endResult));
|
|
if (inputmask.maxLength !== undefined) {
|
|
var buffer = getBuffer.call(inputmask);
|
|
if (buffer.length > inputmask.maxLength && !fromIsValid) {
|
|
resetMaskSet.call(inputmask, true);
|
|
maskset.validPositions = $.extend(true, {}, positionsClone); //revert validation changes
|
|
endResult = false;
|
|
}
|
|
}
|
|
return endResult;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function positionCanMatchDefinition(pos, testDefinition, opts) {
|
|
const inputmask = this,
|
|
maskset = this.maskset;
|
|
|
|
var valid = false,
|
|
tests = getTests.call(inputmask, pos);
|
|
for (var tndx = 0; tndx < tests.length; tndx++) {
|
|
if (tests[tndx].match &&
|
|
((tests[tndx].match["nativeDef"] === testDefinition.match[opts.shiftPositions ? "def" : "nativeDef"] && (!opts.shiftPositions || !testDefinition.match.static)) ||
|
|
tests[tndx].match["nativeDef"] === testDefinition.match["nativeDef"] || (opts.regex && !tests[tndx].match.static && tests[tndx].match.fn.test(testDefinition.input)))) {
|
|
valid = true;
|
|
break;
|
|
} else if (tests[tndx].match && tests[tndx].match["def"] === testDefinition.match["nativeDef"]) {
|
|
valid = undefined;
|
|
break;
|
|
}
|
|
}
|
|
if (valid === false) {
|
|
if (maskset.jitOffset[pos] !== undefined) {
|
|
valid = positionCanMatchDefinition.call(inputmask, pos + maskset.jitOffset[pos], testDefinition, opts);
|
|
}
|
|
}
|
|
return valid;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function refreshFromBuffer(start, end, buffer) {
|
|
const inputmask = this,
|
|
maskset = this.maskset,
|
|
opts = this.opts,
|
|
$ = this.dependencyLib;
|
|
// checkVal.call(inputmask, el, false, true, isRTL ? buffer.reverse() : buffer);
|
|
var i, p, skipOptionalPartCharacter = opts.skipOptionalPartCharacter,
|
|
bffr = inputmask.isRTL ? buffer.slice().reverse() : buffer;
|
|
opts.skipOptionalPartCharacter = "";
|
|
if (start === true) {
|
|
resetMaskSet.call(inputmask);
|
|
maskset.tests = {}; //refresh tests after possible alternating
|
|
start = 0;
|
|
end = buffer.length;
|
|
p = determineNewCaretPosition.call(inputmask, { begin: 0, end: 0 }, false).begin;
|
|
} else {
|
|
for (i = start; i < end; i++) {
|
|
delete maskset.validPositions[i];
|
|
}
|
|
p = start;
|
|
}
|
|
|
|
var keypress = new $.Event("keypress");
|
|
for (i = start; i < end; i++) {
|
|
keypress.keyCode = bffr[i].toString().charCodeAt(0);
|
|
inputmask.ignorable = false; //make sure ignorable is ignored ;-)
|
|
var valResult = EventHandlers.keypressEvent.call(inputmask, keypress, true, false, false, p);
|
|
if (valResult !== false && valResult !== undefined) {
|
|
p = valResult.forwardPosition;
|
|
}
|
|
}
|
|
|
|
opts.skipOptionalPartCharacter = skipOptionalPartCharacter;
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
//fill in best positions according the current input
|
|
function trackbackPositions(originalPos, newPos, fillOnly) {
|
|
const inputmask = this,
|
|
maskset = this.maskset,
|
|
$ = this.dependencyLib;
|
|
|
|
// console.log("trackbackPositions " + originalPos + " " + newPos);
|
|
if (originalPos === undefined) {
|
|
//find previous valid
|
|
for (originalPos = newPos - 1; originalPos > 0; originalPos--) {
|
|
if (maskset.validPositions[originalPos]) break;
|
|
}
|
|
}
|
|
for (var ps = originalPos; ps < newPos; ps++) {
|
|
if (maskset.validPositions[ps] === undefined && !isMask.call(inputmask, ps, false)) {
|
|
var vp = ps == 0 ? getTest.call(inputmask, ps) : maskset.validPositions[ps - 1];
|
|
if (vp) {
|
|
var tests = getTests.call(inputmask, ps).slice();
|
|
if (tests[tests.length - 1].match.def === "") tests.pop();
|
|
var bestMatch = determineTestTemplate.call(inputmask, ps, tests), np;
|
|
if (bestMatch && (bestMatch.match.jit !== true || (bestMatch.match.newBlockMarker === "master" && (np = maskset.validPositions[ps + 1]) && np.match.optionalQuantifier === true))) {
|
|
bestMatch = $.extend({}, bestMatch, {
|
|
"input": getPlaceholder.call(inputmask, ps, bestMatch.match, true) || bestMatch.match.def
|
|
});
|
|
bestMatch.generatedInput = true;
|
|
revalidateMask.call(inputmask, ps, bestMatch, true);
|
|
|
|
if (fillOnly !== true) {
|
|
//revalidate the new position to update the locator value
|
|
var cvpInput = maskset.validPositions[newPos].input;
|
|
maskset.validPositions[newPos] = undefined;
|
|
return isValid.call(inputmask, newPos, cvpInput, true, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//tobe put on prototype?
|
|
function revalidateMask(pos, validTest, fromIsValid, validatedPos) {
|
|
const inputmask = this,
|
|
maskset = this.maskset,
|
|
opts = this.opts,
|
|
$ = this.dependencyLib;
|
|
|
|
function IsEnclosedStatic(pos, valids, selection) {
|
|
var posMatch = valids[pos];
|
|
if (posMatch !== undefined && posMatch.match.static === true && posMatch.match.optionality !== true && (valids[0] === undefined || valids[0].alternation === undefined)) {
|
|
var prevMatch = selection.begin <= pos - 1 ? valids[pos - 1] && valids[pos - 1].match.static === true && valids[pos - 1] : valids[pos - 1],
|
|
nextMatch = selection.end > pos + 1 ? valids[pos + 1] && valids[pos + 1].match.static === true && valids[pos + 1] : valids[pos + 1];
|
|
return prevMatch && nextMatch;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
var offset = 0, begin = pos.begin !== undefined ? pos.begin : pos, end = pos.end !== undefined ? pos.end : pos,
|
|
valid = true;
|
|
if (pos.begin > pos.end) {
|
|
begin = pos.end;
|
|
end = pos.begin;
|
|
}
|
|
|
|
validatedPos = validatedPos !== undefined ? validatedPos : begin;
|
|
if (begin !== end || (opts.insertMode && maskset.validPositions[validatedPos] !== undefined && fromIsValid === undefined) || validTest === undefined || validTest.match.optionalQuantifier || validTest.match.optionality) {
|
|
//reposition & revalidate others
|
|
var positionsClone = $.extend(true, {}, maskset.validPositions),
|
|
lvp = getLastValidPosition.call(inputmask, undefined, true),
|
|
i;
|
|
maskset.p = begin; //needed for alternated position after overtype selection
|
|
|
|
for (i = lvp; i >= begin; i--) {
|
|
delete maskset.validPositions[i];
|
|
if (validTest === undefined) delete maskset.tests[i + 1];
|
|
}
|
|
|
|
var j = validatedPos,
|
|
posMatch = j, t, canMatch, test;
|
|
|
|
if (validTest) {
|
|
maskset.validPositions[validatedPos] = $.extend(true, {}, validTest);
|
|
posMatch++;
|
|
j++;
|
|
}
|
|
|
|
for (i = validTest ? end : end - 1; i <= lvp; i++) {
|
|
if ((t = positionsClone[i]) !== undefined && t.generatedInput !== true &&
|
|
(i >= end || (i >= begin && IsEnclosedStatic(i, positionsClone, {
|
|
begin: begin,
|
|
end: end
|
|
})))) {
|
|
while (test = getTest.call(inputmask, posMatch), test.match.def !== "") { //loop needed to match further positions
|
|
if ((canMatch = positionCanMatchDefinition.call(inputmask, posMatch, t, opts)) !== false || t.match.def === "+") { //validated match //we still need some hackery for the + validator (numeric alias)
|
|
if (t.match.def === "+") getBuffer.call(inputmask, true);
|
|
var result = isValid.call(inputmask, posMatch, t.input, t.match.def !== "+", /*t.match.def !== "+"*/ true);
|
|
valid = result !== false;
|
|
j = (result.pos || posMatch) + 1;
|
|
if (!valid && canMatch) break;
|
|
} else {
|
|
valid = false;
|
|
}
|
|
if (valid) {
|
|
if (validTest === undefined && t.match.static && i === pos.begin) offset++;
|
|
break;
|
|
}
|
|
if (!valid && getBuffer.call(inputmask), posMatch > maskset.maskLength) {
|
|
break;
|
|
}
|
|
posMatch++;
|
|
}
|
|
if (getTest.call(inputmask, posMatch).match.def == "") {
|
|
valid = false;
|
|
}
|
|
//restore position
|
|
posMatch = j;
|
|
}
|
|
if (!valid) break;
|
|
}
|
|
if (!valid) {
|
|
maskset.validPositions = $.extend(true, {}, positionsClone);
|
|
resetMaskSet.call(inputmask, true);
|
|
return false;
|
|
}
|
|
} else if (validTest && getTest.call(inputmask, validatedPos).match.cd === validTest.match.cd) {
|
|
maskset.validPositions[validatedPos] = $.extend(true, {}, validTest);
|
|
}
|
|
|
|
resetMaskSet.call(inputmask, true);
|
|
return offset;
|
|
}
|