// source --> https://www.art-asahikawa.com/wp-content/plugins/contact-form-7-cost-calculator/frontend/js/autoNumeric-1.9.45.js /** * autoNumeric.js * @author: Bob Knothe * @author: Sokolov Yura * @version: 1.9.45 - 2015-06-13 GMT 5:00 PM / 19:00 * * Created by Robert J. Knothe on 2010-10-25. Please report any bugs to https://github.com/BobKnothe/autoNumeric * Contributor by Sokolov Yura on 2010-11-07 * * Copyright (c) 2011 Robert J. Knothe http://www.decorplanit.com/plugin/ * * The MIT License (http://www.opensource.org/licenses/mit-license.php) * * Permission is hereby granted, free of charge, to any person * obtaining a copy of this software and associated documentation * files (the "Software"), to deal in the Software without * restriction, including without limitation the rights to use, * copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the * Software is furnished to do so, subject to the following * conditions: * * The above copyright notice and this permission notice shall be * included in all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR * OTHER DEALINGS IN THE SOFTWARE. */ (function(factory) { if (typeof define === "function" && define.amd) { /** AMD. Register as an anonymous module. */ define(["jquery"], factory); } else if (typeof module === "object" && module.exports) { /** Node/CommonJS */ module.exports = factory(require("jquery")); } else { /** Browser globals */ factory(window.jQuery); } }(function($) { "use strict"; /*jslint browser: true*/ /*global jQuery: false*/ /*Cross browser routine for getting selected range/cursor position */ /** * Cross browser routine for getting selected range/cursor position */ function getElementSelection(that) { var position = {}; if (that.selectionStart === undefined) { that.focus(); var select = document.selection.createRange(); position.length = select.text.length; select.moveStart('character', -that.value.length); position.end = select.text.length; position.start = position.end - position.length; } else { position.start = that.selectionStart; position.end = that.selectionEnd; position.length = position.end - position.start; } return position; } /** * Cross browser routine for setting selected range/cursor position */ function setElementSelection(that, start, end) { if (that.selectionStart === undefined) { that.focus(); var r = that.createTextRange(); r.collapse(true); r.moveEnd('character', end); r.moveStart('character', start); r.select(); } else { that.selectionStart = start; that.selectionEnd = end; } } /** * run callbacks in parameters if any * any parameter could be a callback: * - a function, which invoked with jQuery element, parameters and this parameter name and returns parameter value * - a name of function, attached to $(selector).autoNumeric.functionName(){} - which was called previously */ function runCallbacks($this, settings) { /** * loops through the settings object (option array) to find the following * k = option name example k=aNum * val = option value example val=0123456789 */ $.each(settings, function(k, val) { if (typeof val === 'function') { settings[k] = val($this, settings, k); } else if (typeof $this.autoNumeric[val] === 'function') { /** * calls the attached function from the html5 data example: data-a-sign="functionName" */ settings[k] = $this.autoNumeric[val]($this, settings, k); } }); } /** * Converts the vMin, vMax & mDec string to numeric value */ function convertKeyToNumber(settings, key) { if (typeof(settings[key]) === 'string') { settings[key] *= 1; } } /** * Preparing user defined options for further usage * merge them with defaults appropriately */ function autoCode($this, settings) { runCallbacks($this, settings); settings.tagList = ['b', 'caption', 'cite', 'code', 'dd', 'del', 'div', 'dfn', 'dt', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ins', 'kdb', 'label', 'li', 'output', 'p', 'q', 's', 'sample', 'span', 'strong', 'td', 'th', 'u', 'var']; var vmax = settings.vMax.toString().split('.'), vmin = (!settings.vMin && settings.vMin !== 0) ? [] : settings.vMin.toString().split('.'); convertKeyToNumber(settings, 'vMax'); convertKeyToNumber(settings, 'vMin'); convertKeyToNumber(settings, 'mDec'); /** set mDec if not defined by user */ settings.mDec = (settings.mRound === 'CHF') ? '2' : settings.mDec; settings.allowLeading = true; settings.aNeg = settings.vMin < 0 ? '-' : ''; vmax[0] = vmax[0].replace('-', ''); vmin[0] = vmin[0].replace('-', ''); settings.mInt = Math.max(vmax[0].length, vmin[0].length, 1); if (settings.mDec === null) { var vmaxLength = 0, vminLength = 0; if (vmax[1]) { vmaxLength = vmax[1].length; } if (vmin[1]) { vminLength = vmin[1].length; } settings.mDec = Math.max(vmaxLength, vminLength); } /** set alternative decimal separator key */ if (settings.altDec === null && settings.mDec > 0) { if (settings.aDec === '.' && settings.aSep !== ',') { settings.altDec = ','; } else if (settings.aDec === ',' && settings.aSep !== '.') { settings.altDec = '.'; } } /** cache regexps for autoStrip */ var aNegReg = settings.aNeg ? '([-\\' + settings.aNeg + ']?)' : '(-?)'; settings.aNegRegAutoStrip = aNegReg; settings.skipFirstAutoStrip = new RegExp(aNegReg + '[^-' + (settings.aNeg ? '\\' + settings.aNeg : '') + '\\' + settings.aDec + '\\d]' + '.*?(\\d|\\' + settings.aDec + '\\d)'); settings.skipLastAutoStrip = new RegExp('(\\d\\' + settings.aDec + '?)[^\\' + settings.aDec + '\\d]\\D*$'); var allowed = '-' + settings.aNum + '\\' + settings.aDec; settings.allowedAutoStrip = new RegExp('[^' + allowed + ']', 'gi'); settings.numRegAutoStrip = new RegExp(aNegReg + '(?:\\' + settings.aDec + '?(\\d+\\' + settings.aDec + '\\d+)|(\\d*(?:\\' + settings.aDec + '\\d*)?))'); return settings; } /** * strips all unwanted characters and leave only a number alert */ function autoStrip(s, settings, strip_zero) { if (settings.aSign) { /** remove currency sign */ while (s.indexOf(settings.aSign) > -1) { s = s.replace(settings.aSign, ''); } } s = s.replace(settings.skipFirstAutoStrip, '$1$2'); /** first replace anything before digits */ s = s.replace(settings.skipLastAutoStrip, '$1'); /** then replace anything after digits */ s = s.replace(settings.allowedAutoStrip, ''); /** then remove any uninterested characters */ if (settings.altDec) { s = s.replace(settings.altDec, settings.aDec); } /** get only number string */ var m = s.match(settings.numRegAutoStrip); s = m ? [m[1], m[2], m[3]].join('') : ''; if ((settings.lZero === 'allow' || settings.lZero === 'keep') && strip_zero !== 'strip') { var parts = [], nSign = ''; parts = s.split(settings.aDec); if (parts[0].indexOf('-') !== -1) { nSign = '-'; parts[0] = parts[0].replace('-', ''); } if (parts[0].length > settings.mInt && parts[0].charAt(0) === '0') { /** strip leading zero if need */ parts[0] = parts[0].slice(1); } s = nSign + parts.join(settings.aDec); } if ((strip_zero && settings.lZero === 'deny') || (strip_zero && settings.lZero === 'allow' && settings.allowLeading === false)) { var strip_reg = '^' + settings.aNegRegAutoStrip + '0*(\\d' + (strip_zero === 'leading' ? ')' : '|$)'); strip_reg = new RegExp(strip_reg); s = s.replace(strip_reg, '$1$2'); } return s; } /** * places or removes brackets on negative values * works only when with pSign: 'p' */ function negativeBracket(s, settings) { if (settings.pSign === 'p') { var brackets = settings.nBracket.split(','); if (!settings.hasFocus && !settings.removeBrackets) { s = s.replace(settings.aNeg, ''); s = brackets[0] + s + brackets[1]; } else if ((settings.hasFocus && s.charAt(0) === brackets[0]) || (settings.removeBrackets && s.charAt(0) === brackets[0])) { s = s.replace(brackets[0], settings.aNeg); s = s.replace(brackets[1], ''); } } return s; } /** * function to handle numbers less than 0 that are stored in Exponential notation ex: .0000001 stored as 1e-7 */ function checkValue(value, settings) { if (value) { var checkSmall = +value; if (checkSmall < 0.000001 && checkSmall > -1) { value = +value; if (value < 0.000001 && value > 0) { value = (value + 10).toString(); value = value.substring(1); } if (value < 0 && value > -1) { value = (value - 10).toString(); value = '-' + value.substring(2); } value = value.toString(); } else { var parts = value.split('.'); if (parts[1] !== undefined) { if (+parts[1] === 0) { value = parts[0]; } else { parts[1] = parts[1].replace(/0*$/, ''); value = parts.join('.'); } } } } return (settings.lZero === 'keep') ? value : value.replace(/^0*(\d)/, '$1'); } /** * prepare number string to be converted to real number */ function fixNumber(s, aDec, aNeg) { if (aDec && aDec !== '.') { s = s.replace(aDec, '.'); } if (aNeg && aNeg !== '-') { s = s.replace(aNeg, '-'); } if (!s.match(/\d/)) { s += '0'; } return s; } /** * prepare real number to be converted to our format */ function presentNumber(s, aDec, aNeg) { if (aNeg && aNeg !== '-') { s = s.replace('-', aNeg); } if (aDec && aDec !== '.') { s = s.replace('.', aDec); } return s; } /** * private function to check for empty value */ function checkEmpty(iv, settings, signOnEmpty) { if (iv === '' || iv === settings.aNeg) { if (settings.wEmpty === 'zero') { return iv + '0'; } if (settings.wEmpty === 'sign' || signOnEmpty) { return iv + settings.aSign; } return iv; } return null; } /** * private function that formats our number */ function autoGroup(iv, settings) { iv = autoStrip(iv, settings); var testNeg = iv.replace(',', '.'), empty = checkEmpty(iv, settings, true); if (empty !== null) { return empty; } var digitalGroup = ''; if (settings.dGroup === 2) { digitalGroup = /(\d)((\d)(\d{2}?)+)$/; } else if (settings.dGroup === 4) { digitalGroup = /(\d)((\d{4}?)+)$/; } else { digitalGroup = /(\d)((\d{3}?)+)$/; } /** splits the string at the decimal string */ var ivSplit = iv.split(settings.aDec); if (settings.altDec && ivSplit.length === 1) { ivSplit = iv.split(settings.altDec); } /** assigns the whole number to the a variable (s) */ var s = ivSplit[0]; if (settings.aSep) { while (digitalGroup.test(s)) { /** re-inserts the thousand separator via a regular expression */ s = s.replace(digitalGroup, '$1' + settings.aSep + '$2'); } } if (settings.mDec !== 0 && ivSplit.length > 1) { if (ivSplit[1].length > settings.mDec) { ivSplit[1] = ivSplit[1].substring(0, settings.mDec); } /** joins the whole number with the decimal value */ iv = s + settings.aDec + ivSplit[1]; } else { /** if whole numbers only */ iv = s; } if (settings.aSign) { var has_aNeg = iv.indexOf(settings.aNeg) !== -1; iv = iv.replace(settings.aNeg, ''); iv = settings.pSign === 'p' ? settings.aSign + iv : iv + settings.aSign; if (has_aNeg) { iv = settings.aNeg + iv; } } if (testNeg < 0 && settings.nBracket !== null) { /** removes the negative sign and places brackets */ iv = negativeBracket(iv, settings); } return iv; } /** * round number after setting by pasting or $().autoNumericSet() * private function for round the number * please note this handled as text - JavaScript math function can return inaccurate values * also this offers multiple rounding methods that are not easily accomplished in JavaScript */ function autoRound(iv, settings) { /** value to string */ iv = (iv === '') ? '0' : iv.toString(); convertKeyToNumber(settings, 'mDec'); /** set mDec to number needed when mDec set by 'update method */ if (settings.mRound === 'CHF') { iv = (Math.round(iv * 20) / 20).toString(); } var ivRounded = '', i = 0, nSign = '', rDec = (typeof(settings.aPad) === 'boolean' || settings.aPad === null) ? (settings.aPad ? settings.mDec : 0) : +settings.aPad; var truncateZeros = function(ivRounded) { /** truncate not needed zeros */ var regex = (rDec === 0) ? (/(\.(?:\d*[1-9])?)0*$/) : rDec === 1 ? (/(\.\d(?:\d*[1-9])?)0*$/) : new RegExp('(\\.\\d{' + rDec + '}(?:\\d*[1-9])?)0*$'); ivRounded = ivRounded.replace(regex, '$1'); /** If there are no decimal places, we don't need a decimal point at the end */ if (rDec === 0) { ivRounded = ivRounded.replace(/\.$/, ''); } return ivRounded; }; if (iv.charAt(0) === '-') { /** Checks if the iv (input Value)is a negative value */ nSign = '-'; iv = iv.replace('-', ''); /** removes the negative sign will be added back later if required */ } if (!iv.match(/^\d/)) { /** append a zero if first character is not a digit (then it is likely to be a dot)*/ iv = '0' + iv; } if (nSign === '-' && +iv === 0) { /** determines if the value is zero - if zero no negative sign */ nSign = ''; } if ((+iv > 0 && settings.lZero !== 'keep') || (iv.length > 0 && settings.lZero === 'allow')) { /** trims leading zero's if needed */ iv = iv.replace(/^0*(\d)/, '$1'); } var dPos = iv.lastIndexOf('.'), /** virtual decimal position */ vdPos = (dPos === -1) ? iv.length - 1 : dPos, /** checks decimal places to determine if rounding is required */ cDec = (iv.length - 1) - vdPos; /** check if no rounding is required */ if (cDec <= settings.mDec) { ivRounded = iv; /** check if we need to pad with zeros */ if (cDec < rDec) { if (dPos === -1) { ivRounded += settings.aDec; } var zeros = '000000'; while (cDec < rDec) { zeros = zeros.substring(0, rDec - cDec); ivRounded += zeros; cDec += zeros.length; } } else if (cDec > rDec) { ivRounded = truncateZeros(ivRounded); } else if (cDec === 0 && rDec === 0) { ivRounded = ivRounded.replace(/\.$/, ''); } if (settings.mRound !== 'CHF') { return (+ivRounded === 0) ? ivRounded : nSign + ivRounded; } if (settings.mRound === 'CHF') { dPos = ivRounded.lastIndexOf('.'); iv = ivRounded; } } /** rounded length of the string after rounding */ var rLength = dPos + settings.mDec, tRound = +iv.charAt(rLength + 1), ivArray = iv.substring(0, rLength + 1).split(''), odd = (iv.charAt(rLength) === '.') ? (iv.charAt(rLength - 1) % 2) : (iv.charAt(rLength) % 2), onePass = true; if (odd !== 1) { odd = (odd === 0 && (iv.substring(rLength + 2, iv.length) > 0)) ? 1 : 0; } /*jslint white: true*/ if ((tRound > 4 && settings.mRound === 'S') || /** Round half up symmetric */ (tRound > 4 && settings.mRound === 'A' && nSign === '') || /** Round half up asymmetric positive values */ (tRound > 5 && settings.mRound === 'A' && nSign === '-') || /** Round half up asymmetric negative values */ (tRound > 5 && settings.mRound === 's') || /** Round half down symmetric */ (tRound > 5 && settings.mRound === 'a' && nSign === '') || /** Round half down asymmetric positive values */ (tRound > 4 && settings.mRound === 'a' && nSign === '-') || /** Round half down asymmetric negative values */ (tRound > 5 && settings.mRound === 'B') || /** Round half even "Banker's Rounding" */ (tRound === 5 && settings.mRound === 'B' && odd === 1) || /** Round half even "Banker's Rounding" */ (tRound > 0 && settings.mRound === 'C' && nSign === '') || /** Round to ceiling toward positive infinite */ (tRound > 0 && settings.mRound === 'F' && nSign === '-') || /** Round to floor toward negative infinite */ (tRound > 0 && settings.mRound === 'U') || /** round up away from zero */ (settings.mRound === 'CHF')) { /** Round Swiss FRanc */ /*jslint white: false*/ for (i = (ivArray.length - 1); i >= 0; i -= 1) { /** Round up the last digit if required, and continue until no more 9's are found */ if (ivArray[i] !== '.') { if (settings.mRound === 'CHF' && ivArray[i] <= 2 && onePass) { ivArray[i] = 0; onePass = false; break; } if (settings.mRound === 'CHF' && ivArray[i] <= 7 && onePass) { ivArray[i] = 5; onePass = false; break; } if (settings.mRound === 'CHF' && onePass) { ivArray[i] = 10; onePass = false; } else { ivArray[i] = +ivArray[i] + 1; } if (ivArray[i] < 10) { break; } if (i > 0) { ivArray[i] = '0'; } } } } ivArray = ivArray.slice(0, rLength + 1); /** Reconstruct the string, converting any 10's to 0's */ ivRounded = truncateZeros(ivArray.join('')); /** return rounded value */ return (+ivRounded === 0) ? ivRounded : nSign + ivRounded; } /** * truncate decimal part of a number */ function truncateDecimal(s, settings, paste) { var aDec = settings.aDec, mDec = settings.mDec; s = (paste === 'paste') ? autoRound(s, settings) : s; if (aDec && mDec) { var parts = s.split(aDec); /** truncate decimal part to satisfying length * cause we would round it anyway */ if (parts[1] && parts[1].length > mDec) { if (mDec > 0) { parts[1] = parts[1].substring(0, mDec); s = parts.join(aDec); } else { s = parts[0]; } } } return s; } /** * checking that number satisfy format conditions * and lays between settings.vMin and settings.vMax * and the string length does not exceed the digits in settings.vMin and settings.vMax */ function autoCheck(s, settings) { s = autoStrip(s, settings); s = truncateDecimal(s, settings); s = fixNumber(s, settings.aDec, settings.aNeg); var value = +s; return value >= settings.vMin && value <= settings.vMax; } /** * Holder object for field properties */ function AutoNumericHolder(that, settings) { this.settings = settings; this.that = that; this.$that = $(that); this.formatted = false; this.settingsClone = autoCode(this.$that, this.settings); this.value = that.value; } AutoNumericHolder.prototype = { init: function(e) { this.value = this.that.value; this.settingsClone = autoCode(this.$that, this.settings); this.ctrlKey = e.ctrlKey; this.cmdKey = e.metaKey; this.shiftKey = e.shiftKey; this.selection = getElementSelection(this.that); /** keypress event overwrites meaningful value of e.keyCode */ if (e.type === 'keydown' || e.type === 'keyup') { this.kdCode = e.keyCode; } this.which = e.which; this.processed = false; this.formatted = false; }, setSelection: function(start, end, setReal) { start = Math.max(start, 0); end = Math.min(end, this.that.value.length); this.selection = { start: start, end: end, length: end - start }; if (setReal === undefined || setReal) { setElementSelection(this.that, start, end); } }, setPosition: function(pos, setReal) { this.setSelection(pos, pos, setReal); }, getBeforeAfter: function() { var value = this.value, left = value.substring(0, this.selection.start), right = value.substring(this.selection.end, value.length); return [left, right]; }, getBeforeAfterStriped: function() { var parts = this.getBeforeAfter(); parts[0] = autoStrip(parts[0], this.settingsClone); parts[1] = autoStrip(parts[1], this.settingsClone); return parts; }, /** * strip parts from excess characters and leading zeroes */ normalizeParts: function(left, right) { var settingsClone = this.settingsClone; right = autoStrip(right, settingsClone); /** if right is not empty and first character is not aDec, */ /** we could strip all zeros, otherwise only leading */ var strip = right.match(/^\d/) ? true : 'leading'; left = autoStrip(left, settingsClone, strip); /** prevents multiple leading zeros from being entered */ if ((left === '' || left === settingsClone.aNeg) && settingsClone.lZero === 'deny') { if (right > '') { right = right.replace(/^0*(\d)/, '$1'); } } var new_value = left + right; /** insert zero if has leading dot */ if (settingsClone.aDec) { var m = new_value.match(new RegExp('^' + settingsClone.aNegRegAutoStrip + '\\' + settingsClone.aDec)); if (m) { left = left.replace(m[1], m[1] + '0'); new_value = left + right; } } /** insert zero if number is empty and io.wEmpty == 'zero' */ if (settingsClone.wEmpty === 'zero' && (new_value === settingsClone.aNeg || new_value === '')) { left += '0'; } return [left, right]; }, /** * set part of number to value keeping position of cursor */ setValueParts: function(left, right, paste) { var settingsClone = this.settingsClone, parts = this.normalizeParts(left, right), new_value = parts.join(''), position = parts[0].length; if (autoCheck(new_value, settingsClone)) { new_value = truncateDecimal(new_value, settingsClone, paste); if (position > new_value.length) { position = new_value.length; } this.value = new_value; this.setPosition(position, false); return true; } return false; }, /** * helper function for expandSelectionOnSign * returns sign position of a formatted value */ signPosition: function() { var settingsClone = this.settingsClone, aSign = settingsClone.aSign, that = this.that; if (aSign) { var aSignLen = aSign.length; if (settingsClone.pSign === 'p') { var hasNeg = settingsClone.aNeg && that.value && that.value.charAt(0) === settingsClone.aNeg; return hasNeg ? [1, aSignLen + 1] : [0, aSignLen]; } var valueLen = that.value.length; return [valueLen - aSignLen, valueLen]; } return [1000, -1]; }, /** * expands selection to cover whole sign * prevents partial deletion/copying/overwriting of a sign */ expandSelectionOnSign: function(setReal) { var sign_position = this.signPosition(), selection = this.selection; if (selection.start < sign_position[1] && selection.end > sign_position[0]) { /** if selection catches something except sign and catches only space from sign */ if ((selection.start < sign_position[0] || selection.end > sign_position[1]) && this.value.substring(Math.max(selection.start, sign_position[0]), Math.min(selection.end, sign_position[1])).match(/^\s*$/)) { /** then select without empty space */ if (selection.start < sign_position[0]) { this.setSelection(selection.start, sign_position[0], setReal); } else { this.setSelection(sign_position[1], selection.end, setReal); } } else { /** else select with whole sign */ this.setSelection(Math.min(selection.start, sign_position[0]), Math.max(selection.end, sign_position[1]), setReal); } } }, /** * try to strip pasted value to digits */ checkPaste: function() { if (this.valuePartsBeforePaste !== undefined) { var parts = this.getBeforeAfter(), oldParts = this.valuePartsBeforePaste; delete this.valuePartsBeforePaste; /** try to strip pasted value first */ parts[0] = parts[0].substr(0, oldParts[0].length) + autoStrip(parts[0].substr(oldParts[0].length), this.settingsClone); if (!this.setValueParts(parts[0], parts[1], 'paste')) { this.value = oldParts.join(''); this.setPosition(oldParts[0].length, false); } } }, /** * process pasting, cursor moving and skipping of not interesting keys * if returns true, further processing is not performed */ skipAllways: function(e) { var kdCode = this.kdCode, which = this.which, ctrlKey = this.ctrlKey, cmdKey = this.cmdKey, shiftKey = this.shiftKey; /** catch the ctrl up on ctrl-v */ if (((ctrlKey || cmdKey) && e.type === 'keyup' && this.valuePartsBeforePaste !== undefined) || (shiftKey && kdCode === 45)) { this.checkPaste(); return false; } /** codes are taken from http://www.cambiaresearch.com/c4/702b8cd1-e5b0-42e6-83ac-25f0306e3e25/Javascript-Char-Codes-Key-Codes.aspx * skip Fx keys, windows keys, other special keys * Thanks Ney Estrabelli for the FF for Mac meta key support "keycode 224" */ if ((kdCode >= 112 && kdCode <= 123) || (kdCode >= 91 && kdCode <= 93) || (kdCode >= 9 && kdCode <= 31) || (kdCode < 8 && (which === 0 || which === kdCode)) || kdCode === 144 || kdCode === 145 || kdCode === 45 || kdCode === 224) { return true; } if ((ctrlKey || cmdKey) && kdCode === 65) { /** if select all (a=65)*/ return true; } if ((ctrlKey || cmdKey) && (kdCode === 67 || kdCode === 86 || kdCode === 88)) { /** if copy (c=67) paste (v=86) or cut (x=88) */ if (e.type === 'keydown') { this.expandSelectionOnSign(); } if (kdCode === 86 || kdCode === 45) { /** try to prevent wrong paste */ if (e.type === 'keydown' || e.type === 'keypress') { if (this.valuePartsBeforePaste === undefined) { this.valuePartsBeforePaste = this.getBeforeAfter(); } } else { this.checkPaste(); } } return e.type === 'keydown' || e.type === 'keypress' || kdCode === 67; } if (ctrlKey || cmdKey) { return true; } if (kdCode === 37 || kdCode === 39) { /** jump over thousand separator */ var aSep = this.settingsClone.aSep, start = this.selection.start, value = this.that.value; if (e.type === 'keydown' && aSep && !this.shiftKey) { if (kdCode === 37 && value.charAt(start - 2) === aSep) { this.setPosition(start - 1); } else if (kdCode === 39 && value.charAt(start + 1) === aSep) { this.setPosition(start + 1); } } return true; } if (kdCode >= 34 && kdCode <= 40) { return true; } return false; }, /** * process deletion of characters * returns true if processing performed */ processAllways: function() { var parts; /** process backspace or delete */ if (this.kdCode === 8 || this.kdCode === 46) { if (!this.selection.length) { parts = this.getBeforeAfterStriped(); if (this.kdCode === 8) { parts[0] = parts[0].substring(0, parts[0].length - 1); } else { parts[1] = parts[1].substring(1, parts[1].length); } this.setValueParts(parts[0], parts[1]); } else { this.expandSelectionOnSign(false); parts = this.getBeforeAfterStriped(); this.setValueParts(parts[0], parts[1]); } return true; } return false; }, /** * process insertion of characters * returns true if processing performed */ processKeypress: function() { var settingsClone = this.settingsClone, cCode = String.fromCharCode(this.which), parts = this.getBeforeAfterStriped(), left = parts[0], right = parts[1]; /** start rules when the decimal character key is pressed */ /** always use numeric pad dot to insert decimal separator */ if (cCode === settingsClone.aDec || (settingsClone.altDec && cCode === settingsClone.altDec) || ((cCode === '.' || cCode === ',') && this.kdCode === 110)) { /** do not allow decimal character if no decimal part allowed */ if (!settingsClone.mDec || !settingsClone.aDec) { return true; } /** do not allow decimal character before aNeg character */ if (settingsClone.aNeg && right.indexOf(settingsClone.aNeg) > -1) { return true; } /** do not allow decimal character if other decimal character present */ if (left.indexOf(settingsClone.aDec) > -1) { return true; } if (right.indexOf(settingsClone.aDec) > 0) { return true; } if (right.indexOf(settingsClone.aDec) === 0) { right = right.substr(1); } this.setValueParts(left + settingsClone.aDec, right); return true; } /** * start rule on negative sign & prevent minus if not allowed */ if (cCode === '-' || cCode === '+') { if (!settingsClone.aNeg) { return true; } /** caret is always after minus */ if (left === '' && right.indexOf(settingsClone.aNeg) > -1) { left = settingsClone.aNeg; right = right.substring(1, right.length); } /** change sign of number, remove part if should */ if (left.charAt(0) === settingsClone.aNeg) { left = left.substring(1, left.length); } else { left = (cCode === '-') ? settingsClone.aNeg + left : left; } this.setValueParts(left, right); return true; } /** digits */ if (cCode >= '0' && cCode <= '9') { /** if try to insert digit before minus */ if (settingsClone.aNeg && left === '' && right.indexOf(settingsClone.aNeg) > -1) { left = settingsClone.aNeg; right = right.substring(1, right.length); } if (settingsClone.vMax <= 0 && settingsClone.vMin < settingsClone.vMax && this.value.indexOf(settingsClone.aNeg) === -1 && cCode !== '0') { left = settingsClone.aNeg + left; } this.setValueParts(left + cCode, right); return true; } /** prevent any other character */ return true; }, /** * formatting of just processed value with keeping of cursor position */ formatQuick: function() { var settingsClone = this.settingsClone, parts = this.getBeforeAfterStriped(), leftLength = this.value; if ((settingsClone.aSep === '' || (settingsClone.aSep !== '' && leftLength.indexOf(settingsClone.aSep) === -1)) && (settingsClone.aSign === '' || (settingsClone.aSign !== '' && leftLength.indexOf(settingsClone.aSign) === -1))) { var subParts = [], nSign = ''; subParts = leftLength.split(settingsClone.aDec); if (subParts[0].indexOf('-') > -1) { nSign = '-'; subParts[0] = subParts[0].replace('-', ''); parts[0] = parts[0].replace('-', ''); } if (subParts[0].length > settingsClone.mInt && parts[0].charAt(0) === '0') { /** strip leading zero if need */ parts[0] = parts[0].slice(1); } parts[0] = nSign + parts[0]; } var value = autoGroup(this.value, this.settingsClone), position = value.length; if (value) { /** prepare regexp which searches for cursor position from unformatted left part */ var left_ar = parts[0].split(''), i = 0; for (i; i < left_ar.length; i += 1) { /** thanks Peter Kovari */ if (!left_ar[i].match('\\d')) { left_ar[i] = '\\' + left_ar[i]; } } var leftReg = new RegExp('^.*?' + left_ar.join('.*?')); /** search cursor position in formatted value */ var newLeft = value.match(leftReg); if (newLeft) { position = newLeft[0].length; /** if we are just before sign which is in prefix position */ if (((position === 0 && value.charAt(0) !== settingsClone.aNeg) || (position === 1 && value.charAt(0) === settingsClone.aNeg)) && settingsClone.aSign && settingsClone.pSign === 'p') { /** place caret after prefix sign */ position = this.settingsClone.aSign.length + (value.charAt(0) === '-' ? 1 : 0); } } else if (settingsClone.aSign && settingsClone.pSign === 's') { /** if we could not find a place for cursor and have a sign as a suffix */ /** place carret before suffix currency sign */ position -= settingsClone.aSign.length; } } this.that.value = value; this.setPosition(position); this.formatted = true; } }; /** * thanks to Anthony & Evan C */ function autoGet(obj) { if (typeof obj === 'string') { obj = obj.replace(/\[/g, "\\[").replace(/\]/g, "\\]"); obj = '#' + obj.replace(/(:|\.)/g, '\\$1'); /** obj = '#' + obj.replace(/([;&,\.\+\*\~':"\!\^#$%@\[\]\(\)=>\|])/g, '\\$1'); */ /** possible modification to replace the above 2 lines */ } return $(obj); } /** * function to attach data to the element * and imitate the holder */ function getHolder($that, settings, update) { var data = $that.data('autoNumeric'); if (!data) { data = {}; $that.data('autoNumeric', data); } var holder = data.holder; if ((holder === undefined && settings) || update) { holder = new AutoNumericHolder($that.get(0), settings); data.holder = holder; } return holder; } var methods = { /** * Method to initiate autoNumeric and attached the settings (default and options passed as a parameter * $(someSelector).autoNumeric('init'); // initiate autoNumeric with defaults * $(someSelector).autoNumeric('init', {option}); // initiate autoNumeric with options * $(someSelector).autoNumeric(); // initiate autoNumeric with defaults * $(someSelector).autoNumeric({option}); // initiate autoNumeric with options * options passes as a parameter example '{aSep: '.', aDec: ',', aSign: '€ '} */ init: function(options) { return this.each(function() { var $this = $(this), settings = $this.data('autoNumeric'), /** attempt to grab 'autoNumeric' settings, if they don't exist returns "undefined". */ tagData = $this.data(), /** attempt to grab HTML5 data, if they don't exist we'll get "undefined".*/ $input = $this.is('input[type=text], input[type=hidden], input[type=tel], input:not([type])'); if (typeof settings !== 'object') { /** If we couldn't grab settings, create them from defaults and passed options. */ settings = $.extend({}, $.fn.autoNumeric.defaults, tagData, options, { aNum: '0123456789', hasFocus: false, removeBrackets: false, runOnce: false, tagList: ['b', 'caption', 'cite', 'code', 'dd', 'del', 'div', 'dfn', 'dt', 'em', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'ins', 'kdb', 'label', 'li', 'output', 'p', 'q', 's', 'sample', 'span', 'strong', 'td', 'th', 'u', 'var'] }); /** Merge defaults, tagData and options */ if (settings.aDec === settings.aSep) { $.error("autoNumeric will not function properly when the decimal character aDec: '" + settings.aDec + "' and thousand separator aSep: '" + settings.aSep + "' are the same character"); } $this.data('autoNumeric', settings); /** Save our new settings */ } else { return this; } var holder = getHolder($this, settings); if (!$input && $this.prop('tagName').toLowerCase() === 'input') { /** checks for non-supported input types */ $.error('The input type "' + $this.prop('type') + '" is not supported by autoNumeric()'); } if ($.inArray($this.prop('tagName').toLowerCase(), settings.tagList) === -1 && $this.prop('tagName').toLowerCase() !== 'input') { $.error("The <" + $this.prop('tagName').toLowerCase() + "> is not supported by autoNumeric()"); } if (settings.runOnce === false && settings.aForm) { /** routine to format default value on page load */ if ($input) { var setValue = true; if ($this[0].value === '' && settings.wEmpty === 'empty') { $this[0].value = ''; setValue = false; } if ($this[0].value === '' && settings.wEmpty === 'sign') { $this[0].value = settings.aSign; setValue = false; } /** checks for page reload from back button * also checks for ASP.net form post back * the following HTML data attribute is REQUIRED (data-an-default="same value as the value attribute") * example: */ if (setValue && $this.val() !== '' && ((settings.anDefault === null && $this[0].value === $this.prop('defaultValue')) || (settings.anDefault !== null && settings.anDefault.toString() === $this.val()))) { $this.autoNumeric('set', $this.val()); } } if ($.inArray($this.prop('tagName').toLowerCase(), settings.tagList) !== -1 && $this.text() !== '') { $this.autoNumeric('set', $this.text()); } } settings.runOnce = true; if ($this.is('input[type=text], input[type=hidden], input[type=tel], input:not([type])')) { /**added hidden type */ $this.on('keydown.autoNumeric', function(e) { holder = getHolder($this); if (holder.settings.aDec === holder.settings.aSep) { $.error("autoNumeric will not function properly when the decimal character aDec: '" + holder.settings.aDec + "' and thousand separator aSep: '" + holder.settings.aSep + "' are the same character"); } if (holder.that.readOnly) { holder.processed = true; return true; } /** The below streamed code / comment allows the "enter" keydown to throw a change() event */ /** if (e.keyCode === 13 && holder.inVal !== $this.val()){ $this.change(); holder.inVal = $this.val(); }*/ holder.init(e); if (holder.skipAllways(e)) { holder.processed = true; return true; } if (holder.processAllways()) { holder.processed = true; holder.formatQuick(); e.preventDefault(); return false; } holder.formatted = false; return true; }); $this.on('keypress.autoNumeric', function(e) { holder = getHolder($this); var processed = holder.processed; holder.init(e); if (holder.skipAllways(e)) { return true; } if (processed) { e.preventDefault(); return false; } if (holder.processAllways() || holder.processKeypress()) { holder.formatQuick(); e.preventDefault(); return false; } holder.formatted = false; }); $this.on('keyup.autoNumeric', function(e) { holder = getHolder($this); holder.init(e); var skip = holder.skipAllways(e), tabIn = holder.kdCode; holder.kdCode = 0; delete holder.valuePartsBeforePaste; if ($this[0].value === holder.settings.aSign) { /** added to properly place the caret when only the currency is present */ if (holder.settings.pSign === 's') { setElementSelection(this, 0, 0); } else { setElementSelection(this, holder.settings.aSign.length, holder.settings.aSign.length); } } else if (tabIn === 9 && holder.settings.nBracket !== null && $this[0].value !== holder.settings.aSign) { setElementSelection(this, 0, $this.val().length); } if (skip) { return true; } if (this.value === '') { return true; } if (!holder.formatted) { holder.formatQuick(); } }); $this.on('focusin.autoNumeric', function(e) { holder = getHolder($this); var $settings = holder.settingsClone; $settings.hasFocus = true; if ($settings.nBracket !== null) { var checkVal = $this.val(); $this.val(negativeBracket(checkVal, $settings)); } holder.inVal = $this.val(); var onEmpty = checkEmpty(holder.inVal, $settings, true); if (onEmpty !== null && onEmpty !== '') { $this.val(onEmpty); } }); $this.on('focusout.autoNumeric', function(e) { holder = getHolder($this); var $settings = holder.settingsClone, value = $this.val(), origValue = value; $settings.hasFocus = false; var strip_zero = ''; /** added to control leading zero */ if ($settings.lZero === 'allow') { /** added to control leading zero */ $settings.allowLeading = false; strip_zero = 'leading'; } if (value !== '') { value = autoStrip(value, $settings, strip_zero); if (checkEmpty(value, $settings) === null && autoCheck(value, $settings, $this[0])) { value = fixNumber(value, $settings.aDec, $settings.aNeg); value = autoRound(value, $settings); value = presentNumber(value, $settings.aDec, $settings.aNeg); } else { value = ''; } } var groupedValue = checkEmpty(value, $settings, false); if (groupedValue === null) { groupedValue = autoGroup(value, $settings); } if (groupedValue !== holder.inVal || groupedValue !== origValue) { $this.val(groupedValue); $this.change(); delete holder.inVal; } }); } }); }, /** * method to remove settings and stop autoNumeric() - does not remove the formatting * $(someSelector).autoNumeric('destroy'); // destroy autoNumeric * no parameters accepted */ destroy: function() { return $(this).each(function() { var $this = $(this); $this.removeData('autoNumeric'); $this.off('autoNumeric'); }); }, /** * method to update settings - can be call as many times * $(someSelector).autoNumeric('update', {options}); // updates the settings * options passes as a parameter example '{aSep: '.', aDec: ',', aSign: '€ '} */ update: function(options) { return $(this).each(function() { var $this = autoGet($(this)), settings = $this.data('autoNumeric'); if (typeof settings !== 'object') { $.error("You must initialize autoNumeric('init', {options}) prior to calling the 'update' method"); } var strip = $this.autoNumeric('get'); settings = $.extend(settings, options); getHolder($this, settings, true); if (settings.aDec === settings.aSep) { $.error("autoNumeric will not function properly when the decimal character aDec: '" + settings.aDec + "' and thousand separator aSep: '" + settings.aSep + "' are the same character"); } $this.data('autoNumeric', settings); if ($this.val() !== '' || $this.text() !== '') { return $this.autoNumeric('set', strip); } return; }); }, /** * method to format value sent as a parameter "" * $(someSelector).autoNumeric('set', 'value'}); // formats the value being passed * value passed as a string - can be a integer '1234' or double '1234.56789' * must contain only numbers and one decimal (period) character */ set: function(valueIn) { if (valueIn === null || isNaN(valueIn)) { return; } return $(this).each(function() { var $this = autoGet($(this)), settings = $this.data('autoNumeric'), value = valueIn.toString(), testValue = valueIn.toString(), $input = $this.is('input[type=text], input[type=hidden], input[type=tel], input:not([type])'); if (typeof settings !== 'object') { $.error("You must initialize autoNumeric('init', {options}) prior to calling the 'set' method"); } /** allows locale decimal separator to be a comma */ if ((testValue === $this.attr('value') || testValue === $this.text()) && settings.runOnce === false) { value = value.replace(',', '.'); } if (!$.isNumeric(+value)) { $.error("The value (" + value + ") being 'set' is not numeric and has caused a error to be thrown"); } value = checkValue(value, settings); settings.setEvent = true; value.toString(); if (value !== '') { value = autoRound(value, settings); } value = presentNumber(value, settings.aDec, settings.aNeg); if (!autoCheck(value, settings)) { value = autoRound('', settings); } value = autoGroup(value, settings); if ($input) { return $this.val(value); } if ($.inArray($this.prop('tagName').toLowerCase(), settings.tagList) !== -1) { return $this.text(value); } return false; }); }, /** * method to get the unformatted that accepts up to one parameter * $(someSelector).autoNumeric('get'); no parameters accepted * values returned as ISO numeric string "1234.56" where the decimal character is a period * only the first element in the selector is returned */ get: function() { var $this = autoGet($(this)), settings = $this.data('autoNumeric'); if (typeof settings !== 'object') { $.error("You must initialize autoNumeric('init', {options}) prior to calling the 'get' method"); } var getValue = ''; /** determine the element type then use .eq(0) selector to grab the value of the first element in selector */ if ($this.is('input[type=text], input[type=hidden], input[type=tel], input:not([type])')) { /**added hidden type */ getValue = $this.eq(0).val(); } else if ($.inArray($this.prop('tagName').toLowerCase(), settings.tagList) !== -1) { getValue = $this.eq(0).text(); } else { $.error("The <" + $this.prop('tagName').toLowerCase() + "> is not supported by autoNumeric()"); } if ((getValue === '' && settings.wEmpty === 'empty') || (getValue === settings.aSign && (settings.wEmpty === 'sign' || settings.wEmpty === 'empty'))) { return ''; } if (getValue !== '' && settings.nBracket !== null) { settings.removeBrackets = true; getValue = negativeBracket(getValue, settings); settings.removeBrackets = false; } if (settings.runOnce || settings.aForm === false) { getValue = autoStrip(getValue, settings); } getValue = fixNumber(getValue, settings.aDec, settings.aNeg); if (+getValue === 0 && settings.lZero !== 'keep') { getValue = '0'; } if (settings.lZero === 'keep') { return getValue; } getValue = checkValue(getValue, settings); return getValue; /** returned Numeric String */ }, /** * The 'getString' method used jQuerys .serialize() method that creates a text string in standard URL-encoded notation * it then loops through the string and un-formats the inputs with autoNumeric * $(someSelector).autoNumeric('getString'); no parameter accepted * values returned as ISO numeric string "1234.56" where the decimal character is a period */ getString: function() { var isAutoNumeric = false, $this = autoGet($(this)), formFields = $this.serialize(), formParts = formFields.split('&'), formIndex = $('form').index($this), allFormElements = $('form:eq(' + formIndex + ')'), aiIndex = [], /* all input index */ scIndex = [], /* successful control index */ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, /* from jQuery serialize method */ rsubmittable = /^(?:input|select|textarea|keygen)/i, /* from jQuery serialize method */ rcheckableType = /^(?:checkbox|radio)$/i, rnonAutoNumericTypes = /^(?:button|checkbox|color|date|datetime|datetime-local|email|file|image|month|number|password|radio|range|reset|search|submit|time|url|week)/i, count = 0; /*jslint unparam: true*/ /* index of successful elements */ $.each(allFormElements[0], function(i, field) { if (field.name !== '' && rsubmittable.test(field.localName) && !rsubmitterTypes.test(field.type) && !field.disabled && (field.checked || !rcheckableType.test(field.type))) { scIndex.push(count); count = count + 1; } else { scIndex.push(-1); } }); /* index of all inputs tags except checkbox */ count = 0; $.each(allFormElements[0], function(i, field) { if (field.localName === 'input' && (field.type === '' || field.type === 'text' || field.type === 'hidden' || field.type === 'tel')) { aiIndex.push(count); count = count + 1; } else { aiIndex.push(-1); if (field.localName === 'input' && rnonAutoNumericTypes.test(field.type)) { count = count + 1; } } }); $.each(formParts, function(i, miniParts) { miniParts = formParts[i].split('='); var scElement = $.inArray(i, scIndex); if (scElement > -1 && aiIndex[scElement] > -1) { var testInput = $('form:eq(' + formIndex + ') input:eq(' + aiIndex[scElement] + ')'), settings = testInput.data('autoNumeric'); if (typeof settings === 'object') { if (miniParts[1] !== null) { miniParts[1] = $('form:eq(' + formIndex + ') input:eq(' + aiIndex[scElement] + ')').autoNumeric('get').toString(); formParts[i] = miniParts.join('='); isAutoNumeric = true; } } } }); /*jslint unparam: false*/ if (!isAutoNumeric) { $.error("You must initialize autoNumeric('init', {options}) prior to calling the 'getString' method"); } return formParts.join('&'); }, /** * The 'getString' method used jQuerys .serializeArray() method that creates array or objects that can be encoded as a JSON string * it then loops through the string and un-formats the inputs with autoNumeric * $(someSelector).autoNumeric('getArray'); no parameter accepted * values returned as ISO numeric string "1234.56" where the decimal character is a period */ getArray: function() { var isAutoNumeric = false, $this = autoGet($(this)), formFields = $this.serializeArray(), formIndex = $('form').index($this), allFormElements = $('form:eq(' + formIndex + ')'), aiIndex = [], /* all input index */ scIndex = [], /* successful control index */ rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, /* from jQuery serialize method */ rsubmittable = /^(?:input|select|textarea|keygen)/i, /* from jQuery serialize method */ rcheckableType = /^(?:checkbox|radio)$/i, rnonAutoNumericTypes = /^(?:button|checkbox|color|date|datetime|datetime-local|email|file|image|month|number|password|radio|range|reset|search|submit|time|url|week)/i, count = 0; /*jslint unparam: true*/ /* index of successful elements */ $.each(allFormElements[0], function(i, field) { if (field.name !== '' && rsubmittable.test(field.localName) && !rsubmitterTypes.test(field.type) && !field.disabled && (field.checked || !rcheckableType.test(field.type))) { scIndex.push(count); count = count + 1; } else { scIndex.push(-1); } }); /* index of all inputs tags */ count = 0; $.each(allFormElements[0], function(i, field) { if (field.localName === 'input' && (field.type === '' || field.type === 'text' || field.type === 'hidden' || field.type === 'tel')) { aiIndex.push(count); count = count + 1; } else { aiIndex.push(-1); if (field.localName === 'input' && rnonAutoNumericTypes.test(field.type)) { count = count + 1; } } }); $.each(formFields, function(i, field) { var scElement = $.inArray(i, scIndex); if (scElement > -1 && aiIndex[scElement] > -1) { var testInput = $('form:eq(' + formIndex + ') input:eq(' + aiIndex[scElement] + ')'), settings = testInput.data('autoNumeric'); if (typeof settings === 'object') { field.value = $('form:eq(' + formIndex + ') input:eq(' + aiIndex[scElement] + ')').autoNumeric('get').toString(); isAutoNumeric = true; } } }); /*jslint unparam: false*/ if (!isAutoNumeric) { $.error("None of the successful form inputs are initialized by autoNumeric."); } return formFields; }, /** * The 'getSteetings returns the object with autoNumeric settings for those who need to look under the hood * $(someSelector).autoNumeric('getSettings'); // no parameters accepted * $(someSelector).autoNumeric('getSettings').aDec; // return the aDec setting as a string - ant valid setting can be used */ getSettings: function() { var $this = autoGet($(this)); return $this.eq(0).data('autoNumeric'); } }; /** * autoNumeric function */ $.fn.autoNumeric = function(method) { if (methods[method]) { return methods[method].apply(this, Array.prototype.slice.call(arguments, 1)); } if (typeof method === 'object' || !method) { return methods.init.apply(this, arguments); } $.error('Method "' + method + '" is not supported by autoNumeric()'); }; /** * Defaults are public - these can be overridden by the following: * HTML5 data attributes * Options passed by the 'init' or 'update' methods * Use jQuery's $.extend method - great way to pass ASP.NET current culture settings */ $.fn.autoNumeric.defaults = { /** allowed thousand separator characters * comma = ',' * period "full stop" = '.' * apostrophe is escaped = '\'' * space = ' ' * none = '' * NOTE: do not use numeric characters */ aSep: ',', /** digital grouping for the thousand separator used in Format * dGroup: '2', results in 99,99,99,999 common in India for values less than 1 billion and greater than -1 billion * dGroup: '3', results in 999,999,999 default * dGroup: '4', results in 9999,9999,9999 used in some Asian countries */ dGroup: '3', /** allowed decimal separator characters * period "full stop" = '.' * comma = ',' */ aDec: '.', /** allow to declare alternative decimal separator which is automatically replaced by aDec * developed for countries the use a comma ',' as the decimal character * and have keyboards\numeric pads that have a period 'full stop' as the decimal characters (Spain is an example) */ altDec: null, /** allowed currency symbol * Must be in quotes aSign: '$', a space is allowed aSign: '$ ' */ aSign: '', /** placement of currency sign * for prefix pSign: 'p', * for suffix pSign: 's', */ pSign: 'p', /** maximum possible value * value must be enclosed in quotes and use the period for the decimal point * value must be larger than vMin */ vMax: '9999999999999.99', /** minimum possible value * value must be enclosed in quotes and use the period for the decimal point * value must be smaller than vMax */ vMin: '-9999999999999.99', /** max number of decimal places = used to override decimal places set by the vMin & vMax values * value must be enclosed in quotes example mDec: '3', * This can also set the value via a call back function mDec: 'css:# */ mDec: null, /** method used for rounding * mRound: 'S', Round-Half-Up Symmetric (default) * mRound: 'A', Round-Half-Up Asymmetric * mRound: 's', Round-Half-Down Symmetric (lower case s) * mRound: 'a', Round-Half-Down Asymmetric (lower case a) * mRound: 'B', Round-Half-Even "Bankers Rounding" * mRound: 'U', Round Up "Round-Away-From-Zero" * mRound: 'D', Round Down "Round-Toward-Zero" - same as truncate * mRound: 'C', Round to Ceiling "Toward Positive Infinity" * mRound: 'F', Round to Floor "Toward Negative Infinity" */ mRound: 'S', /** controls decimal padding * aPad: true - always Pad decimals with zeros * aPad: false - does not pad with zeros. * aPad: `some number` - pad decimals with zero to number different from mDec * thanks to Jonas Johansson for the suggestion */ aPad: true, /** places brackets on negative value -$ 999.99 to (999.99) * visible only when the field does NOT have focus the left and right symbols should be enclosed in quotes and seperated by a comma * nBracket: null, nBracket: '(,)', nBracket: '[,]', nBracket: '<,>' or nBracket: '{,}' */ nBracket: null, /** Displayed on empty string * wEmpty: 'empty', - input can be blank * wEmpty: 'zero', - displays zero * wEmpty: 'sign', - displays the currency sign */ wEmpty: 'empty', /** controls leading zero behavior * lZero: 'allow', - allows leading zeros to be entered. Zeros will be truncated when entering additional digits. On focusout zeros will be deleted. * lZero: 'deny', - allows only one leading zero on values less than one * lZero: 'keep', - allows leading zeros to be entered. on fousout zeros will be retained. */ lZero: 'allow', /** determine if the select all keyboard command will select * the complete input text or only the input numeric value * if the currency symbol is between the numeric value and the negative sign only the numeric value will sellected */ sNumber: true, /** determine if the default value will be formatted on page ready. * true = automatically formats the default value on page ready * false = will not format the default value */ aForm: true, /** helper option for ASP.NET postback * should be the value of the unformatted default value * examples: * no default value='' {anDefault: ''} * value=1234.56 {anDefault: '1234.56'} */ anDefault: null }; })); // source --> https://www.art-asahikawa.com/wp-content/plugins/contact-form-7-cost-calculator/frontend/js/formula_evaluator-min.js /** math-expression-evaluator version 1.3.8 Dated:2021-07-03 */ (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.mexp = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o"+pop2.value+""+arr[i].show+""+pop1.value+"",type:10}); else disp.push({value:(pop2.type!=1?"(":"")+pop2.value+(pop2.type!=1?")":"")+""+pop1.value+"",type:1}); } else if(arr[i].type===2||arr[i].type===9){ pop1=disp.pop(); pop2=disp.pop(); disp.push({value:(pop2.type!=1?"(":"")+pop2.value+(pop2.type!=1?")":"")+arr[i].show+(pop1.type!=1?"(":"")+pop1.value+(pop1.type!=1?")":""),type:arr[i].type}); } else if(arr[i].type===12){ pop1=disp.pop(); pop2=disp.pop(); pop3=disp.pop(); disp.push({value:arr[i].show+"("+pop3.value+","+pop2.value+","+pop1.value+")",type:12}); } } return disp[0].value; }; module.exports=Mexp; },{"./postfix_evaluator.js":5}],2:[function(require,module,exports){ 'use strict' var Mexp = require('./math_function.js') function inc (arr, val) { for (var i = 0; i < arr.length; i++) { arr[i] += val } return arr } var token = [ 'sin', 'cos', 'tan', 'pi', '(', ')', 'P', 'C', ' ', 'asin', 'acos', 'atan', '7', '8', '9', 'int', 'cosh', 'acosh', 'ln', '^', 'root', '4', '5', '6', '/', '!', 'tanh', 'atanh', 'Mod', '1', '2', '3', '*', 'sinh', 'asinh', 'e', 'log', '0', '.', '+', '-', ',', 'Sigma', 'n', 'Pi', 'pow', 'floor' ] var show = [ 'sin', 'cos', 'tan', 'π', '(', ')', 'P', 'C', ' ', 'asin', 'acos', 'atan', '7', '8', '9', 'Int', 'cosh', 'acosh', ' ln', '^', 'root', '4', '5', '6', '÷', '!', 'tanh', 'atanh', ' Mod ', '1', '2', '3', '×', 'sinh', 'asinh', 'e', ' log', '0', '.', '+', '-', ',', 'Σ', 'n', 'Π', 'pow', 'floor' ] var eva = [ Mexp.math.sin, Mexp.math.cos, Mexp.math.tan, 'PI', '(', ')', Mexp.math.P, Mexp.math.C, ' '.anchor, Mexp.math.asin, Mexp.math.acos, Mexp.math.atan, '7', '8', '9', Math.floor, Mexp.math.cosh, Mexp.math.acosh, Math.log, Math.pow, Math.sqrt, '4', '5', '6', Mexp.math.div, Mexp.math.fact, Mexp.math.tanh, Mexp.math.atanh, Mexp.math.mod, '1', '2', '3', Mexp.math.mul, Mexp.math.sinh, Mexp.math.asinh, 'E', Mexp.math.log, '0', '.', Mexp.math.add, Mexp.math.sub, ',', Mexp.math.sigma, 'n', Mexp.math.Pi, Math.pow, Math.floor ] var preced = { 0: 11, 1: 0, 2: 3, 3: 0, 4: 0, 5: 0, 6: 0, 7: 11, 8: 11, 9: 1, 10: 10, 11: 0, 12: 11, 13: 0, 14: -1 // will be filtered after lexer } // stores precedence by types var type = [ 0, 0, 0, 3, 4, 5, 10, 10, 14, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 10, 0, 1, 1, 1, 2, 7, 0, 0, 2, 1, 1, 1, 2, 0, 0, 3, 0, 1, 6, 9, 9, 11, 12, 13, 12, 8 ] /* 0 : function with syntax function_name(Maths_exp) 1 : numbers 2 : binary operators like * / Mod left associate and same precedence 3 : Math constant values like e,pi,Cruncher ans 4 : opening bracket 5 : closing bracket 6 : decimal 7 : function with syntax (Math_exp)function_name 8: function with syntax function_name(Math_exp1,Math_exp2) 9 : binary operator like +,- 10: binary operator like P C or ^ 11: , 12: function with , seperated three parameters and third parameter is a string that will be mexp string 13: variable of Sigma function */ var type0 = { 0: true, 1: true, 3: true, 4: true, 6: true, 8: true, 9: true, 12: true, 13: true, 14: true } // type2:true,type4:true,type9:true,type11:true,type21:true,type22 var type1 = { 0: true, 1: true, 2: true, 3: true, 4: true, 5: true, 6: true, 7: true, 8: true, 9: true, 10: true, 11: true, 12: true, 13: true } // type3:true,type5:true,type7:true,type23 var type1Asterick = { 0: true, 3: true, 4: true, 8: true, 12: true, 13: true } var empty = {} var type3Asterick = { 0: true, 1: true, 3: true, 4: true, 6: true, 8: true, 12: true, 13: true } // type_5:true,type_7:true,type_23 var type6 = { 1: true } var newAr = [ [], [ '1', '2', '3', '7', '8', '9', '4', '5', '6', '+', '-', '*', '/', '(', ')', '^', '!', 'P', 'C', 'e', '0', '.', ',', 'n', ' ' ], ['pi', 'ln', 'Pi'], ['sin', 'cos', 'tan', 'Del', 'int', 'Mod', 'log', 'pow'], ['asin', 'acos', 'atan', 'cosh', 'root', 'tanh', 'sinh'], ['acosh', 'atanh', 'asinh', 'Sigma','floor'] ] function match (str1, str2, i, x) { for (var f = 0; f < x; f++) { if (str1[i + f] !== str2[f]) { return false } } return true } Mexp.addToken = function (tokens) { for (var i = 0; i < tokens.length; i++) { var x = tokens[i].token.length var temp = -1 // newAr is a specially designed data structure index of 1d array = length of tokens newAr[x] = newAr[x] || [] for (var y = 0; y < newAr[x].length; y++) { if (tokens[i].token === newAr[x][y]) { temp = token.indexOf(newAr[x][y]) break } } if (temp === -1) { token.push(tokens[i].token) type.push(tokens[i].type) if (newAr.length <= tokens[i].token.length) { newAr[tokens[i].token.length] = [] } newAr[tokens[i].token.length].push(tokens[i].token) eva.push(tokens[i].value) show.push(tokens[i].show) } else { // overwrite token[temp] = tokens[i].token type[temp] = tokens[i].type eva[temp] = tokens[i].value show[temp] = tokens[i].show } } } function tokenize (string) { var nodes = [] var length = string.length var key, x, y for (var i = 0; i < length; i++) { if (i < length - 1 && string[i] === ' ' && string[i + 1] === ' ') { continue } key = '' for ( x = string.length - i > newAr.length - 2 ? newAr.length - 1 : string.length - i; x > 0; x-- ) { if (newAr[x] === undefined) continue for (y = 0; y < newAr[x].length; y++) { if (match(string, newAr[x][y], i, x)) { key = newAr[x][y] y = newAr[x].length x = 0 } } } i += key.length - 1 if (key === '') { throw new Mexp.Exception("Can't understand after " + string.slice(i)) } var index = token.indexOf(key) nodes.push({ index: index, token: key, type: type[index], eval: eva[index], precedence: preced[type[index]], show: show[index] }) } return nodes } Mexp.lex = function (inp, tokens) { 'use strict' var changeSignObj = { value: Mexp.math.changeSign, type: 0, pre: 21, show: '-' } var closingParObj = { value: ')', show: ')', type: 5, pre: 0 } var openingParObj = { value: '(', type: 4, pre: 0, show: '(' } var str = [openingParObj] var ptc = [] // Parenthesis to close at the beginning is after one token var inpStr = inp var allowed = type0 var bracToClose = 0 var asterick = empty var prevKey = '' var i if (typeof tokens !== 'undefined') { Mexp.addToken(tokens) } var obj = {} var nodes = tokenize(inpStr) for (i = 0; i < nodes.length; i++) { var node = nodes[i] if (node.type === 14) { if ( i > 0 && i < nodes.length - 1 && nodes[i + 1].type === 1 && (nodes[i - 1].type === 1 || nodes[i - 1].type === 6) ) { throw new Mexp.Exception('Unexpected Space') } continue } var cToken = node.token var cType = node.type var cEv = node.eval var cPre = node.precedence var cShow = node.show var pre = str[str.length - 1] var j for (j = ptc.length; j--;) { // loop over ptc if (ptc[j] === 0) { if ([0, 2, 3, 4, 5, 9, 11, 12, 13].indexOf(cType) !== -1) { if (allowed[cType] !== true) { throw new Mexp.Exception(cToken + ' is not allowed after ' + prevKey) } str.push(closingParObj) allowed = type1 asterick = type3Asterick inc(ptc, -1).pop() } } else break } //console.log(allowed ); //console.log(nodes ); if (allowed[cType] !== true) { throw new Mexp.Exception(cToken + ' is not allowed after ' + prevKey) } if (asterick[cType] === true) { cType = 2 cEv = Mexp.math.mul cShow = '×' cPre = 3 i = i - 1 } obj = { value: cEv, type: cType, pre: cPre, show: cShow } if (cType === 0) { allowed = type0 asterick = empty inc(ptc, 2).push(2) str.push(obj) str.push(openingParObj) } else if (cType === 1) { if (pre.type === 1) { pre.value += cEv inc(ptc, 1) } else { str.push(obj) } allowed = type1 asterick = type1Asterick } else if (cType === 2) { allowed = type0 asterick = empty inc(ptc, 2) str.push(obj) } else if (cType === 3) { // constant str.push(obj) allowed = type1 asterick = type3Asterick } else if (cType === 4) { inc(ptc, 1) bracToClose++ allowed = type0 asterick = empty str.push(obj) } else if (cType === 5) { if (!bracToClose) { throw new Mexp.Exception('Closing parenthesis are more than opening one, wait What!!!') } bracToClose-- allowed = type1 asterick = type3Asterick str.push(obj) inc(ptc, 1) } else if (cType === 6) { if (pre.hasDec) { throw new Mexp.Exception('Two decimals are not allowed in one number') } if (pre.type !== 1) { pre = { value: 0, type: 1, pre: 0 } // pre needs to be changed as it will the last value now to be safe in later code str.push(pre) inc(ptc, -1) } allowed = type6 inc(ptc, 1) asterick = empty pre.value += cEv pre.hasDec = true } else if (cType === 7) { allowed = type1 asterick = type3Asterick inc(ptc, 1) str.push(obj) } if (cType === 8) { allowed = type0 asterick = empty inc(ptc, 4).push(4) str.push(obj) str.push(openingParObj) } else if (cType === 9) { if (pre.type === 9) { if (pre.value === Mexp.math.add) { pre.value = cEv pre.show = cShow inc(ptc, 1) } else if (pre.value === Mexp.math.sub && cShow === '-') { pre.value = Mexp.math.add pre.show = '+' inc(ptc, 1) } } else if ( pre.type !== 5 && pre.type !== 7 && pre.type !== 1 && pre.type !== 3 && pre.type !== 13 ) { // changesign only when negative is found if (cToken === '-') { // do nothing for + token // don't add with the above if statement as that will run the else statement of parent if on Ctoken + allowed = type0 asterick = empty inc(ptc, 2).push(2) str.push(changeSignObj) str.push(openingParObj) } } else { str.push(obj) inc(ptc, 2) } allowed = type0 asterick = empty } else if (cType === 10) { allowed = type0 asterick = empty inc(ptc, 2) str.push(obj) } else if (cType === 11) { allowed = type0 asterick = empty str.push(obj) } else if (cType === 12) { allowed = type0 asterick = empty inc(ptc, 6).push(6) str.push(obj) str.push(openingParObj) } else if (cType === 13) { allowed = type1 asterick = type3Asterick str.push(obj) } inc(ptc, -1) prevKey = cToken } for (j = ptc.length; j--;) { // loop over ptc if (ptc[j] === 0) { str.push(closingParObj) inc(ptc, -1).pop() } else break // if it is not zero so before ptc also cant be zero } if (allowed[5] !== true) { throw new Mexp.Exception('complete the expression') } while (bracToClose--) { str.push(closingParObj) } str.push(closingParObj) // console.log(str); return new Mexp(str) } module.exports = Mexp },{"./math_function.js":3}],3:[function(require,module,exports){ "use strict"; var Mexp = function (parsed) { this.value = parsed } Mexp.math = { isDegree: true, // mode of calculator acos: function (x) { return (Mexp.math.isDegree ? 180 / Math.PI * Math.acos(x) : Math.acos(x)) }, add: function (a, b) { return a + b }, asin: function (x) { return (Mexp.math.isDegree ? 180 / Math.PI * Math.asin(x) : Math.asin(x)) }, atan: function (x) { return (Mexp.math.isDegree ? 180 / Math.PI * Math.atan(x) : Math.atan(x)) }, acosh: function (x) { return Math.log(x + Math.sqrt(x * x - 1)) }, asinh: function (x) { return Math.log(x + Math.sqrt(x * x + 1)) }, atanh: function (x) { return Math.log((1 + x) / (1 - x)) }, C: function (n, r) { var pro = 1 var other = n - r var choice = r if (choice < other) { choice = other other = r } for (var i = choice + 1; i <= n; i++) { pro *= i } return pro / Mexp.math.fact(other) }, changeSign: function (x) { return -x }, cos: function (x) { if (Mexp.math.isDegree) x = Mexp.math.toRadian(x) return Math.cos(x) }, cosh: function (x) { return (Math.pow(Math.E, x) + Math.pow(Math.E, -1 * x)) / 2 }, div: function (a, b) { return a / b }, fact: function (n) { if (n % 1 !== 0) return 'NaN' var pro = 1 for (var i = 2; i <= n; i++) { pro *= i } return pro }, inverse: function (x) { return 1 / x }, log: function (i) { return Math.log(i) / Math.log(10) }, mod: function (a, b) { return a % b }, mul: function (a, b) { return a * b }, P: function (n, r) { var pro = 1 for (var i = Math.floor(n) - Math.floor(r) + 1; i <= Math.floor(n); i++) { pro *= i } return pro }, Pi: function (low, high, ex) { var pro = 1 for (var i = low; i <= high; i++) { pro *= Number(ex.postfixEval({ n: i })) } return pro }, pow10x: function (e) { var x = 1 while (e--) { x *= 10 } return x }, sigma: function (low, high, ex) { var sum = 0 for (var i = low; i <= high; i++) { sum += Number(ex.postfixEval({ n: i })) } return sum }, sin: function (x) { if (Mexp.math.isDegree) x = Mexp.math.toRadian(x) return Math.sin(x) }, sinh: function (x) { return (Math.pow(Math.E, x) - Math.pow(Math.E, -1 * x)) / 2 }, sub: function (a, b) { return a - b }, tan: function (x) { if (Mexp.math.isDegree) x = Mexp.math.toRadian(x) return Math.tan(x) }, tanh: function (x) { return Mexp.sinha(x) / Mexp.cosha(x) }, toRadian: function (x) { return x * Math.PI / 180 } } Mexp.Exception = function (message) { this.message = message } module.exports = Mexp },{}],4:[function(require,module,exports){ var Mexp = require('./lexer.js'); Mexp.prototype.toPostfix = function () { 'use strict'; var post = [], elem, popped, prep, pre, ele; var stack = [{ value: "(", type: 4, pre: 0 }]; var arr = this.value; for (var i = 1; i < arr.length; i++) { if (arr[i].type === 1 || arr[i].type === 3 || arr[i].type === 13) { //if token is number,constant,or n(which is also a special constant in our case) if (arr[i].type === 1) arr[i].value = Number(arr[i].value); post.push(arr[i]); } else if (arr[i].type === 4) { stack.push(arr[i]); } else if (arr[i].type === 5) { while ((popped = stack.pop()).type !== 4) { post.push(popped); } } else if (arr[i].type === 11) { while ((popped = stack.pop()).type !== 4) { post.push(popped); } stack.push(popped); } else { elem = arr[i]; pre = elem.pre; ele = stack[stack.length - 1]; prep = ele.pre; var flag = ele.value == 'Math.pow' && elem.value == 'Math.pow'; if (pre > prep) stack.push(elem); else { while (prep >= pre && !flag || flag && pre < prep) { popped = stack.pop(); ele = stack[stack.length - 1]; post.push(popped); prep = ele.pre; flag = elem.value == 'Math.pow' && ele.value == 'Math.pow'; } stack.push(elem); } } } return new Mexp(post); }; module.exports = Mexp; },{"./lexer.js":2}],5:[function(require,module,exports){ var Mexp=require('./postfix.js'); Mexp.prototype.postfixEval = function (UserDefined) { 'use strict'; UserDefined=UserDefined||{}; UserDefined.PI=Math.PI; UserDefined.E=Math.E; var stack=[],pop1,pop2,pop3; var disp=[]; var temp=''; var arr=this.value; var bool=(typeof UserDefined.n!=="undefined"); for(var i=0;i1) { throw(new Mexp.Exception("Uncaught Syntax error")); } return stack[0].value>1000000000000000?"Infinity":parseFloat(stack[0].value.toFixed(15)); }; Mexp.eval=function(str,tokens,obj){ if (typeof tokens==="undefined") { return this.lex(str).toPostfix().postfixEval(); } else if (typeof obj==="undefined") { if (typeof tokens.length!=="undefined") return this.lex(str,tokens).toPostfix().postfixEval(); else return this.lex(str).toPostfix().postfixEval(tokens); } else return this.lex(str,tokens).toPostfix().postfixEval(obj); }; module.exports=Mexp; },{"./postfix.js":4}]},{},[1])(1) }); // source --> https://www.art-asahikawa.com/wp-content/plugins/contact-form-7-cost-calculator/frontend/js/cf7_calculator.js (function($) { "use strict"; $( document ).ready( function () { $("body").on("click","input.number-format",function(){ $(this).autoNumeric(); var data = $(this).autoNumeric("get"); $(this).val(data); }) $("body").on("change keyup",".wpcf7 input,.wpcf7 select,.wpcf7 textarea",function(e){ $.cf7_formulas(); if (typeof cf7_logic != 'undefined') { $("input").trigger("cf7_logic"); } }) $.cf7_formulas = function(){ var total = 0; var max = 100; var reg =[]; var match; $("form.wpcf7-form input").each(function () { if( $(this).attr("type") == "checkbox" || $(this).attr("type") == "radio" ) { var name = $(this).attr("name").replace("[]", ""); reg.push(name); }else{ reg.push($(this).attr("name")); } }) $("form.wpcf7-form select").each(function () { reg.push($(this).attr("name")); }) reg = $.remove_duplicates_ctf7(reg); var field_regexp = new RegExp( '('+reg.join("|")+')'); $( ".ctf7-total" ).each(function( index ) { var eq = $(this).data('formulas'); console.log(eq); if(eq == "") { return ; } console.log(eq); eq = eq.toString(); while ( match = field_regexp.exec( eq ) ){ var type = $("input[name="+match[0]+"]").attr("type"); if( type === undefined ) { var type = $("input[name='"+match[0]+"[]']").attr("type"); } if( type =="checkbox" ){ var vl = 0; $("input[name='"+match[0]+"[]']:checked").each(function () { var row_value = $(this).val(); var n = row_value.search(/\|/i); if(n>0){ var vls = row_value.split("|"); vl += new Number( vls[0] ); }else{ vl += new Number($(this).val()); var text_lb = $(this).closest("span").find(".wpcf7-list-item-label").text(); if( text_lb != "" ){ $(this).val(vl+ "|" +text_lb); } } }); $("input[name='"+match[0]+"']:checked").each(function () { vl += new Number($(this).val()); }); }else if( type == "radio"){ var vl = $("input[name='"+match[0]+"']:checked").val(); }else if( type == "date"){ var vl = $("input[name="+match[0]+"]").val(); } else if( type === undefined ){ var vl = $("select[name="+match[0]+"]").val(); var n = vl.search(/\|/i); if(n>0){ var vls = vl.split("|"); vl = vls[0]; }else{ var text_lb = $("select[name="+match[0]+"]").find(":selected").text(); $("select[name="+match[0]+"]").find(":selected").val(vl+ "|" + text_lb); } }else{ if( $("input[name="+match[0]+"]").hasClass( "ctf7-total" ) ) { var vl = $("input[name="+match[0]+"]").attr("data-number"); }else{ var vl = $("input[name="+match[0]+"]").val(); } } if( $("input[name="+match[0]+"]").hasClass("number-format") ){ $("input[name="+match[0]+"]").autoNumeric(); vl = $("input[name="+match[0]+"]").autoNumeric("get"); }else{ } if( vl == ""){ vl = 0; } var reg_inner = new RegExp(match[0] + "(?!\\d)","gm"); eq = eq.replace( reg_inner, vl ); } eq = $.cf7_fomulas_days(eq); eq = $.cf7_fomulas_months(eq); eq = $.cf7_fomulas_years(eq); eq = $.cf7_fomulas_floor(eq); eq = $.cf7_fomulas_floor_2(eq); eq = $.cf7_fomulas_mod(eq); eq = $.cf7_fomulas_round(eq); eq = $.cf7_fomulas_round_2(eq); eq = $.cf7_fomulas_ceil(eq); eq = $.cf7_fomulas_elseif(eq); try{ var r = mexp.eval( eq ); // Evaluate the final equation total = r; } catch(e) { total = eq; } $(this).attr("data-number",total); if( $(this).hasClass("number-format") ){ $(this).autoNumeric(); $(this).autoNumeric("set",total); $(this).parent().find('.cf7-calculated-name').autoNumeric(); $(this).parent().find('.cf7-calculated-name').autoNumeric("set",total); }else{ $(this).val(total); $(this).parent().find('.cf7-calculated-name').html(total); } }); } $.remove_duplicates_ctf7 = function(arr) { var obj = {}; var ret_arr = []; for (var i = 0; i < arr.length; i++) { obj[arr[i]] = true; } for (var key in obj) { if("_wpcf7" == key || "_wpcf7_version" == key || "_wpcf7_locale" == key || "_wpcf7_unit_tag" == key || "_wpnonce" == key || "undefined" == key || "_wpcf7_container_post" == key || "_wpcf7_nonce" == key ){ }else { if(key !=""){ ret_arr.push(key +"(?!\\d)"); } } } return ret_arr; } $.cf7_fomulas_elseif = function(x){ console.log(x); var re = /if\(([^()]*)\)/gm; x = x.replace( re,function (x) { return $.cf7_fomulas_if(x); }); if( x.match(re) ){ x = $.cf7_fomulas_elseif(x); } return x; } $.cf7_fomulas_if = function(x){ x = x.replace(/[if()]/g, ''); var data = x.split(","); try { if(eval(data[0])){ return mexp.eval(data[1]); }else{ return mexp.eval(data[2]); } } catch (e) { var check_string = data[0].split("=="); var check_string2 = check_string[1].trim(); var check_string1 = check_string[0].trim(); if( !$.isNumeric( check_string2 ) ){ if( check_string1 == check_string2 ){ return mexp.eval(data[1]); }else{ return mexp.eval(data[2]); } }else{ return 0; } } } $.cf7_fomulas_days = function(x){ var re = /days\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[days()]/g, ''); var datas = x.split(","); if( datas[1] == "now" ){ var today = new Date(); var day_end1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_end1= datas[1]; } var day_end = $.cf7_fomulas_parse_date(day_end1); if( datas[0] == "now" ){ var today = new Date(); var day_start1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_start1 = datas[0]; } var day_start = $.cf7_fomulas_parse_date(day_start1); if( isNaN(day_end) || isNaN(day_start) ){ return 0; }else{ return $.cf7_fomulas_datediff(day_end,day_start); } }); if( x.match(re) ){ x = $.cf7_fomulas_days(x); } return x; } $.cf7_fomulas_months = function(x){ var re = /months\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[months()]/g, ''); var datas = x.split(","); if( datas[1] == "now" ){ var today = new Date(); var day_end1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_end1= datas[1]; } var day_end = $.cf7_fomulas_parse_date(day_end1); if( datas[0] == "now" ){ var today = new Date(); var day_start1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_start1 = datas[0]; } var day_start = $.cf7_fomulas_parse_date(day_start1); if( isNaN(day_end) || isNaN(day_start) ){ return 0; }else{ return day_start.getMonth() - day_end.getMonth() + (12 * (day_start.getFullYear() - day_end.getFullYear())) } }); if( x.match(re) ){ x = $.cf7_fomulas_months(x); } return x; } $.cf7_fomulas_years = function(x){ var re = /years\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[years()]/g, ''); var datas = x.split(","); if( datas[1] == "now" ){ var today = new Date(); var day_end1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_end1= datas[1]; } var day_end = $.cf7_fomulas_parse_date(day_end1); if( datas[0] == "now" ){ var today = new Date(); var day_start1 = today.getFullYear()+'-'+(today.getMonth()+1)+'-'+today.getDate(); }else{ var day_start1 = datas[0]; } var day_start = $.cf7_fomulas_parse_date(day_start1); if( isNaN(day_end) || isNaN(day_start) ){ return 0; }else{ return day_start.getFullYear() - day_end.getFullYear(); } }); if( x.match(re) ){ x = $.cf7_fomulas_years(x); } return x; } $.cf7_fomulas_round = function(x){ var re = /round\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[round()]/g, ''); x = mexp.eval(x); console.log(x); return Math.round(x); }); if( x.match(re) ){ x = $.cf7_fomulas_round(x); } return x; } $.cf7_fomulas_round_2 = function(x){ var re = /round2\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[round2()]/g, ''); x = mexp.eval(x); return Math.round(x * 100) / 100 }); if( x.match(re) ){ x = $.cf7_fomulas_round_2(x); } return x; } $.cf7_fomulas_floor = function(x){ var re = /floor\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[floor()]/g, ''); x = mexp.eval(x); return Math.floor(x); }); if( x.match(re) ){ x = $.cf7_fomulas_floor(x); } return x; } $.cf7_fomulas_floor_2 = function(x){ var re = /floor2\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[floor2()]/g, ''); x = mexp.eval(x); return Math.floor(x * 100) / 100 }); if( x.match(re) ){ x = $.cf7_fomulas_floor_2(x); } return x; } $.cf7_fomulas_ceil = function(x){ var re = /ceil\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[ceil()]/g, ''); x = mexp.eval(x); return Math.ceil(x); }); if( x.match(re) ){ x = $.cf7_fomulas_ceil(x); } return x; } $.cf7_fomulas_mod = function(x){ var re = /mod\(([^()]*)\)/gm; x = x.replace( re,function (x) { x = x.replace(/[mod()]/g, ''); var datas = x.split(","); return datas[0] % datas[1]; }); if( x.match(re) ){ x = $.cf7_fomulas_mod(x); } return x; } $.cf7_fomulas_parse_date = function(str){ return new Date(str); } $.cf7_cover_date_format = function(str,id){ var date=""; var format = id.data("date-format"); if( format == "m/d/Y" ) { var datas = str.split("/"); date = datas[2] + "-" + datas[0] + "-" + datas[1]; } else if( format == "d/m/Y") { var datas = str.split("/"); date = datas[2] + "-" + datas[1] + "-" + datas[0]; } else if( format == "F j, Y"){ date = str; } return date; } $.cf7_fomulas_datediff = function(first, second){ second = second.getTime(); first = first.getTime(); return Math.round((second-first)/(1000*60*60*24)); } if ( $( ".wpcf7-form" ).length ) { $.cf7_formulas(); $(".cf7-hide").closest('p').css('display', 'none'); } }) })(jQuery);