mirror of
https://github.com/DanielnetoDotCom/YouPHPTube
synced 2025-10-04 02:09:22 +02:00
add inputmask
This commit is contained in:
DanieL
parent
ab84f1e730
commit
e07838c6c7
203 changed files with 29712 additions and 5216 deletions
664
node_modules/inputmask/lib/validation.js
generated
vendored
Normal file
664
node_modules/inputmask/lib/validation.js
generated
vendored
Normal file
|
|
@ -0,0 +1,664 @@
|
|||
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;
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue