Created
January 4, 2016 23:06
-
-
Save philleepflorence/0b95ef601a3494d5c6c3 to your computer and use it in GitHub Desktop.
Collection of utilities and helpers
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
Dependencies: jQuery(v1.8), Underscore.js | |
Last Edited: 02/23/2015 | |
*/ | |
"use strict"; | |
var UTILITIES = function() | |
{ | |
var utils = this; | |
var comma = function() | |
{ | |
var amount = String(this); | |
if (amount < 1000) return amount; | |
var x = amount.split('.'); | |
var x1 = x[0]; | |
var x2 = x.length > 1 ? '.' + x[1] : ''; | |
var rgx = /(\d+)(\d{3})/; | |
while (rgx.test(x1)) | |
{ | |
x1 = x1.replace(rgx, '$1' + ',' + '$2'); | |
} | |
return x1 + x2; | |
}; | |
var decode = function(string) | |
{ | |
var decoder = document.getElementById('decoder'); | |
if (!decoder) | |
{ | |
decoder = document.createElement('div'); | |
decoder.id = 'decoder'; | |
} | |
$(decoder).html(string); | |
return $(decoder).html(); | |
}; | |
var between = function(a, b) | |
{ | |
if (a > b) return (this >= b && this <= a); | |
else return (this >= a && this <= b); | |
}; | |
var isLimit = function(a) | |
{ | |
if (a <= 0) return (this <= a); | |
else return (this >= a); | |
}; | |
var isMetaKey = function() | |
{ | |
var num = this.valueOf(); | |
if (_.indexOf([8,9,13,16,17,18,19,20,27,32,37,38,39,40,45,46], num) !== -1) return true; | |
else return false; | |
}; | |
var lPad = function(len, padding) | |
{ | |
var str = this + ''; | |
padding = padding || '0'; | |
len = len || 2; | |
str = str.length >= len ? str : new Array(len - str.length + 1).join(padding) + str; | |
return str; | |
}; | |
var roundToNumber = function(num) | |
{ | |
num = num % 10 === 0 ? num : Math.pow(10, ( num || 2 )); | |
return Math.round(this * num) / num; | |
}; | |
var isNumeric = function() | |
{ | |
return (this - 0) == this && this.length > 0; | |
}; | |
var toFormat = function(type, format) | |
{ | |
var str = this; | |
var regex, | |
unix, | |
tStamp; | |
if (!type || !format) return str; | |
if (type === 'date') | |
{ | |
if (format === 'timestamp') | |
{ | |
regex = utils.regex('integer'); | |
if (regex.lastIndex) regex.lastIndex = 0; | |
unix = regex.test(str) ? str.toString() : moment(str.replace(/-0/g, '-')).unix(); | |
if (regex.lastIndex) regex.lastIndex = 0; | |
str = str.length === 0 ? '' : ( ( regex.test(unix) ) ? unix : str.strToTime() ); | |
} | |
else | |
{ | |
regex = utils.regex('integer'); | |
if (regex.lastIndex) regex.lastIndex = 0; | |
unix = regex.test(str) ? str.toString() : moment(str.replace(/-0/g, '-')).unix(); | |
if (regex.lastIndex) regex.lastIndex = 0; | |
tStamp = ( regex.test(unix) ) ? unix : str.strToTime(); | |
str = moment.unix(tStamp).format(format); | |
console.log(tStamp, unix, str); | |
} | |
} | |
else if (type === 'array') | |
{ | |
str = str.explode(format); | |
} | |
else if (type === 'string') | |
{ | |
if (typeof String.prototype[format] === 'function') str = str[format](); | |
} | |
return str; | |
}; | |
var strToTime = function(now) | |
{ | |
var parsed, match, year, date, days, ranges, len, times, regex, i, text = this.toLowerCase(); | |
text = text.replace(/^\s+|\s+$/g, '').replace(/\s{2,}/g, ' ').replace(/[\t\r\n]/g, '').toLowerCase(); | |
if (text === 'now') | |
{ | |
return now === null || isNaN(now) ? new Date().getTime() / 1000 | 0 : now | 0; | |
} | |
if (!isNaN(parsed = Date.parse(text))) | |
{ | |
return parsed / 1000 | 0; | |
} | |
if (text === 'now') | |
{ | |
return new Date().getTime() / 1000; | |
} | |
if (!isNaN(parsed = Date.parse(text))) | |
{ | |
return parsed / 1000; | |
} | |
match = text.match(/^(\d{2,4})-(\d{2})-(\d{2})(?:\s(\d{1,2}):(\d{2})(?::\d{2})?)?(?:\.(\d+)?)?$/); | |
if (match) | |
{ | |
year = match[1] >= 0 && match[1] <= 69 ? +match[1] + 2000 : match[1]; | |
return new Date(year, parseInt(match[2], 10) - 1, match[3], match[4] || 0, match[5] || 0, match[6] || 0, match[7] || 0) / 1000; | |
} | |
date = now ? new Date(now * 1000) : new Date(); | |
days = { | |
'sun': 0, | |
'mon': 1, | |
'tue': 2, | |
'wed': 3, | |
'thu': 4, | |
'fri': 5, | |
'sat': 6 | |
}; | |
ranges = { | |
'yea': 'FullYear', | |
'mon': 'Month', | |
'day': 'Date', | |
'hou': 'Hours', | |
'min': 'Minutes', | |
'sec': 'Seconds' | |
}; | |
var lastNext = function(type, range, modifier) | |
{ | |
var diff, day = days[range]; | |
if (typeof day !== 'undefined') { | |
diff = day - date.getDay(); | |
if (diff === 0) { | |
diff = 7 * modifier; | |
} | |
else if (diff > 0 && type === 'last') { | |
diff -= 7; | |
} | |
else if (diff < 0 && type === 'next') { | |
diff += 7; | |
} | |
date.setDate(date.getDate() + diff); | |
} | |
}; | |
var process = function(val) | |
{ | |
var splt = val.split(' '), | |
type = splt[0], | |
range = splt[1].substring(0, 3), | |
typeIsNumber = /\d+/.test(type), | |
ago = splt[2] === 'ago', | |
num = (type === 'last' ? -1 : 1) * (ago ? -1 : 1); | |
if (typeIsNumber) { | |
num *= parseInt(type, 10); | |
} | |
if (ranges.hasOwnProperty(range) && !splt[1].match(/^mon(day|\.)?$/i)) { | |
return date['set' + ranges[range]](date['get' + ranges[range]]() + num); | |
} | |
if (range === 'wee') { | |
return date.setDate(date.getDate() + (num * 7)); | |
} | |
if (type === 'next' || type === 'last') { | |
lastNext(type, range, num); | |
} | |
else if (!typeIsNumber) { | |
return false; | |
} | |
return true; | |
}; | |
times = '(years?|months?|weeks?|days?|hours?|minutes?|min|seconds?|sec' + '|sunday|sun\\.?|monday|mon\\.?|tuesday|tue\\.?|wednesday|wed\\.?' + '|thursday|thu\\.?|friday|fri\\.?|saturday|sat\\.?)'; | |
regex = '([+-]?\\d+\\s' + times + '|' + '(last|next)\\s' + times + ')(\\sago)?'; | |
match = text.match(new RegExp(regex, 'gi')); | |
if (!match) | |
{ | |
return false; | |
} | |
for(i = 0, len = match.length; i < len; i++) | |
{ | |
if (!process(match[i])) | |
{ | |
return false; | |
} | |
} | |
return (date.getTime() / 1000); | |
}; | |
/* !Prototypes - Dates */ | |
this.Dates = function() | |
{ | |
console.log('Utilities(): Prototypes(): Dates'); | |
Date.prototype.between = between; | |
}; | |
/* !Prototypes - Numbers */ | |
this.Numbers = function() | |
{ | |
console.log('Utilities(): Prototypes(): Numbers'); | |
Number.prototype.between = between; | |
Number.prototype.isLimit = isLimit; | |
Number.prototype.lPad = lPad; | |
Number.prototype.roundToNumber = roundToNumber; | |
Number.prototype.comma = comma; | |
Number.prototype.percent = function(denominator, decimal) | |
{ | |
denominator = denominator || 100; | |
if (this === denominator) return '100%'; | |
if (this === 0) return '0%'; | |
var percentage = 0; | |
denominator = denominator || 100; | |
decimal = Math.pow(10, ( decimal || 2 )); | |
percentage = ( ( this / denominator ) * 100 ).roundToNumber(decimal); | |
return percentage + '%'; | |
}; | |
Number.prototype.tax = function(rate, decimal) | |
{ | |
if (this === 0) return 0; | |
if (rate === 0) return this; | |
decimal = Math.pow(10, ( decimal || 2 )); | |
return ( ( this * rate ) + this ).roundToNumber(decimal); | |
}; | |
Number.prototype.percentage = function(percent, decimal) | |
{ | |
if (this === 0) return 0; | |
percent = typeof percent === 'boolean' ? percent : false; | |
decimal = typeof decimal === 'number' ? decimal : 2; | |
decimal = Math.pow(10, decimal); | |
var percentage = 0; | |
var num = percent ? 0.01 : 100; | |
percentage = ( this * num ).roundToNumber(decimal); | |
return percentage; | |
}; | |
Number.prototype.decimals = function() | |
{ | |
if (this === 0) return 0; | |
var num = this, | |
match = ('' + num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/); | |
if (!match) return 0; | |
return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0)); | |
}; | |
Number.prototype.decimeter = function(decimal, format) | |
{ | |
var num = this; | |
format = format ? format.toUpperCase() : 'AUTO'; | |
decimal = Math.pow(10, decimal); | |
if (format === 'BYTES' || format === 'AUTO') | |
{ | |
var mod = format === 'BYTES' ? 1024 : 1000; | |
var units = format === 'BYTES' ? ["B", "KB", "MB", "GB", "TB", "PB"] : ["", "K", "M", "B", "T", "P"]; | |
for(var i = 0; num > mod; i++) num /= mod; | |
return num.roundToNumber(decimal) + ' ' + units[i]; | |
} | |
return '0'; | |
}; | |
}; | |
/* !Prototypes - Strings */ | |
this.Strings = function() | |
{ | |
console.log('Utilities(): Prototypes(): Strings'); | |
String.prototype.between = between; | |
String.prototype.isNumeric = isNumeric; | |
String.prototype.lPad = lPad; | |
String.prototype.strToTime = strToTime; | |
String.prototype.toFormat = toFormat; | |
String.prototype.comma = comma; | |
String.prototype.capitalize = function() | |
{ | |
return this.replace( /(^|\s)([a-z])/g , function(m,p1,p2){ return p1+p2.toUpperCase(); } ); | |
}; | |
String.prototype.decimals = function() | |
{ | |
if (this === 0) return 0; | |
var num = this, | |
match = ('' + num).match(/(?:\.(\d+))?(?:[eE]([+-]?\d+))?$/); | |
if (!match) return 0; | |
return Math.max(0, (match[1] ? match[1].length : 0) - (match[2] ? +match[2] : 0)); | |
}; | |
String.prototype.explode = function(separator) | |
{ | |
var str = this; | |
var arr = []; | |
separator = separator || [", ", "; ", ",", ";", "\n"]; | |
if (separator === 'linebreak') | |
{ | |
arr = str.split("\n"); | |
} | |
else if (typeof separator === 'string') | |
{ | |
arr = str.split(separator); | |
} | |
else if (typeof separator === 'object') | |
{ | |
for(var i in separator) | |
{ | |
if (str.indexOf(separator[i]) >= 0) | |
{ | |
arr = str.split(separator[i]); | |
break; | |
} | |
} | |
if (arr.length === 0) | |
arr = [str.toString()]; | |
} | |
return utils.arrays.trim(arr); | |
}; | |
String.prototype.format = function() | |
{ | |
var i = 0, args = arguments; | |
return this.replace(/({{.*?}})/g, function () | |
{ | |
return typeof args[i] !== 'undefined' ? args[i++] : ''; | |
}); | |
}; | |
String.prototype.hash = function() | |
{ | |
for(var ret = 0, i = 0, len = this.length; i < len; i++) | |
ret = (31 * ret + this.charCodeAt(i)) << 0; | |
return String(ret).LRTrim('-'); | |
}; | |
String.prototype.hexadecimal = function() | |
{ | |
var str = this; | |
var rgb = str.match(/^rgb\((\d+),\s*(\d+),\s*(\d+)\)$/); | |
var rgba = str.match(/^rgba?[\s+]?\([\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?,[\s+]?(\d+)[\s+]?/i); | |
var color = str.toString(); | |
var opacity = 1; | |
var type; | |
if (rgb) | |
{ | |
type = 'rgb'; | |
color = "#" + ("0" + parseInt(rgb[1],10).toString(16)).slice(-2) + ("0" + parseInt(rgb[2],10).toString(16)).slice(-2) + ("0" + parseInt(rgb[3],10).toString(16)).slice(-2); | |
} | |
else if (rgba) | |
{ | |
type = 'rgba'; | |
opacity = parseFloat(_.last(str.split(',')).replace(/[0-9.]/, '')); | |
color = "#" + ("0" + parseInt(rgba[1],10).toString(16)).slice(-2) + ("0" + parseInt(rgba[2],10).toString(16)).slice(-2) + ("0" + parseInt(rgba[3],10).toString(16)).slice(-2); | |
} | |
return { color : color, opacity : opacity, input : type }; | |
}; | |
String.prototype.htmlCharsEncode = function(quotes) | |
{ | |
var str = this; | |
str = str.sanitize(); | |
quotes = typeof quotes === 'boolean' ? quotes : true; | |
var htmlCharacters = ["®","¯","°","±","²","³","´","µ","","·","¸","¹","º","»","¼","½","¾","¿","À","Á","Â","Ã", | |
"Ä","Å","Æ","Ç","È","É","Ê","Ë","Ì","Í","Î","Ï","Ð","Ñ","Ò","Ó","Ô","Õ","Ö","×","Ø", | |
"Ù","Ú","Û","Ü","Ý","Þ","ß","à","á","â","ã","ä","å","æ","ç","è","é","ê","ë","ì","í", | |
"î","ï","ð","ñ","ò","ó","ô","õ","ö","÷","ø","ù","ú","û","ü","ý","þ","ÿ","‘","’","‚","“", | |
"”","„","†","‡","…","‰","‹","›","♠","♣","♥","♦","‾","←","↑","→","↓","™","[","]","–","—","¡", | |
"¢","£","¤","¥","¦","§","¨","©","ª","«","¬","•"]; | |
var chars = [/®/g,/¯/g,/°/g,/±/g,/²/g,/³/g,/´/g,/µ/g,/¶/g,/·/g,/¸/g,/¹/g,/º/g,/»/g,/¼/g,/½/g,/¾/g,/¿/g,/À/g,/ÃÂ/g,/Â/g,/Ã/g,/Ä/g,/Ã…/g,/Æ/g,/Ç/g,/È/g,/É/g,/Ê/g,/Ë/g,/ÃŒ/g,/ÃÂ/g,/ÃŽ/g,/ÃÂ/g,/ÃÂ/g,/Ñ/g,/Ã’/g,/Ó/g,/Ãâ€/g,/Õ/g, | |
/Ö/g,/×/g,/Ø/g,/Ù/g,/Ú/g,/Û/g,/Ãœ/g,/ÃÂ/g,/Þ/g,/ß/g,/à /g,/á/g,/â/g,/ã/g,/ä/g,/Ã¥/g,/æ/g,/ç/g,/è/g,/é/g,/ê/g,/ë/g,/ì/g,/ÃÂ/g,/î/g,/ï/g,/ð/g,/ñ/g,/ò/g,/ó/g,/ô/g,/õ/g,/ö/g,/÷/g,/ø/g,/ù/g,/ú/g,/û/g,/ü/g,/ý/g, | |
/þ/g,/ÿ/g,/‘/g,/’/g,/‚/g,/“/g,/â€Â/g,/„/g,/†/g,/‡/g,/…/g,/‰/g,/‹/g,/›/g,/â™ /g,/♣/g,/♥/g,/♦/g,/‾/g,/â†Â/g,/↑/g,/→/g,/↓/g,/â„¢/g,/\[/g,/\]/g,/–/g,/â€â€/g,/¡/g,/¢/g,/£/g,/¤/g,/Â¥/g,/¦/g,/§/g,/¨/g,/©/g,/ª/g,/«/g,/¬/g,/•/g]; | |
for(var i in chars) | |
{ | |
str = str.replace( chars[i], htmlCharacters[i] ); | |
} | |
if (quotes === true) | |
{ | |
str = str.replace( /"/g, '\\"' ); | |
str = str.replace( /'/g, "\\'" ); | |
} | |
return str; | |
}; | |
String.prototype.isSQLDate = function() | |
{ | |
var str = this.toString(); | |
var regex = utils.regex('date')['sqlDate']; | |
if (regex.lastIndex) regex.lastIndex = 0; | |
return regex.test(str); | |
}; | |
String.prototype.LPadding = function(padding) | |
{ | |
var temp = this.trim().split(''); | |
if (temp[0] !== padding) | |
temp = [padding].concat(temp); | |
return temp.join(''); | |
}; | |
String.prototype.LRPadding = function(padding) | |
{ | |
var temp = this.trim().split(''); | |
padding = padding || ''; | |
if (temp[0] !== padding) | |
temp = [padding].concat(temp); | |
if (temp[temp.length - 1] !== padding) | |
temp = temp.concat([padding]); | |
return temp.join(''); | |
}; | |
String.prototype.LRTrim = function(trim) | |
{ | |
var temp = this.trim().split(''); | |
trim = trim || ''; | |
if (temp[0] === trim) | |
temp.splice(0,1); | |
if (temp[temp.length - 1] === trim) | |
temp.splice(temp.length - 1,1); | |
return temp.join(''); | |
}; | |
String.prototype.gzip = function() | |
{ | |
var temp = this.trim(); | |
temp = temp.replace(/\>[\n\t ]+\</g, '><'); | |
temp = temp.replace(/\n/g, ''); | |
temp = temp.replace(/\r/g, ''); | |
temp = temp.replace(/\t/g, ''); | |
return temp; | |
}; | |
String.prototype.trim = function(charlist) | |
{ | |
var str = this, whitespace, l = 0, i = 0; | |
str += ''; | |
if (!charlist) { whitespace = " \n\r\t\f\x0b\xa0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u2028\u2029\u3000"; } | |
else { | |
charlist += ''; | |
whitespace = charlist.replace(/([\[\]\(\)\.\?\/\*\{\}\+\$\^\:])/g, '$1'); | |
} | |
l = this.length; | |
for (i = 0; i < l; i++) { | |
if (whitespace.indexOf(str.charAt(i)) === -1) { | |
str = str.substring(i); | |
break; | |
} | |
} | |
l = str.length; | |
for (i = l - 1; i >= 0; i--) { | |
if (whitespace.indexOf(str.charAt(i)) === -1) { | |
str = str.substring(0, i + 1); | |
break; | |
} | |
} | |
return whitespace.indexOf(str.charAt(0)) === -1 ? str : ''; | |
}; | |
String.prototype.stripslashes = function() | |
{ | |
return (this + '').replace(/\\{2,}/g, function(s, n1) | |
{ | |
switch (n1) | |
{ | |
case '\\': | |
return '\\'; | |
case '0': | |
return '\u0000'; | |
case '': | |
return ''; | |
default: | |
return n1; | |
} | |
}); | |
}; | |
String.prototype.stripTags = function(ignoreTags, _replace) | |
{ | |
var str = this; | |
_replace = _replace || ''; | |
ignoreTags = (((ignoreTags || "") + "").toLowerCase().match(/<[a-z][a-z0-9]*>/g) || []).join(''); | |
var tags = /<\/?([a-z][a-z0-9]*)\b[^>]*>/gi, commentsAndPhpTags = /<!--[\s\S]*?-->|<\?(?:php)?[\s\S]*?\?>/gi; | |
return str.replace(commentsAndPhpTags, _replace).replace(tags, function($0, $1) | |
{ | |
return ignoreTags.indexOf('<' + $1.toLowerCase() + '>') > -1 ? $0 : _replace; | |
}); | |
}; | |
String.prototype.sanitizePaste = function() | |
{ | |
var str = this.trim().stripTags().sanitize(); | |
str = str.replace( /“/g, '"' ); | |
str = str.replace( /â€ÂÂÂ/g, '"' ); | |
str = str.replace( /’/g, "'" ); | |
str = str.replace( /\s*mso-[^:]+:[^;"]+;?/gi, "" ); | |
str = str.replace( /\s*MARGIN: 0cm 0cm 0pt\s*;/gi, "" ); | |
str = str.replace( /\s*MARGIN: 0cm 0cm 0pt\s*"/gi, "\"" ); | |
str = str.replace( /\s*TEXT-INDENT: 0cm\s*;/gi, "" ); | |
str = str.replace( /\s*TEXT-INDENT: 0cm\s*"/gi, "\"" ); | |
str = str.replace( /\s*TEXT-ALIGN: [^\s;]+;?"/gi, "\"" ); | |
str = str.replace( /\s*PAGE-BREAK-BEFORE: [^\s;]+;?"/gi, "\"" ); | |
str = str.replace( /\s*FONT-VARIANT: [^\s;]+;?"/gi, "\"" ); | |
str = str.replace( /\s*tab-stops:[^;"]*;?/gi, "" ); | |
str = str.replace( /\s*tab-stops:[^"]*/gi, "" ); | |
str = str.replace( /\s*face="[^"]*"/gi, "" ); | |
str = str.replace( /\s*face=[^ >]*/gi, "" ); | |
str = str.replace( /size|SIZE = ([\d]{1})/g, '' ); | |
str = str.replace( /\n/g, '<br>' ); | |
return str; | |
}; | |
String.prototype.sanitize = function() | |
{ | |
var str = this; | |
str = str.replace(/â€Â/g,'"'); | |
str = str.replace(/“/g,'"'); | |
str = str.replace(/’/g,"'"); | |
str = str.replace(/‘/g,"'"); | |
str = str.replace(/`/g,"'"); | |
return str; | |
}; | |
String.prototype.stripEmptyTags = function() | |
{ | |
return this.replace(/<[^\/>][^>]*><\/[^>]+>/gi, '').replace(/<[^\/>][^>]*><\/[^>]+>/gi, ''); | |
}; | |
String.prototype.lineBreak = function(reverse) | |
{ | |
if (!reverse) return this.replace(/\n/g, "<br>"); | |
else if (reverse) return this.replace(/<br\s*[\/]?>/gi, "\n"); | |
}; | |
String.prototype.stripLineBreak = function() | |
{ | |
return this.replace(/\n/g, "").replace(/\r/g, "").replace(/\t/g, ""); | |
}; | |
String.prototype.to24Hours = function() | |
{ | |
var str = this; | |
var meridian = str.substr(str.length - 2); | |
var _string = str.replace(meridian, ''); | |
_string = _string.split(':'); | |
_string = utils.arrays.trim(_string); | |
meridian = meridian.toLowerCase(); | |
_string[0] = meridian === 'pm' ? ( _string[0] == 12 ? '00' : parseInt(_string[0]) + 12 ) : ( _string[0].lPad() ); | |
_string[1] = _string[1].lPad(); | |
return _string.join(':'); | |
}; | |
String.prototype.toUrlString = function() | |
{ | |
var str = this; | |
str = str.replace(/\s/g, '-'); | |
str = str.replace(/_/g, '-'); | |
str = str.replace(/[^a-zA-z0-9\-\/\+]/g, ''); | |
str = str.replace(/-{2,}/g, '-'); | |
return str.toLowerCase(); | |
}; | |
String.prototype.toUrlFormat = function(type) | |
{ | |
var str = this; | |
str = str.LRPadding('/'); | |
str = str.toUrlString(); | |
return str.toLowerCase(); | |
}; | |
String.prototype.toUrlPath = function(type) | |
{ | |
var str = this; | |
str = str.LRPadding('/'); | |
str = decode(str); | |
return str.toLowerCase(); | |
}; | |
String.prototype.toCamelCase = function(type) | |
{ | |
var str = this; | |
str = str.replace(/[^a-zA-Z0-9 ]/g, " "); | |
str = str.replace(/([a-z](?=[A-Z]))/g, '$1 '); | |
str = str.replace(/([^a-zA-Z0-9 ])|^[0-9]+/g, '').trim().toLowerCase(); | |
str = str.replace(/([ 0-9]+)([a-zA-Z])/g, function(a,b,c) { return b.trim() + c.toUpperCase(); }); | |
return str; | |
}; | |
String.prototype.toVariableString = function() | |
{ | |
var str = this.trim('/').toUrlString(); | |
str = str.replace(/[^a-zA-z0-9]/g, '_'); | |
str = str.replace(/-/g, '_'); | |
return str.toLowerCase(); | |
}; | |
String.prototype.toSearchString = function() | |
{ | |
var str = this; | |
str = str.replace(/\s/g, '-'); | |
str = str.replace(/[^a-zA-z0-9\-]/g, '-'); | |
str = str.replace(/-{1,}/g, '+'); | |
return str.toLowerCase(); | |
}; | |
String.prototype.toInteger = function() | |
{ | |
var str = this; | |
str = parseInt(str); | |
return str; | |
}; | |
String.prototype.truncate = function(limit) | |
{ | |
limit = limit || 20; | |
if (this.length < limit) return this; | |
else return '{{string}}...'.format(this.substring(0, limit)); | |
}; | |
String.prototype.UrlToWords = function(hyphen, glue) | |
{ | |
var str = this; | |
str = str.trim('/'); | |
str = hyphen ? String( str.replace(/[^A-Za-z0-9-]/gi, ( glue || ' ⇢ ' )) ).replace(/-/gi, ' ') : str.replace(/[^A-Za-z0-9]/gi, ' '); | |
return str; | |
}; | |
String.prototype.quotesEncode = function() | |
{ | |
var str = this; | |
str = str.replace(/'/gi, '''); | |
str = str.replace(/"/gi, '"'); | |
return str; | |
}; | |
String.prototype.sanitizeCode = function() | |
{ | |
var str = this.quotesEncode(); | |
str = str.replace(/</gi, '<'); | |
str = str.replace(/>/gi, '>'); | |
return str; | |
}; | |
String.prototype.getExtension = function() | |
{ | |
var str = this; | |
str = str.toLowerCase(); | |
var end = str.split('.'); | |
return utils.arrays.end(end); | |
}; | |
String.prototype.parseHTML = function() | |
{ | |
var str = this; | |
str = str.replace(/</g, '<'); | |
str = str.replace(/>/g, '>'); | |
return str; | |
}; | |
String.prototype.htmlCharsDecode = function(quote) | |
{ | |
var str = this; | |
var optTemp = 0, | |
i = 0, | |
noquotes = false; | |
if (typeof quote === 'undefined') | |
{ | |
quote = 2; | |
} | |
str = str.toString().replace(/</g, '<').replace(/>/g, '>'); | |
var OPTS = | |
{ | |
'ENT_NOQUOTES' : 0, | |
'ENT_HTML_QUOTE_SINGLE' : 1, | |
'ENT_HTML_QUOTE_DOUBLE' : 2, | |
'ENT_COMPAT' : 2, | |
'ENT_QUOTES' : 3, | |
'ENT_IGNORE' : 4 | |
}; | |
if (quote === 0) | |
{ | |
noquotes = true; | |
} | |
if (typeof quote !== 'number') | |
{ | |
quote = [].concat(quote); | |
for (i = 0; i < quote.length; i++) | |
{ | |
if (OPTS[quote[i]] === 0) | |
{ | |
noquotes = true; | |
} | |
else if (OPTS[quote[i]]) | |
{ | |
optTemp = optTemp | OPTS[quote[i]]; | |
} | |
} | |
quote = optTemp; | |
} | |
if (!noquotes) | |
{ | |
str = str.replace(/"/g, '"'); | |
} | |
str = str.replace(/&/g, '&'); | |
str = str.replace(/�*39;/g, "'"); | |
str = str.replace(/'|�*27;/g, "'"); | |
str = str.replace(/"/g, '"'); | |
str = str.replace(/\\{2,}/g, '').replace(/\\'/g, "'").replace(/\\"/g, '"'); | |
return str; | |
}; | |
String.prototype.isEmpty = function() | |
{ | |
if (this === '') return true; | |
else return false; | |
}; | |
String.prototype.remove = function(_regex) | |
{ | |
var regex = utils.regex(_regex); | |
if (!regex) return this; | |
return this.replace(regex, ''); | |
}; | |
String.prototype.validate = function(type, allowEmpty) | |
{ | |
var str = this; | |
if (str.length === 0 && !allowEmpty) return false; | |
if (!utils.variables.get(type)) return true; | |
var regex; | |
allowEmpty = allowEmpty || false; | |
if (str.length === 0 && allowEmpty) return true; | |
if (type === 'date') | |
{ | |
var test = false; | |
regex = utils.regex('date'); | |
for(var index in regex) | |
{ | |
regex = regex[index]; | |
if (regex.lastIndex) regex.lastIndex = 0; | |
if (regex.test(str) === true) | |
{ | |
test = true; | |
break; | |
} | |
} | |
if (!test) | |
test = str.strToTime(); | |
return test; | |
} | |
if (type === 'emailMultiple') | |
{ | |
var tempStr = str.explode(); | |
var count = tempStr.length; | |
var _pass = 0; | |
regex = utils.regex('email'); | |
for(var i in tempStr) | |
{ | |
if (regex.lastIndex) regex.lastIndex = 0; | |
if (regex.test(tempStr[i].trim()) === true) _pass++; | |
} | |
return ( _pass === count ? true : false ); | |
} | |
regex = utils.regex(type); | |
if (!regex) return true; | |
if (regex !== null) | |
{ | |
if (regex.lastIndex) regex.lastIndex = 0; | |
return regex.test(str); | |
} | |
if (str.length === 0 && !allowEmpty) return false; | |
}; | |
String.prototype.wordwrap = function(charsLength, breakString, cut) | |
{ | |
var m = (charsLength !== null ? charsLength : 50); | |
var b = (breakString !== null ? breakString : "<br>"); | |
var c = (cut !== null ? cut : false); | |
var i, j, l, s, r, str = this; | |
str += ''; | |
if (m < 1) return str; | |
for (i = -1, l = (r = str.split(/\r\n|\n|\r/)).length; ++i < l; r[i] += s) | |
{ | |
for (s = r[i], r[i] = ""; s.length > m; r[i] += s.slice(0, j) + ((s = s.slice(j)).length ? b : "")) | |
{ | |
j = c === 2 || (j = s.slice(0, m + 1).match(/\S*(\s)?$/))[1] ? m : j.input.length - j[0].length || c === 1 && m || j.input.length + (j = s.slice(m).match(/^\S*/)).input.length; | |
} | |
} | |
return r.join(b); | |
}; | |
}; | |
/* !Modules - Arrays */ | |
this.arrays = function() | |
{ | |
console.log('Utilities(): arrays()'); | |
utils.arrays.deviation = function(array, linear) | |
{ | |
linear = linear || true; | |
if (utils.arrays.size(array) > 1 && linear) | |
{ | |
return Math.abs(array[1] - array[0]); | |
} | |
return 0; | |
}; | |
utils.arrays.end = function(obj) | |
{ | |
var len = utils.arrays.size(obj); | |
return obj[len - 1]; | |
}; | |
utils.arrays.key = function(array, val) | |
{ | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
if (i === val) | |
return true; | |
return false; | |
}; | |
utils.arrays.insert = function(a, b, array) | |
{ | |
var temp = array[a]; | |
array.splice(a, 1); | |
array.splice(b, 0, temp); | |
return array; | |
}; | |
utils.arrays.intersection = function(a, b, strict) | |
{ | |
if (!strict) return _.intersection(a, b); | |
var _array = []; | |
var _len = a.length > b.length ? a.length : b.length; | |
for(var i = 0; i < _len; i++) | |
if (a[i] == b[i]) | |
_array[i] = ( a[i] || b[i] ); | |
return _array; | |
}; | |
utils.arrays.numeric = function(array) | |
{ | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
if (!isNaN(array[i])) | |
return true; | |
return false; | |
}; | |
utils.arrays.match = function(array, value) | |
{ | |
var match = 0; | |
var index = 0; | |
var min = utils.arrays.min(array, true); | |
var max = utils.arrays.max(array, true); | |
if (value > max.value) return { index : max.index, value : max.value }; | |
var deviation = utils.arrays.deviation(array); | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
{ | |
var m = Math.abs(value - array[i]); | |
if (m < deviation) | |
{ | |
deviation = m; | |
match = array[i]; | |
index = i; | |
} | |
} | |
return { index : index, value : match }; | |
}; | |
utils.arrays.max = function(array, robject) | |
{ | |
var max = 0; | |
var object = {}; | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
{ | |
if (array[i] > max) | |
{ | |
object = { index : i, value : array[i] }; | |
max = array[i]; | |
} | |
} | |
return robject ? object : max; | |
}; | |
utils.arrays.merge = function(a, b) | |
{ | |
if (!a || !b) return {}; | |
var temp = {}; | |
var A = utils.arrays.size(a); | |
var B = utils.arrays.size(a); | |
for(var i = 0; i < A; i++) | |
temp[i] = a[i]; | |
for(var i = 0; i < B; i++) | |
temp[i] = b[i]; | |
return temp; | |
}; | |
utils.arrays.min = function(array, robject) | |
{ | |
var min = 0; | |
var object = {}; | |
var len = utils.arrays.size(array); | |
var i; | |
for(i in array) break; | |
min = array[i]; | |
object = { index : i, value : array[i] }; | |
for(i = 0; i < len; i++) | |
{ | |
if (array[i] < min) | |
{ | |
object = { index : i, value : array[i] }; | |
min = array[i]; | |
} | |
} | |
return robject ? object : min; | |
}; | |
utils.arrays.range = function(low, high, step) | |
{ | |
var matrix = []; | |
var inival, | |
endval, | |
plus; | |
var walker = step || 1; | |
var chars = false; | |
if (!isNaN(low) && !isNaN(high)) | |
{ | |
inival = low; | |
endval = high; | |
} | |
else if (isNaN(low) && isNaN(high)) | |
{ | |
chars = true; | |
inival = low.charCodeAt(0); | |
endval = high.charCodeAt(0); | |
} | |
else | |
{ | |
inival = ( isNaN(low) ? 0 : low ); | |
endval = ( isNaN(high) ? 0 : high ); | |
} | |
plus = ((inival > endval) ? false : true); | |
if (plus) | |
{ | |
while(inival <= endval) | |
{ | |
matrix.push(((chars) ? String.fromCharCode(inival) : inival)); | |
inival += walker; | |
} | |
} | |
else | |
{ | |
while(inival >= endval) | |
{ | |
matrix.push(((chars) ? String.fromCharCode(inival) : inival)); | |
inival -= walker; | |
} | |
} | |
return matrix; | |
}; | |
utils.arrays.size = function(array) | |
{ | |
if (!array) return 0; | |
if (array.length) return array.length; | |
return _.size(array); | |
}; | |
utils.arrays.sum = function(array) | |
{ | |
var len = utils.arrays.size(array); | |
var sum = 0; | |
for(var i = 0; i < len; i++) | |
sum += parseFloat(array[i]) || 0; | |
return sum; | |
}; | |
utils.arrays.swap = function(a, b, array) | |
{ | |
var temp = array[a]; | |
array[a] = array[b]; | |
array[b] = temp; | |
return array; | |
}; | |
utils.arrays.trim = function(array) | |
{ | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
if (typeof array[i] === 'string') | |
if (array[i].length > 0 && !isNaN(array[i])) | |
array[i] = parseFloat(array[i]); | |
else | |
array[i] = array[i].trim(); | |
return array; | |
}; | |
utils.arrays.value = function(array, val) | |
{ | |
if (typeof array.indexOf === 'function') return array.indexOf(val); | |
var len = utils.arrays.size(array); | |
for(var i = 0; i < len; i++) | |
if (array[i] === val) | |
return i; | |
return -1; | |
}; | |
}; | |
/* !Modules - Collections */ | |
this.collections = function() | |
{ | |
console.log('Utilities(): collections()'); | |
utils.collections.append = function(obj, value, fields) | |
{ | |
if (typeof obj !== 'object') return false; | |
if (!fields) | |
{ | |
var len = utils.arrays.size(obj); | |
obj[len] = value; | |
} | |
else if (typeof fields === 'string') | |
{ | |
obj[fields] = value; | |
} | |
else if (typeof fields === 'object') | |
{ | |
var lastField = fields.length - 1; | |
for (var i = 0; i < lastField; i++) | |
{ | |
var key = fields[i]; | |
if (!(key in obj)) | |
{ | |
obj[key] = {}; | |
obj = obj[key]; | |
} | |
else obj = obj[key]; | |
} | |
obj[fields[lastField]] = value; | |
} | |
}; | |
/* | |
Returns boolean based on the value of two objects. | |
@a - First Collection. | |
@b - Second Collection. | |
*/ | |
utils.collections.compare = function(a, b) | |
{ | |
if (JSON && JSON.stringify) return JSON.stringify(a) == JSON.stringify(b); | |
return false; | |
}; | |
/* | |
Returns value based on set of keys passed. | |
@object - Input {key : value} collection. | |
@keys - Keys to search for : String() or Array(). | |
*/ | |
utils.collections.contains = function(object, keys) | |
{ | |
keys = typeof keys === 'object' ? keys : [keys]; | |
var len = keys.length; | |
if (typeof object !== 'object' || !keys || len === 0) return null; | |
var curr = object[keys[0]]; | |
if (len === 1) return curr; | |
for(var i = 1; i < len; i++) | |
{ | |
if (curr && utils.object.isset(curr[keys[i]]) && i < ( len - 1 )) curr = curr[keys[i]]; | |
else if (curr && utils.object.isset(curr[keys[i]]) && i === ( len - 1 )) return curr[keys[i]]; | |
else if (!curr) return curr; | |
} | |
return null; | |
}; | |
utils.collections.css = function(css) | |
{ | |
var s = {}; | |
if (!css) return s; | |
if (css instanceof CSSStyleDeclaration) | |
{ | |
for(var i in css) | |
if ((css[i]).toLowerCase) | |
s[(css[i]).toLowerCase()] = (css[css[i]]); | |
} | |
else if (typeof css == "string") | |
{ | |
css = css.split("; "); | |
for(var i in css) | |
{ | |
var l = css[i].split(": "); | |
s[l[0].toLowerCase()] = (l[1]); | |
} | |
} | |
return s; | |
}; | |
utils.collections.difference = function(a, b) | |
{ | |
var _return = {}; | |
for(var i in a) | |
if (a[i] !== b[i]) | |
_return[i] = a[i] || b[i]; | |
return _return; | |
}; | |
/* | |
Returns int. | |
@object - Input {key : value} collection. | |
@MAX_DEPTH - To prevent Max Stack Overflow a maximum depth is required. | |
*/ | |
utils.collections.depth = function(object, MAX_DEPTH) | |
{ | |
var level = 1; | |
MAX_DEPTH = MAX_DEPTH || 100; | |
for(var i in object) | |
{ | |
if (!object.hasOwnProperty(i)) continue; | |
if (typeof object[i] == 'object') | |
{ | |
var depth = utils.collections.depth(object[i], MAX_DEPTH) + 1; | |
level = Math.max(depth, level); | |
if (level > MAX_DEPTH) return MAX_DEPTH; | |
} | |
} | |
return level; | |
}; | |
/* | |
Returns value. | |
@object - Input {key : value} collection. | |
@key - Key to search for. | |
@value - Value to search for. | |
@find - Key in object within same tree level as @key. | |
*/ | |
utils.collections.find = function(object, key, value, find) | |
{ | |
if (( value && object[key] == value ) || ( !value && object[key] )) return find && object[find] ? object[find] : object[key]; | |
for(var i in object) | |
{ | |
if (( !value && i == key ) || ( value && object[i] == value )) | |
return find && object[find] ? object[find] : object[key]; | |
else if (_.isObject(object[i])) | |
{ | |
var r = utils.collections.find(object[i], key, value, find); | |
if (r) return r; | |
} | |
} | |
return null; | |
}; | |
utils.collections.get = function(obj, fields) | |
{ | |
var lastField = fields.length - 1; | |
for (var i = 0; i < lastField; i++) | |
{ | |
var key = fields[i]; | |
if (!(key in obj)) { obj[key] = {}; obj = obj[key]; } | |
else { obj = obj[key]; } | |
} | |
return (obj[fields[lastField]]) ? obj[fields[lastField]] : null; | |
}; | |
utils.collections.implode = function(collection, glue, delimiter) | |
{ | |
delimiter = delimiter || ', '; | |
if (!glue || !collection || typeof collection !== 'object') return null; | |
var string = []; | |
for(var i in collection) | |
string.push(i + glue + collection[i]); | |
return string.join(delimiter); | |
}; | |
utils.collections.keys = function(collection, delimiter) | |
{ | |
delimiter = delimiter; | |
if (!collection || typeof collection !== 'object') return null; | |
var string = _.keys(collection); | |
return delimiter ? string.join(delimiter) : string; | |
}; | |
utils.collections.lowercase = function(object, useKey) | |
{ | |
var R = {}; | |
for(var i in object) if (useKey) R[String(i).toLowerCase()] = object[i]; else ( R[i] = typeof object[i] === 'string' ? object[i].toLowerCase() : object[i] ); | |
return R; | |
}; | |
/* Turn boject into URL Query String */ | |
utils.collections.params = function(json, encode) | |
{ | |
encode = typeof encode === 'boolean' ? encode : true; | |
return '?' + | |
Object.keys(json).map(function(key) | |
{ | |
if (encode) return encodeURIComponent(key) + '=' + encodeURIComponent(json[key]); | |
else return key + '=' + json[key]; | |
}).join('&'); | |
}; | |
/* | |
Returns arrays of objects of property arrays and levels - [{ level : int, properties : [] }]. | |
@object - Input {key : value} collection. | |
@delimiter - Separator for temporary string. | |
@MAX_DEPTH - To prevent Max Stack Overflow a maximum depth is required. | |
*/ | |
utils.collections.properties = function(object, delimiter, MAX_DEPTH, LEVEL, KEYS, stack) | |
{ | |
MAX_DEPTH = MAX_DEPTH || 50; | |
KEYS = KEYS || []; | |
stack = stack || ''; | |
delimiter = delimiter || ' === '; | |
LEVEL = LEVEL || 0; | |
LEVEL++; | |
for(var i in object) | |
{ | |
if (object.hasOwnProperty(i)) | |
{ | |
if (LEVEL > MAX_DEPTH) return KEYS; | |
if (LEVEL === 1) KEYS.push({ depth : LEVEL, properties : [i] }); | |
if (typeof object[i] === 'object') utils.collections.properties(object[i], delimiter, MAX_DEPTH, LEVEL, KEYS, stack + delimiter + i); | |
else if (LEVEL > 1) KEYS.push({ depth : LEVEL, properties : (stack + delimiter + i).trim(delimiter).explode(delimiter) }); | |
} | |
} | |
return KEYS; | |
}; | |
utils.collections.reduce = function(object, mixedobj, json) | |
{ | |
if (typeof mixedobj !== 'string' && typeof mixedobj !== 'object') return null; | |
var array = json && typeof mixedobj === 'string' ? mixedobj.split('.') : mixedobj; | |
var len = array.length; | |
for(var i in array) | |
{ | |
if (object[array[i]]) | |
{ | |
if (i === len - 1) return object[array[i]]; | |
else return utils.collections.reduce(object[array[i]], ( json ? _.rest(array, i).join('.') : _.rest(array, i) ), json); | |
} | |
} | |
return json ? object : null; | |
}; | |
/* | |
Returns array of collections. | |
@object - Input {key : value} collection. | |
@key - Key to search for. | |
@value - Value to search for. | |
@depth - How deep to go while recursively searching - default = utils.collections.depth. | |
*/ | |
utils.collections.search = function(object, value, key, array, depth, MAX_DEPTH) | |
{ | |
key = typeof key === 'object' && key ? key : String(key); | |
value = String(value); | |
depth = depth || 0; | |
MAX_DEPTH = MAX_DEPTH || utils.collections.depth(object); | |
array = array || []; | |
if (depth > MAX_DEPTH) return array; | |
depth++; | |
for(var i in object) | |
{ | |
var curr = object[i]; | |
var isObj = _.isObject(curr); | |
if ( typeof key === 'object' && key > 0 && ( String(utils.collections.contains(curr, key)).indexOf(value) >= 0 ) ) array.push(curr); | |
else if ( !isObj && ( ( key && key === String(i) ) || ( value && String(curr).indexOf(value) >= 0 ) ) ) array.push(object); | |
else if (isObj) utils.collections.search(curr, value, key, array, depth, MAX_DEPTH); | |
} | |
return array; | |
}; | |
utils.collections.unique = function(collection) | |
{ | |
if (!collection || typeof collection !== 'object') return collection; | |
return _.filter(collection, function(element, index) | |
{ | |
for(index += 1; index < collection.length; index += 1) | |
{ | |
if (_.isEqual(element, collection[index])) return false; | |
} | |
return true; | |
}); | |
}; | |
utils.collections.values = function(collection, delimiter) | |
{ | |
delimiter = delimiter; | |
if (!collection || typeof collection !== 'object') return null; | |
var string = _.values(collection); | |
return delimiter ? string.join(delimiter) : string; | |
}; | |
}; | |
/* !Modules - JSON */ | |
this.json = function() | |
{ | |
console.log('Utilities(): json()'); | |
utils.json.parse = function(str) | |
{ | |
var _json = {}; | |
try | |
{ | |
_json = $.parseJSON(str); | |
} | |
catch(e) | |
{ | |
_json.error = e; | |
} | |
return _json; | |
}; | |
}; | |
/* !Modules - Variables */ | |
this.variables = function() | |
{ | |
console.log('Utilities(): variables()'); | |
utils.variables.get = function(obj) | |
{ | |
var undef, i; | |
var emptyValues = [undef, null, ""]; | |
for (i in emptyValues) | |
{ | |
if (obj === emptyValues[i]) return null; | |
} | |
return obj; | |
}; | |
}; | |
/* !Modules - Arguments */ | |
this.arguments = function(array, caller) | |
{ | |
console.log('Utilities(): arguments()'); | |
if (caller) return array.callee.caller.caller.toString(); | |
if (typeof array !== 'object') return null; | |
var args = {}; | |
for(var i in array) | |
{ | |
if (_.isNull(array[i]) || _.isUndefined(array[i])) continue; | |
var dom = typeof array[i] === 'object' ? $(array[i]).get(0) : null; | |
if (dom && _.isElement(dom)) | |
{ | |
args.dom = array[i]; | |
continue; | |
} | |
if (_.isFunction(array[i])) | |
{ | |
args.callback = array[i]; | |
continue; | |
} | |
if (_.isArray(array[i])) | |
{ | |
args.array = array[i]; | |
continue; | |
} | |
args[typeof array[i]] = array[i]; | |
} | |
return args; | |
}; | |
/* !Modules - Object */ | |
this.object = function() | |
{ | |
console.log('Utilities(): object()'); | |
utils.object.isset = function() | |
{ | |
var a = arguments; | |
if (a) return true; | |
var l = a.length, | |
i = 0, | |
undef; | |
if (l === 0) return false; | |
while (i !== l) | |
{ | |
if (a[i] === undef || a[i] === null) return false; | |
i++; | |
} | |
return true; | |
}; | |
utils.object.size = function(object) | |
{ | |
var objects = [object]; | |
var size = 0; | |
for(var index = 0; index < objects.length; index++) | |
{ | |
switch(typeof objects[index]) | |
{ | |
case 'boolean': | |
size += 4; | |
break; | |
case 'number': | |
size += 8; | |
break; | |
case 'string': | |
size += 2 * objects[index].length; | |
break; | |
case 'object': | |
if (Object.prototype.toString.call(objects[index]) != '[object Array]') | |
{ | |
for(var key in objects[index]) size += 2 * key.length; | |
} | |
for(var key in objects[index]) | |
{ | |
var processed = false; | |
for(var search = 0; search < objects.length; search++) | |
{ | |
if (objects[search] === objects[index][key]) | |
{ | |
processed = true; | |
break; | |
} | |
} | |
if (!processed) objects.push(objects[index][key]); | |
} | |
} | |
} | |
return size; | |
}; | |
}; | |
this.regex = function(regex) | |
{ | |
var regExp = { | |
"date" : { | |
"sqlDate" : /^(?:(?:(?:(?:(?:1[6-9]|[2-9]\d)?(?:0[48]|[2468][048]|[13579][26])|(?:(?:16|[2468][048]|[3579][26])00)))(\/|-|\.)(?:0?2\1(?:29)))|(?:(?:(?:1[6-9]|[2-9]\d)?\d{2})(\/|-|\.)(?:(?:(?:0?[13578]|1[02])\2(?:31))|(?:(?:0?[1,3-9]|1[0-2])\2(29|30))|(?:(?:0?[1-9])|(?:1[0-2]))\2(?:0?[1-9]|1\d|2[0-8]))))$/gi, | |
"usDate" : /^(((((((0?[13578])|(1[02]))[\.\-\/]?((0?[1-9])|([12]\d)|(3[01])))|(((0?[469])|(11))[\.\-\/]?((0?[1-9])|([12]\d)|(30)))|((0?2)[\.\-\/]?((0?[1-9])|(1\d)|(2[0-8]))))[\.\-\/]?(((19)|(20))?([\d][\d]))))|((0?2)[\.\-\/]?(29)[\.\-\/]?(((19)|(20))?(([02468][048])|([13579][26])))))$/gi, | |
"eurDate" : /^(?=\d)(?:(?!(?:(?:0?[5-9]|1[0-4])(?:\.|-|\/)10(?:\.|-|\/)(?:1582))|(?:(?:0?[3-9]|1[0-3])(?:\.|-|\/)0?9(?:\.|-|\/)(?:1752)))(31(?!(?:\.|-|\/)(?:0?[2469]|11))|30(?!(?:\.|-|\/)0?2)|(?:29(?:(?!(?:\.|-|\/)0?2(?:\.|-|\/))|(?=\D0?2\D(?:(?!000[04]|(?:(?:1[^0-6]|[2468][^048]|[3579][^26])00))(?:(?:(?:\d\d)(?:[02468][048]|[13579][26])(?!\x20BC))|(?:00(?:42|3[0369]|2[147]|1[258]|09)\x20BC))))))|2[0-8]|1\d|0?[1-9])([-.\/])(1[012]|(?:0?[1-9]))\2((?=(?:00(?:4[0-5]|[0-3]?\d)\x20BC)|(?:\d{4}(?:$|(?=\x20\d)\x20)))\d{4}(?:\x20BC)?)(?:$|(?=\x20\d)\x20))?((?:(?:0?[1-9]|1[012])(?::[0-5]\d){0,2}(?:\x20[aApP][mM]))|(?:[01]\d|2[0-3])(?::[0-5]\d){1,2})?$/gi, | |
}, | |
"hexadecimal" : /^#?([a-f0-9]{6}|[a-f0-9]{3})$/gi, | |
"url" : /^(ftp\:|http\:|https\:)?\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/gi, | |
"urlsafe" : /^[a-z0-9\/\-]+$/g, | |
"image" : /^[a-z0-9\/\-.]+$/g, | |
"creditcard" : /^(?:4[0-9]{12}(?:[0-9]{3})?|5[1-5][0-9]{14}|6(?:011|5[0-9][0-9])[0-9]{12}|3[47][0-9]{13}|3(?:0[0-5]|[68][0-9])[0-9]{11}|(?:2131|1800|35\d{3})\d{11})$/g, | |
"URL" : /(((ftp|http|https):)?\/\/(\w+:{0,1}\w*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?)|(^[a-z0-9\/\-]+$)/g, | |
"formNameLimit" : /[^a-z0-9_]/g, | |
"email" : /([a-z0-9])(([\-a-z0-9._])*([a-z0-9]))*\@([a-z0-9])(([a-z0-9-])*([a-z0-9]))+(\.([a-z0-9])([-a-z0-9_-])?([a-z0-9])+)/gi, | |
"emailname" : /([\w\s]+)[\s]([a-z0-9])(([\-a-z0-9._])*([a-z0-9]))*\@([a-z0-9])(([a-z0-9-])*([a-z0-9]))+(\.([a-z0-9])([-a-z0-9_-])?([a-z0-9])+)/gi, | |
"word" : /\w/gi, | |
"birthyear" : /(?:(?:19|20)[0-9]{2})/g, | |
"alpha" : /^[A-Za-z]+$/gi, | |
"username" : /^[A-Za-z0-9-\.]{4,}$/gi, | |
"alphanumeric" : /^[A-Za-z0-9]+$/gi, | |
"alphanumericspace" : /^[A-Za-z0-9\s]+$/gi, | |
"alphanumerichyphen" : /^[A-Za-z0-9-]+$/gi, | |
"alphanumericunderscore": /^[A-Za-z0-9_]+$/gi, | |
"digits" : /\d/gi, | |
"integer" : /^\s*(\+|\-)?\d+\s*$/g, | |
"currency" : /^\s*(\+|\-)?((\d+(\.\d\d)?)|(\.\d\d))\s*$/g, | |
"time" : /^((([0]?[1-9]|1[0-2])(:|\.)[0-5][0-9]((:|\.)[0-5][0-9])?( )?(AM|am|aM|Am|PM|pm|pM|Pm))|(([0]?[0-9]|1[0-9]|2[0-3])(:|\.)[0-5][0-9]((:|\.)[0-5][0-9])?))$/gi, | |
"html" : /<(br|basefont|hr|input|source|frame|param|area|meta|!--|col|link|option|base|img|wbr|!DOCTYPE).*?>|<(a|abbr|acronym|address|applet|article|aside|audio|b|bdi|bdo|big|blockquote|body|button|canvas|caption|center|cite|code|colgroup|command|datalist|dd|del|details|dfn|dialog|dir|div|dl|dt|em|embed|fieldset|figcaption|figure|font|footer|form|frameset|head|header|hgroup|h1|h2|h3|h4|h5|h6|html|i|iframe|ins|kbd|keygen|label|legend|li|map|mark|menu|meter|nav|noframes|noscript|object|ol|optgroup|output|p|pre|progress|q|rp|rt|ruby|s|samp|script|section|select|small|span|strike|strong|style|sub|summary|sup|table|tbody|td|textarea|tfoot|th|thead|time|title|tr|track|tt|u|ul|var|video).*?<\/\2>/gi | |
}; | |
if (regex && regExp[regex]) return regExp[regex]; | |
else if (regex && !regExp[regex]) return null; | |
else return regExp; | |
}; | |
for(var i in arguments) if (typeof utils[arguments[i]] === 'function') utils[arguments[i]](); | |
}; | |
var utils; |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment