remove version

build.xml

@@ -81,7 +81,7 @@
 			 <arg value="-OutputDirectory" />
 			 <arg value="..\${distdir}" />
         </exec>
-        <exec executable="EnableNuGetPackageRestore=true mono --runtime=v4.0.30319 ${NugetExe}" failonerror="true" dir="tools" vmlauncher="false" osfamily="unix" >
+        <exec executable="EnableNuGetPackageRestore=true mono --runtime=v4.0.30319 ${NugetExe}" failonerror="false" dir="tools" vmlauncher="false" osfamily="unix" >
 			 <arg value="pack"/>
 			 <arg value="../nuget/${nuspec}" />
 			 <arg value="-OutputDirectory" />

js/jquery.inputmask.date.extensions.js

@@ -3,7 +3,7 @@ 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.49
+Version: 0.0.0
 
 Optional extensions on the jquery.inputmask base
 */
@@ -466,4 +466,4 @@ Optional extensions on the jquery.inputmask base
             alias: "dd/mm/yyyy" // "mm/dd/yyyy"
         }
     });
-})(jQuery);
+})(jQuery);

js/jquery.inputmask.date.extensions.js~

@@ -0,0 +1,469 @@
+/*
+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: 0.0.0
+
+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
+                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) {
+                        return opts.regex.ampm.test(chrs + "m");
+                    },
+                    casing: "lower",
+                    cardinality: 1
+                }
+            },
+            insertMode: false,
+            autoUnmask: false
+        },
+        'datetime12': {
+            mask: "1/2/y h:s t\\m",
+            placeholder: "dd/mm/yyyy hh:mm xm",
+            alias: "datetime",
+            hourFormat: "12"
+        },
+        'hh:mm t': {
+            mask: "h:s t\\m",
+            placeholder: "hh:mm xm",
+            alias: "datetime",
+            hourFormat: "12"
+        },
+        'h:s t': {
+            mask: "h:s t\\m",
+            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);

js/jquery.inputmask.extensions.js

@@ -3,7 +3,7 @@ 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.49
+Version: 0.0.0
 
 Optional extensions on the jquery.inputmask base
 */
@@ -99,4 +99,4 @@ Optional extensions on the jquery.inputmask base
             }
         }
     });
-})(jQuery);
+})(jQuery);

js/jquery.inputmask.extensions.js~

@@ -0,0 +1,102 @@
+/*
+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.49
+
+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;
+                    })()
+                },
+                "r": {
+                    validator: ".",
+                    cardinality: 50
+                }
+            },
+            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);

js/jquery.inputmask.js

@@ -3,7 +3,7 @@
 * 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.49
+* Version: 0.0.0
 */
 
 (function ($) {

js/jquery.inputmask.numeric.extensions.js

@@ -3,7 +3,7 @@ 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.49
+Version: 0.0.0
 
 Optional extensions on the jquery.inputmask base
 */

js/jquery.inputmask.numeric.extensions.js~

@@ -0,0 +1,162 @@
+/*
+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.49
+
+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,
+            allowPlus: true,
+            allowMinus: true,
+            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) {
+                if (opts.groupSeparator == "") return pos;
+                var cbuf = buffer.slice(),
+                    radixPos = $.inArray(opts.radixPoint, buffer);
+                if (!reformatOnly) {
+                    cbuf.splice(pos == 0 || pos <= radixPos || opts.skipRadixDance ? pos + 1 : pos, 0, "?"); //set position indicator
+                }
+                var bufVal = cbuf.join('');
+                if (opts.autoGroup || (reformatOnly && bufVal.indexOf(opts.groupSeparator) != -1)) {
+                    var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, opts.groupSeparator);
+                    bufVal = bufVal.replace(new RegExp(escapedGroupSeparator, "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 = $.inArray("?", buffer);
+                if (!reformatOnly) buffer.splice(newPos, 1);
+
+                return reformatOnly ? pos : newPos <= radixPos || (opts.skipRadixDance && newPos != 0) ? newPos - 1 : newPos;
+            },
+            regex: {
+                number: function (groupSeparator, groupSize, radixPoint, digits, allowPlus, allowMinus) {
+                    var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, groupSeparator);
+                    var escapedRadixPoint = $.inputmask.escapeRegex.call(this, radixPoint);
+                    var digitExpression = isNaN(digits) ? digits : '{0,' + digits + '}';
+                    var signedExpression = "[" + (allowPlus ? "\+" : "") + (allowMinus ? "-" : "") + "]?";
+                    return new RegExp("^" + signedExpression + "(\\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 (!strict && 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 == 0 && buffer.length == 0) ? pos : pos + 1, 0, chrs);
+                        var bufferStr = cbuf.join('');
+                        if (opts.autoGroup && !strict) { //strip groupseparator
+                            var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, opts.groupSeparator);
+                            bufferStr = bufferStr.replace(new RegExp(escapedGroupSeparator, "g"), '');
+                        }
+                        var isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits, opts.allowPlus, opts.allowMinus).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, opts.allowPlus, opts.allowMinus).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, opts.allowPlus, opts.allowMinus).test(bufferStr);
+                                if (!isValid && !strict) {
+                                    if (chrs == opts.radixPoint) {
+                                        isValid = opts.regex.number(opts.groupSeparator, opts.groupSize, opts.radixPoint, opts.digits, opts.allowPlus, opts.allowMinus).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, false, opts);
+                            return { "pos": newPos };
+                        }
+                        return isValid;
+                    },
+                    cardinality: 1,
+                    prevalidator: null
+                }
+            },
+            insertMode: true,
+            autoUnmask: false
+        },
+        'integer': {
+            regex: {
+                number: function (groupSeparator, groupSize, radixPoint, digits, allowPlus, allowMinus) {
+                    var escapedGroupSeparator = $.inputmask.escapeRegex.call(this, groupSeparator);
+                    var signedExpression = "[" + (allowPlus ? "\+" : "") + (allowMinus ? "-" : "") + "]?";
+                    return new RegExp("^" + signedExpression + "(\\d+|\\d{1," + groupSize + "}((" + escapedGroupSeparator + "\\d{" + groupSize + "})?)+)$");
+                }
+            },
+            alias: "decimal"
+        }
+    });
+})(jQuery);

js/jquery.inputmask.regex.extensions.js

@@ -3,7 +3,7 @@ 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.49
+Version: 0.0.0
 
 Regex extensions on the jquery.inputmask base
 Allows for using regular expressions as a mask
@@ -53,4 +53,4 @@ Allows for using regular expressions as a mask
             }
         }
     });
-})(jQuery);
+})(jQuery);

js/jquery.inputmask.regex.extensions.js~

@@ -0,0 +1,56 @@
+/*
+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.49
+
+Regex extensions on the jquery.inputmask base
+Allows for using regular expressions as a mask
+*/
+(function ($) {
+    $.extend($.inputmask.defaults.aliases, { // $(selector).inputmask("Regex", { regex: "[0-9]*"}
+        'Regex': {
+            mask: "r",
+            greedy: false,
+            repeat: 10, //needs to be computed
+            regex: null,
+            regexSplit: null,
+            definitions: {
+                'r': {
+                    validator: function (chrs, buffer, pos, strict, opts) {
+
+                        function analyseRegex() {  //ENHANCE ME
+                            var regexSplitRegex = "\\[.*?\]\\*";
+
+                            opts.regexSplit = opts.regex.match(new RegExp(regexSplitRegex, "g"));
+
+                            //if (opts.regex.indexOf("*") != (opts.regex.length - 1)) {
+                            //    opts.regex += "{1}";
+                            //}
+                            //opts.regexSplit.push(opts.regex);
+                        }
+
+                        if (opts.regexSplit == null) {
+                            analyseRegex();
+                        }
+
+                        var cbuffer = buffer.slice(), regexPart = "", isValid = false;
+                        cbuffer.splice(pos, 0, chrs);
+                        var bufferStr = cbuffer.join('');
+                        for (var i = 0; i < opts.regexSplit.length; i++) {
+                            regexPart += opts.regexSplit[i];
+                            var exp = new RegExp("^" + regexPart + "$");
+                            isValid = exp.test(bufferStr);
+                            console.log(bufferStr + ' ' + isValid + ' ' + regexPart);
+                            if (isValid) break;
+                        }
+
+                        return isValid;
+                    },
+                    cardinality: 1
+                }
+            }
+        }
+    });
+})(jQuery);