mirror of
https://github.com/DanielnetoDotCom/YouPHPTube
synced 2025-10-05 19:42:38 +02:00
588 lines
26 KiB
JavaScript
588 lines
26 KiB
JavaScript
/*
|
|
Input Mask plugin extensions
|
|
http://github.com/RobinHerbots/jquery.inputmask
|
|
Copyright (c) Robin Herbots
|
|
Licensed under the MIT license
|
|
*/
|
|
import Inputmask from "../inputmask";
|
|
import keyCode from "../keycode.json";
|
|
import escapeRegex from "../escapeRegex";
|
|
import {seekNext} from "../positioning";
|
|
import {getMaskTemplate} from "../validation-tests";
|
|
|
|
const $ = Inputmask.dependencyLib;
|
|
|
|
class DateObject {
|
|
constructor(mask, format, opts) {
|
|
this.mask = mask;
|
|
this.format = format;
|
|
this.opts = opts;
|
|
this._date = new Date(1, 0, 1);
|
|
this.initDateObject(mask, this.opts);
|
|
}
|
|
|
|
get date() {
|
|
if (this._date === undefined) {
|
|
this._date = new Date(1, 0, 1);
|
|
this.initDateObject(undefined, this.opts);
|
|
}
|
|
return this._date;
|
|
}
|
|
|
|
initDateObject(mask, opts) {
|
|
let match;
|
|
getTokenizer(opts).lastIndex = 0;
|
|
while ((match = getTokenizer(opts).exec(this.format))) {
|
|
let dynMatches = new RegExp("\\d+$").exec(match[0]),
|
|
fcode = dynMatches ? (match[0][0] + "x") : match[0],
|
|
value;
|
|
if (mask !== undefined) {
|
|
if (dynMatches) {
|
|
let lastIndex = getTokenizer(opts).lastIndex,
|
|
tokanMatch = getTokenMatch(match.index, opts);
|
|
getTokenizer(opts).lastIndex = lastIndex;
|
|
value = mask.slice(0, mask.indexOf(tokanMatch.nextMatch[0]));
|
|
} else {
|
|
value = mask.slice(0, fcode.length);
|
|
}
|
|
mask = mask.slice(value.length);
|
|
}
|
|
|
|
if (Object.prototype.hasOwnProperty.call(formatCode, fcode)) {
|
|
this.setValue(this, value, fcode, formatCode[fcode][2], formatCode[fcode][1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
setValue(dateObj, value, fcode, targetProp, dateOperation) {
|
|
if (value !== undefined) {
|
|
dateObj[targetProp] = targetProp === "ampm" ? value : value.replace(/[^0-9]/g, "0");
|
|
dateObj["raw" + targetProp] = value.replace(/\s/g, "_");
|
|
}
|
|
if (dateOperation !== undefined) {
|
|
let datavalue = dateObj[targetProp];
|
|
if ((targetProp === "day" && parseInt(datavalue) === 29) || (targetProp === "month" && parseInt(datavalue) === 2)) {
|
|
if (parseInt(dateObj.day) === 29 && parseInt(dateObj.month) === 2 && (dateObj.year === "" || dateObj.year === undefined)) {
|
|
//set temporary leap year in dateObj
|
|
dateObj._date.setFullYear(2012, 1, 29);
|
|
}
|
|
}
|
|
if (targetProp === "day") {
|
|
useDateObject = true;
|
|
if (parseInt(datavalue) === 0)
|
|
datavalue = 1;
|
|
}
|
|
if (targetProp === "month")
|
|
useDateObject = true;
|
|
if (targetProp === "year") {
|
|
useDateObject = true;
|
|
if (datavalue.length < 4)
|
|
datavalue = pad(datavalue, 4, true);
|
|
}
|
|
if (datavalue !== "" && !isNaN(datavalue)) dateOperation.call(dateObj._date, datavalue);
|
|
if (targetProp === "ampm")
|
|
dateOperation.call(dateObj._date, datavalue);
|
|
}
|
|
}
|
|
|
|
reset() {
|
|
this._date = new Date(1, 0, 1);
|
|
}
|
|
|
|
reInit() {
|
|
this._date = undefined;
|
|
this.date;
|
|
}
|
|
}
|
|
|
|
let currentYear = new Date().getFullYear(),
|
|
useDateObject = false,
|
|
//supported codes for formatting
|
|
//http://blog.stevenlevithan.com/archives/date-time-format
|
|
//https://docs.microsoft.com/en-us/dotnet/standard/base-types/custom-date-and-time-format-strings?view=netframework-4.7
|
|
formatCode = { //regex, valueSetter, type, displayformatter
|
|
d: ["[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", Date.prototype.getDate], //Day of the month as digits; no leading zero for single-digit days.
|
|
dd: ["0[1-9]|[12][0-9]|3[01]", Date.prototype.setDate, "day", function () {
|
|
return pad(Date.prototype.getDate.call(this), 2);
|
|
}], //Day of the month as digits; leading zero for single-digit days.
|
|
ddd: [""], //Day of the week as a three-letter abbreviation.
|
|
dddd: [""], //Day of the week as its full name.
|
|
m: ["[1-9]|1[012]", function (val) {
|
|
let mval = val ? parseInt(val) : 0;
|
|
if (mval > 0) mval--;
|
|
return Date.prototype.setMonth.call(this, mval);
|
|
}, "month", function () {
|
|
return Date.prototype.getMonth.call(this) + 1;
|
|
}], //Month as digits; no leading zero for single-digit months.
|
|
mm: ["0[1-9]|1[012]", function (val) {
|
|
let mval = val ? parseInt(val) : 0;
|
|
if (mval > 0) mval--;
|
|
return Date.prototype.setMonth.call(this, mval);
|
|
}, "month", function () {
|
|
return pad(Date.prototype.getMonth.call(this) + 1, 2);
|
|
}], //Month as digits; leading zero for single-digit months.
|
|
mmm: [""], //Month as a three-letter abbreviation.
|
|
mmmm: [""], //Month as its full name.
|
|
yy: ["[0-9]{2}", Date.prototype.setFullYear, "year", function () {
|
|
return pad(Date.prototype.getFullYear.call(this), 2);
|
|
}], //Year as last two digits; leading zero for years less than 10.
|
|
yyyy: ["[0-9]{4}", Date.prototype.setFullYear, "year", function () {
|
|
return pad(Date.prototype.getFullYear.call(this), 4);
|
|
}],
|
|
h: ["[1-9]|1[0-2]", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no leading zero for single-digit hours (12-hour clock).
|
|
hh: ["0[1-9]|1[0-2]", Date.prototype.setHours, "hours", function () {
|
|
return pad(Date.prototype.getHours.call(this), 2);
|
|
}], //Hours; leading zero for single-digit hours (12-hour clock).
|
|
hx: [function (x) {
|
|
return `[0-9]{${x}}`;
|
|
}, Date.prototype.setHours, "hours", function (x) {
|
|
return Date.prototype.getHours;
|
|
}], //Hours; no limit; set maximum digits
|
|
H: ["1?[0-9]|2[0-3]", Date.prototype.setHours, "hours", Date.prototype.getHours], //Hours; no leading zero for single-digit hours (24-hour clock).
|
|
HH: ["0[0-9]|1[0-9]|2[0-3]", Date.prototype.setHours, "hours", function () {
|
|
return pad(Date.prototype.getHours.call(this), 2);
|
|
}], //Hours; leading zero for single-digit hours (24-hour clock).
|
|
Hx: [function (x) {
|
|
return `[0-9]{${x}}`;
|
|
}, Date.prototype.setHours, "hours", function (x) {
|
|
return function () {
|
|
return pad(Date.prototype.getHours.call(this), x);
|
|
};
|
|
}], //Hours; no limit; set maximum digits
|
|
M: ["[1-5]?[0-9]", Date.prototype.setMinutes, "minutes", Date.prototype.getMinutes], //Minutes; no leading zero for single-digit minutes. Uppercase M unlike CF timeFormat's m to avoid conflict with months.
|
|
MM: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setMinutes, "minutes", function () {
|
|
return pad(Date.prototype.getMinutes.call(this), 2);
|
|
}], //Minutes; leading zero for single-digit minutes. Uppercase MM unlike CF timeFormat's mm to avoid conflict with months.
|
|
s: ["[1-5]?[0-9]", Date.prototype.setSeconds, "seconds", Date.prototype.getSeconds], //Seconds; no leading zero for single-digit seconds.
|
|
ss: ["0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]", Date.prototype.setSeconds, "seconds", function () {
|
|
return pad(Date.prototype.getSeconds.call(this), 2);
|
|
}], //Seconds; leading zero for single-digit seconds.
|
|
l: ["[0-9]{3}", Date.prototype.setMilliseconds, "milliseconds", function () {
|
|
return pad(Date.prototype.getMilliseconds.call(this), 3);
|
|
}], //Milliseconds. 3 digits.
|
|
L: ["[0-9]{2}", Date.prototype.setMilliseconds, "milliseconds", function () {
|
|
return pad(Date.prototype.getMilliseconds.call(this), 2);
|
|
}], //Milliseconds. 2 digits.
|
|
t: ["[ap]", setAMPM, "ampm", getAMPM, 1], //Lowercase, single-character time marker string: a or p.
|
|
tt: ["[ap]m", setAMPM, "ampm", getAMPM, 2], //two-character time marker string: am or pm.
|
|
T: ["[AP]", setAMPM, "ampm", getAMPM, 1], //single-character time marker string: A or P.
|
|
TT: ["[AP]M", setAMPM, "ampm", getAMPM, 2], //two-character time marker string: AM or PM.
|
|
Z: [".*", undefined, "Z", getTimeZoneAbbreviated], //US timezone abbreviation, e.g. EST or MDT. With non-US timezones or in the Opera browser, the GMT/UTC offset is returned, e.g. GMT-0500
|
|
o: [""], //GMT/UTC timezone offset, e.g. -0500 or +0230.
|
|
S: [""] //The date's ordinal suffix (st, nd, rd, or th).
|
|
},
|
|
formatAlias = {
|
|
isoDate: "yyyy-mm-dd", //2007-06-09
|
|
isoTime: "HH:MM:ss", //17:46:21
|
|
isoDateTime: "yyyy-mm-dd'T'HH:MM:ss", //2007-06-09T17:46:21
|
|
isoUtcDateTime: "UTC:yyyy-mm-dd'T'HH:MM:ss'Z'" //2007-06-09T22:46:21Z
|
|
};
|
|
|
|
function setAMPM(value) {
|
|
const hours = this.getHours();
|
|
if (value.toLowerCase().includes("p")) {
|
|
this.setHours(hours + 12);
|
|
// console.log("setAMPM + 12");
|
|
} else if (value.toLowerCase().includes("a") && hours >= 12) {
|
|
this.setHours(hours - 12);
|
|
}
|
|
}
|
|
|
|
function getAMPM() {
|
|
let date = this,
|
|
hours = date.getHours();
|
|
hours = hours || 12;
|
|
return hours >= 12 ? "PM" : "AM";
|
|
}
|
|
|
|
function getTimeZoneAbbreviated() {
|
|
//not perfect, but ok for now
|
|
let date = this, {1: tz} = date.toString().match(/\((.+)\)/);
|
|
if (tz.includes(" ")) {
|
|
tz = tz.replace("-", " ").toUpperCase();
|
|
tz = tz.split(" ").map(([first]) => first).join("");
|
|
}
|
|
return tz;
|
|
}
|
|
|
|
function formatcode(match) {
|
|
var dynMatches = new RegExp("\\d+$").exec(match[0]);
|
|
if (dynMatches && dynMatches[0] !== undefined) {
|
|
var fcode = formatCode[match[0][0] + "x"].slice("");
|
|
fcode[0] = fcode[0](dynMatches[0]);
|
|
fcode[3] = fcode[3](dynMatches[0]);
|
|
|
|
return fcode;
|
|
} else if (formatCode[match[0]]) {
|
|
return formatCode[match[0]];
|
|
}
|
|
}
|
|
|
|
function getTokenizer(opts) {
|
|
if (!opts.tokenizer) {
|
|
var tokens = [], dyntokens = [];
|
|
for (var ndx in formatCode) {
|
|
if (/\.*x$/.test(ndx)) {
|
|
var dynToken = ndx[0] + "\\d+";
|
|
if (dyntokens.indexOf(dynToken) === -1) {
|
|
dyntokens.push(dynToken);
|
|
}
|
|
} else if (tokens.indexOf(ndx[0]) === -1) {
|
|
tokens.push(ndx[0]);
|
|
}
|
|
}
|
|
opts.tokenizer = "(" + (dyntokens.length > 0 ? dyntokens.join("|") + "|" : "") + tokens.join("+|") + ")+?|.";
|
|
opts.tokenizer = new RegExp(opts.tokenizer, "g");
|
|
}
|
|
|
|
return opts.tokenizer;
|
|
}
|
|
|
|
function prefillYear(dateParts, currentResult, opts) {
|
|
if (dateParts.year !== dateParts.rawyear) {
|
|
var crrntyear = currentYear.toString(),
|
|
enteredPart = dateParts.rawyear.replace(/[^0-9]/g, ""),
|
|
currentYearPart = crrntyear.slice(0, enteredPart.length),
|
|
currentYearNextPart = crrntyear.slice(enteredPart.length);
|
|
if (enteredPart.length === 2 && enteredPart === currentYearPart) {
|
|
const entryCurrentYear = new Date(currentYear, dateParts.month - 1, dateParts.day);
|
|
if (dateParts.day == entryCurrentYear.getDate() && (!opts.max || opts.max.date.getTime() >= entryCurrentYear.getTime())) {
|
|
//update dateParts
|
|
dateParts.date.setFullYear(currentYear);
|
|
dateParts.year = crrntyear;
|
|
//update result
|
|
currentResult.insert = [{
|
|
pos: currentResult.pos + 1,
|
|
c: currentYearNextPart[0]
|
|
}, {
|
|
pos: currentResult.pos + 2,
|
|
c: currentYearNextPart[1]
|
|
}];
|
|
}
|
|
}
|
|
}
|
|
|
|
return currentResult;
|
|
}
|
|
|
|
function isValidDate(dateParts, currentResult, opts) {
|
|
if (!useDateObject) return true;
|
|
if (dateParts.rawday === undefined
|
|
|| (!isFinite(dateParts.rawday) && new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day)
|
|
|| (dateParts.day == "29" && (!isFinite(dateParts.rawyear) || dateParts.rawyear === undefined || dateParts.rawyear === ""))
|
|
|| new Date(dateParts.date.getFullYear(), isFinite(dateParts.rawmonth) ? dateParts.month : dateParts.date.getMonth() + 1, 0).getDate() >= dateParts.day) {
|
|
return currentResult;
|
|
} else { //take corrective action if possible
|
|
if (dateParts.day == "29") {
|
|
var tokenMatch = getTokenMatch(currentResult.pos, opts);
|
|
if (tokenMatch.targetMatch[0] === "yyyy" && currentResult.pos - tokenMatch.targetMatchIndex === 2) {
|
|
currentResult.remove = currentResult.pos + 1;
|
|
return currentResult;
|
|
}
|
|
} else if (dateParts.month == "02" && dateParts.day == "30" && currentResult.c !== undefined) {
|
|
dateParts.day = "03";
|
|
dateParts.date.setDate(3);
|
|
dateParts.date.setMonth(1);
|
|
currentResult.insert = [{pos: currentResult.pos, c: "0"}, {pos: currentResult.pos + 1, c: currentResult.c}];
|
|
currentResult.caret = seekNext.call(this, currentResult.pos + 1);
|
|
return currentResult;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
function isDateInRange(dateParts, result, opts, maskset, fromCheckval) {
|
|
if (!result) return result;
|
|
if (result && opts.min) {
|
|
if (/*useDateObject && (dateParts["year"] === undefined || dateParts["yearSet"]) && */opts.min.date.getTime() === opts.min.date.getTime()) {
|
|
let match;
|
|
dateParts.reset();
|
|
getTokenizer(opts).lastIndex = 0;
|
|
while ((match = getTokenizer(opts).exec(opts.inputFormat))) {
|
|
var fcode;
|
|
if ((fcode = formatcode(match))) {
|
|
if (fcode[3]) {
|
|
var setFn = fcode[1];
|
|
var current = dateParts[fcode[2]],
|
|
minVal = opts.min[fcode[2]],
|
|
maxVal = opts.max ? opts.max[fcode[2]] : minVal,
|
|
curVal = [];
|
|
|
|
let forceCurrentValue = false;
|
|
for (let i = 0; i < minVal.length; i++) {
|
|
if (maskset.validPositions[i + match.index] === undefined && !forceCurrentValue) {
|
|
curVal[i] = minVal[i];
|
|
// ADD +1 to whoile
|
|
if (fcode[2] === "year" && current.length - 1 == i && minVal != maxVal)
|
|
curVal = (parseInt(curVal.join("")) + 1).toString().split("");
|
|
if (fcode[2] === "ampm" && minVal != maxVal && opts.min.date.getTime() > dateParts.date.getTime())
|
|
curVal[i] = maxVal[i];
|
|
} else {
|
|
curVal[i] = current[i];
|
|
forceCurrentValue = forceCurrentValue || current[i] > minVal[i];
|
|
}
|
|
}
|
|
|
|
setFn.call(dateParts._date, curVal.join(""));
|
|
}
|
|
}
|
|
}
|
|
|
|
result = opts.min.date.getTime() <= dateParts.date.getTime();
|
|
dateParts.reInit();
|
|
}
|
|
}
|
|
|
|
if (result && opts.max) {
|
|
if (opts.max.date.getTime() === opts.max.date.getTime()) {
|
|
result = opts.max.date.getTime() >= dateParts.date.getTime();
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//parse the given format and return a mask pattern
|
|
//when a dateObjValue is passed a datestring in the requested format is returned
|
|
function parse(format, dateObjValue, opts, raw) {
|
|
//parse format to regex string
|
|
var mask = "", match, fcode;
|
|
getTokenizer(opts).lastIndex = 0;
|
|
while ((match = getTokenizer(opts).exec(format))) {
|
|
if (dateObjValue === undefined) {
|
|
if ((fcode = formatcode(match))) {
|
|
mask += "(" + fcode[0] + ")";
|
|
} else {
|
|
switch (match[0]) {
|
|
case "[":
|
|
mask += "(";
|
|
break;
|
|
case "]":
|
|
mask += ")?";
|
|
break;
|
|
default:
|
|
mask += escapeRegex(match[0]);
|
|
}
|
|
}
|
|
} else {
|
|
if ((fcode = formatcode(match))) {
|
|
if (raw !== true && fcode[3]) {
|
|
var getFn = fcode[3];
|
|
mask += getFn.call(dateObjValue.date);
|
|
} else if (fcode[2]) {
|
|
mask += dateObjValue["raw" + fcode[2]];
|
|
} else {
|
|
mask += match[0];
|
|
}
|
|
} else {
|
|
mask += match[0];
|
|
}
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
//padding function
|
|
function pad(val, len, right) {
|
|
val = String(val);
|
|
len = len || 2;
|
|
while (val.length < len) val = right ? val + "0" : "0" + val;
|
|
return val;
|
|
}
|
|
|
|
function analyseMask(mask, format, opts) {
|
|
if (typeof mask === "string") {
|
|
return new DateObject(mask, format, opts);
|
|
} else if (mask && typeof mask === "object" && Object.prototype.hasOwnProperty.call(mask, "date")) {
|
|
return mask;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
function importDate(dateObj, opts) {
|
|
return parse(opts.inputFormat, {date: dateObj}, opts);
|
|
}
|
|
|
|
function getTokenMatch(pos, opts) {
|
|
var calcPos = 0, targetMatch, match, matchLength = 0;
|
|
getTokenizer(opts).lastIndex = 0;
|
|
while ((match = getTokenizer(opts).exec(opts.inputFormat))) {
|
|
var dynMatches = new RegExp("\\d+$").exec(match[0]);
|
|
matchLength = dynMatches ? parseInt(dynMatches[0]) : match[0].length;
|
|
calcPos += matchLength;
|
|
if (calcPos >= pos + 1) {
|
|
targetMatch = match;
|
|
match = getTokenizer(opts).exec(opts.inputFormat);
|
|
break;
|
|
}
|
|
}
|
|
return {
|
|
targetMatchIndex: calcPos - matchLength,
|
|
nextMatch: match,
|
|
targetMatch: targetMatch
|
|
};
|
|
}
|
|
|
|
|
|
Inputmask.extendAliases({
|
|
"datetime": {
|
|
mask: function (opts) {
|
|
//do not allow numeric input in datetime alias
|
|
opts.numericInput = false;
|
|
|
|
//localize
|
|
formatCode.S = opts.i18n.ordinalSuffix.join("|");
|
|
|
|
opts.inputFormat = formatAlias[opts.inputFormat] || opts.inputFormat; //resolve possible formatAlias
|
|
opts.displayFormat = formatAlias[opts.displayFormat] || opts.displayFormat || opts.inputFormat; //resolve possible formatAlias
|
|
opts.outputFormat = formatAlias[opts.outputFormat] || opts.outputFormat || opts.inputFormat; //resolve possible formatAlias
|
|
opts.placeholder = opts.placeholder !== "" ? opts.placeholder : opts.inputFormat.replace(/[[\]]/, "");
|
|
opts.regex = parse(opts.inputFormat, undefined, opts);
|
|
opts.min = analyseMask(opts.min, opts.inputFormat, opts);
|
|
opts.max = analyseMask(opts.max, opts.inputFormat, opts);
|
|
return null; //migrate to regex mask
|
|
},
|
|
placeholder: "", //set default as none (~ auto); when a custom placeholder is passed it will be used
|
|
inputFormat: "isoDateTime", //format used to input the date
|
|
displayFormat: null, //visual format when the input looses focus
|
|
outputFormat: null, //unmasking format
|
|
min: null, //needs to be in the same format as the inputfornat
|
|
max: null, //needs to be in the same format as the inputfornat,
|
|
skipOptionalPartCharacter: "",
|
|
// Internationalization strings
|
|
i18n: {
|
|
dayNames: [
|
|
"Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun",
|
|
"Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"
|
|
],
|
|
monthNames: [
|
|
"Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec",
|
|
"January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"
|
|
],
|
|
ordinalSuffix: ["st", "nd", "rd", "th"]
|
|
},
|
|
preValidation: function (buffer, pos, c, isSelection, opts, maskset, caretPos, strict) {
|
|
if (strict) return true;
|
|
if (isNaN(c) && buffer[pos] !== c) {
|
|
var tokenMatch = getTokenMatch(pos, opts);
|
|
if (tokenMatch.nextMatch && tokenMatch.nextMatch[0] === c && tokenMatch.targetMatch[0].length > 1) {
|
|
var validator = formatCode[tokenMatch.targetMatch[0]][0];
|
|
if (new RegExp(validator).test("0" + buffer[pos - 1])) {
|
|
buffer[pos] = buffer[pos - 1];
|
|
buffer[pos - 1] = "0";
|
|
return {
|
|
fuzzy: true,
|
|
buffer: buffer,
|
|
refreshFromBuffer: {start: pos - 1, end: pos + 1},
|
|
pos: pos + 1
|
|
};
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
},
|
|
postValidation: function (buffer, pos, c, currentResult, opts, maskset, strict, fromCheckval) {
|
|
const inputmask = this;
|
|
|
|
if (strict) return true;
|
|
var tokenMatch, validator;
|
|
if (currentResult === false) { //try some shifting
|
|
tokenMatch = getTokenMatch(pos + 1, opts);
|
|
if (tokenMatch.targetMatch && tokenMatch.targetMatchIndex === pos && tokenMatch.targetMatch[0].length > 1 && formatCode[tokenMatch.targetMatch[0]] !== undefined) {
|
|
validator = formatCode[tokenMatch.targetMatch[0]][0];
|
|
} else {
|
|
tokenMatch = getTokenMatch(pos + 2, opts);
|
|
if (tokenMatch.targetMatch && tokenMatch.targetMatchIndex === pos + 1 && tokenMatch.targetMatch[0].length > 1 && formatCode[tokenMatch.targetMatch[0]] !== undefined) {
|
|
validator = formatCode[tokenMatch.targetMatch[0]][0];
|
|
}
|
|
}
|
|
if (validator !== undefined) {
|
|
if (maskset.validPositions[pos + 1] !== undefined && new RegExp(validator).test(c + "0")) {
|
|
buffer[pos] = c;
|
|
buffer[pos + 1] = "0";
|
|
currentResult = {
|
|
//insert: [{pos: pos, c: "0"}, {pos: pos + 1, c: c}],
|
|
pos: pos + 2, //this will triggeer a refreshfrombuffer
|
|
caret: pos
|
|
};
|
|
} else if (new RegExp(validator).test("0" + c)) {
|
|
buffer[pos] = "0";
|
|
buffer[pos + 1] = c;
|
|
currentResult = {
|
|
//insert: [{pos: pos, c: "0"}, {pos: pos + 1, c: c}],
|
|
pos: pos + 2 //this will triggeer a refreshfrombuffer
|
|
};
|
|
}
|
|
}
|
|
|
|
if (currentResult === false) return currentResult;
|
|
}
|
|
|
|
if (currentResult.fuzzy) {
|
|
buffer = currentResult.buffer;
|
|
pos = currentResult.pos;
|
|
}
|
|
|
|
//full validate target
|
|
tokenMatch = getTokenMatch(pos, opts);
|
|
if (tokenMatch.targetMatch && tokenMatch.targetMatch[0] && formatCode[tokenMatch.targetMatch[0]] !== undefined) {
|
|
let fcode = formatCode[tokenMatch.targetMatch[0]];
|
|
validator = fcode[0];
|
|
var part = buffer.slice(tokenMatch.targetMatchIndex, tokenMatch.targetMatchIndex + tokenMatch.targetMatch[0].length);
|
|
if (new RegExp(validator).test(part.join("")) === false && tokenMatch.targetMatch[0].length === 2 && maskset.validPositions[tokenMatch.targetMatchIndex] && maskset.validPositions[tokenMatch.targetMatchIndex + 1]) {
|
|
maskset.validPositions[tokenMatch.targetMatchIndex + 1].input = "0";
|
|
}
|
|
if (fcode[2] == "year") {
|
|
var _buffer = getMaskTemplate.call(inputmask, false, 1, undefined, true);
|
|
for (let i = pos + 1; i < buffer.length; i++) {
|
|
buffer[i] = _buffer[i];
|
|
delete maskset.validPositions[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
var result = currentResult, dateParts = analyseMask(buffer.join(""), opts.inputFormat, opts);
|
|
if (result && dateParts.date.getTime() === dateParts.date.getTime()) { //check for a valid date ~ an invalid date returns NaN which isn't equal
|
|
if (opts.prefillYear) result = prefillYear(dateParts, result, opts);
|
|
result = isValidDate.call(inputmask, dateParts, result, opts);
|
|
result = isDateInRange(dateParts, result, opts, maskset, fromCheckval);
|
|
}
|
|
|
|
if (pos !== undefined && result && currentResult.pos !== pos) {
|
|
return {
|
|
buffer: parse(opts.inputFormat, dateParts, opts).split(""),
|
|
refreshFromBuffer: {start: pos, end: currentResult.pos},
|
|
pos: currentResult.caret || currentResult.pos //correct caret position
|
|
};
|
|
}
|
|
|
|
return result;
|
|
},
|
|
onKeyDown: function (e, buffer, caretPos, opts) {
|
|
var input = this;
|
|
if (e.ctrlKey && e.keyCode === keyCode.RIGHT) {
|
|
input.inputmask._valueSet(importDate(new Date(), opts));
|
|
$(input).trigger("setvalue");
|
|
}
|
|
},
|
|
onUnMask: function (maskedValue, unmaskedValue, opts) {
|
|
return unmaskedValue ? parse(opts.outputFormat, analyseMask(maskedValue, opts.inputFormat, opts), opts, true) : unmaskedValue;
|
|
},
|
|
casing: function (elem, test, pos, validPositions) {
|
|
if (test.nativeDef.indexOf("[ap]") == 0) return elem.toLowerCase();
|
|
if (test.nativeDef.indexOf("[AP]") == 0) return elem.toUpperCase();
|
|
return elem;
|
|
},
|
|
onBeforeMask: function (initialValue, opts) {
|
|
if (Object.prototype.toString.call(initialValue) === "[object Date]") {
|
|
initialValue = importDate(initialValue, opts);
|
|
}
|
|
|
|
return initialValue;
|
|
},
|
|
insertMode: false,
|
|
shiftPositions: false,
|
|
keepStatic: false,
|
|
inputmode: "numeric",
|
|
prefillYear: true //Allows to disable prefill for datetime year.
|
|
}
|
|
});
|