| New file |
|---|
| 0,0 → 1,520 |
|---|
| if(!dojo._hasResource["dojo.number"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code. |
| dojo._hasResource["dojo.number"] = true; |
| dojo.provide("dojo.number"); |
| |
| dojo.require("dojo.i18n"); |
| dojo.requireLocalization("dojo.cldr", "number", null, "zh-cn,en,en-ca,zh-tw,en-us,it,ja-jp,ROOT,de-de,es-es,fr,pt,ko-kr,es,de"); |
| dojo.require("dojo.string"); |
| dojo.require("dojo.regexp"); |
| |
| |
| /*===== |
| dojo.number.__formatOptions = function(kwArgs){ |
| // pattern: String? |
| // override formatting pattern with this string (see |
| // dojo.number._applyPattern) |
| // type: String? |
| // choose a format type based on the locale from the following: |
| // decimal, scientific, percent, currency. decimal by default. |
| // places: Number? |
| // fixed number of decimal places to show. This overrides any |
| // information in the provided pattern. |
| // round: NUmber? |
| // 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 |
| // means don't round. |
| // currency: String? |
| // iso4217 currency code |
| // symbol: String? |
| // localized currency symbol |
| // locale: String? |
| // override the locale used to determine formatting rules |
| } |
| =====*/ |
| |
| dojo.number.format = function(/*Number*/value, /*dojo.number.__formatOptions?*/options){ |
| // summary: |
| // Format a Number as a String, using locale-specific settings |
| // description: |
| // Create a string from a Number using a known localized pattern. |
| // Formatting patterns appropriate to the locale are chosen from the |
| // CLDR http://unicode.org/cldr as well as the appropriate symbols and |
| // delimiters. See http://www.unicode.org/reports/tr35/#Number_Elements |
| // value: |
| // the number to be formatted. If not a valid JavaScript number, |
| // return null. |
| |
| options = dojo.mixin({}, options || {}); |
| var locale = dojo.i18n.normalizeLocale(options.locale); |
| var bundle = dojo.i18n.getLocalization("dojo.cldr", "number", locale); |
| options.customs = bundle; |
| var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"]; |
| if(isNaN(value)){ return null; } // null |
| return dojo.number._applyPattern(value, pattern, options); // String |
| }; |
| |
| //dojo.number._numberPatternRE = /(?:[#0]*,?)*[#0](?:\.0*#*)?/; // not precise, but good enough |
| dojo.number._numberPatternRE = /[#0,]*[#0](?:\.0*#*)?/; // not precise, but good enough |
| |
| dojo.number._applyPattern = function(/*Number*/value, /*String*/pattern, /*dojo.number.__formatOptions?*/options){ |
| // summary: |
| // Apply pattern to format value as a string using options. Gives no |
| // consideration to local customs. |
| // value: |
| // the number to be formatted. |
| // pattern: |
| // a pattern string as described in |
| // http://www.unicode.org/reports/tr35/#Number_Format_Patterns |
| // options: dojo.number.__formatOptions? |
| // _applyPattern is usually called via dojo.number.format() which |
| // populates an extra property in the options parameter, "customs". |
| // The customs object specifies group and decimal parameters if set. |
| |
| //TODO: support escapes |
| options = options || {}; |
| var group = options.customs.group; |
| var decimal = options.customs.decimal; |
| |
| var patternList = pattern.split(';'); |
| var positivePattern = patternList[0]; |
| pattern = patternList[(value < 0) ? 1 : 0] || ("-" + positivePattern); |
| |
| //TODO: only test against unescaped |
| if(pattern.indexOf('%') != -1){ |
| value *= 100; |
| }else if(pattern.indexOf('\u2030') != -1){ |
| value *= 1000; // per mille |
| }else if(pattern.indexOf('\u00a4') != -1){ |
| group = options.customs.currencyGroup || group;//mixins instead? |
| decimal = options.customs.currencyDecimal || decimal;// Should these be mixins instead? |
| pattern = pattern.replace(/\u00a4{1,3}/, function(match){ |
| var prop = ["symbol", "currency", "displayName"][match.length-1]; |
| return options[prop] || options.currency || ""; |
| }); |
| }else if(pattern.indexOf('E') != -1){ |
| throw new Error("exponential notation not supported"); |
| } |
| |
| //TODO: support @ sig figs? |
| var numberPatternRE = dojo.number._numberPatternRE; |
| var numberPattern = positivePattern.match(numberPatternRE); |
| if(!numberPattern){ |
| throw new Error("unable to find a number expression in pattern: "+pattern); |
| } |
| return pattern.replace(numberPatternRE, |
| dojo.number._formatAbsolute(value, numberPattern[0], {decimal: decimal, group: group, places: options.places})); |
| } |
| |
| dojo.number.round = function(/*Number*/value, /*Number*/places, /*Number?*/multiple){ |
| // summary: |
| // Rounds the number at the given number of places |
| // value: |
| // the number to round |
| // places: |
| // the number of decimal places where rounding takes place |
| // multiple: |
| // rounds next place to nearest multiple |
| |
| var pieces = String(value).split("."); |
| var length = (pieces[1] && pieces[1].length) || 0; |
| if(length > places){ |
| var factor = Math.pow(10, places); |
| if(multiple > 0){factor *= 10/multiple;places++;} //FIXME |
| value = Math.round(value * factor)/factor; |
| |
| // truncate to remove any residual floating point values |
| pieces = String(value).split("."); |
| length = (pieces[1] && pieces[1].length) || 0; |
| if(length > places){ |
| pieces[1] = pieces[1].substr(0, places); |
| value = Number(pieces.join(".")); |
| } |
| } |
| return value; //Number |
| } |
| |
| /*===== |
| dojo.number.__formatAbsoluteOptions = function(kwArgs){ |
| // decimal: String? |
| // the decimal separator |
| // group: String? |
| // the group separator |
| // places: Integer? |
| // number of decimal places |
| // round: Number? |
| // 5 rounds to nearest .5; 0 rounds to nearest whole (default). -1 |
| // means don't round. |
| } |
| =====*/ |
| |
| dojo.number._formatAbsolute = function(/*Number*/value, /*String*/pattern, /*dojo.number.__formatAbsoluteOptions?*/options){ |
| // summary: |
| // Apply numeric pattern to absolute value using options. Gives no |
| // consideration to local customs. |
| // value: |
| // the number to be formatted, ignores sign |
| // pattern: |
| // the number portion of a pattern (e.g. #,##0.00) |
| options = options || {}; |
| if(options.places === true){options.places=0;} |
| if(options.places === Infinity){options.places=6;} // avoid a loop; pick a limit |
| |
| var patternParts = pattern.split("."); |
| var maxPlaces = (options.places >= 0) ? options.places : (patternParts[1] && patternParts[1].length) || 0; |
| if(!(options.round < 0)){ |
| value = dojo.number.round(value, maxPlaces, options.round); |
| } |
| |
| var valueParts = String(Math.abs(value)).split("."); |
| var fractional = valueParts[1] || ""; |
| if(options.places){ |
| valueParts[1] = dojo.string.pad(fractional.substr(0, options.places), options.places, '0', true); |
| }else if(patternParts[1] && options.places !== 0){ |
| // Pad fractional with trailing zeros |
| var pad = patternParts[1].lastIndexOf("0") + 1; |
| if(pad > fractional.length){ |
| valueParts[1] = dojo.string.pad(fractional, pad, '0', true); |
| } |
| |
| // Truncate fractional |
| var places = patternParts[1].length; |
| if(places < fractional.length){ |
| valueParts[1] = fractional.substr(0, places); |
| } |
| }else{ |
| if(valueParts[1]){ valueParts.pop(); } |
| } |
| |
| // Pad whole with leading zeros |
| var patternDigits = patternParts[0].replace(',', ''); |
| pad = patternDigits.indexOf("0"); |
| if(pad != -1){ |
| pad = patternDigits.length - pad; |
| if(pad > valueParts[0].length){ |
| valueParts[0] = dojo.string.pad(valueParts[0], pad); |
| } |
| |
| // Truncate whole |
| if(patternDigits.indexOf("#") == -1){ |
| valueParts[0] = valueParts[0].substr(valueParts[0].length - pad); |
| } |
| } |
| |
| // Add group separators |
| var index = patternParts[0].lastIndexOf(','); |
| var groupSize, groupSize2; |
| if(index != -1){ |
| groupSize = patternParts[0].length - index - 1; |
| var remainder = patternParts[0].substr(0, index); |
| index = remainder.lastIndexOf(','); |
| if(index != -1){ |
| groupSize2 = remainder.length - index - 1; |
| } |
| } |
| var pieces = []; |
| for(var whole = valueParts[0]; whole;){ |
| var off = whole.length - groupSize; |
| pieces.push((off > 0) ? whole.substr(off) : whole); |
| whole = (off > 0) ? whole.slice(0, off) : ""; |
| if(groupSize2){ |
| groupSize = groupSize2; |
| delete groupSize2; |
| } |
| } |
| valueParts[0] = pieces.reverse().join(options.group || ","); |
| |
| return valueParts.join(options.decimal || "."); |
| }; |
| |
| /*===== |
| dojo.number.__regexpOptions = function(kwArgs){ |
| // pattern: String? |
| // override pattern with this string. Default is provided based on |
| // locale. |
| // type: String? |
| // choose a format type based on the locale from the following: |
| // decimal, scientific, percent, currency. decimal by default. |
| // locale: String? |
| // override the locale used to determine formatting rules |
| // strict: Boolean? |
| // strict parsing, false by default |
| // places: Number|String? |
| // number of decimal places to accept: Infinity, a positive number, or |
| // a range "n,m". By default, defined by pattern. |
| } |
| =====*/ |
| dojo.number.regexp = function(/*dojo.number.__regexpOptions?*/options){ |
| // summary: |
| // Builds the regular needed to parse a number |
| // description: |
| // Returns regular expression with positive and negative match, group |
| // and decimal separators |
| return dojo.number._parseInfo(options).regexp; // String |
| } |
| |
| dojo.number._parseInfo = function(/*Object?*/options){ |
| options = options || {}; |
| var locale = dojo.i18n.normalizeLocale(options.locale); |
| var bundle = dojo.i18n.getLocalization("dojo.cldr", "number", locale); |
| var pattern = options.pattern || bundle[(options.type || "decimal") + "Format"]; |
| //TODO: memoize? |
| var group = bundle.group; |
| var decimal = bundle.decimal; |
| var factor = 1; |
| |
| if(pattern.indexOf('%') != -1){ |
| factor /= 100; |
| }else if(pattern.indexOf('\u2030') != -1){ |
| factor /= 1000; // per mille |
| }else{ |
| var isCurrency = pattern.indexOf('\u00a4') != -1; |
| if(isCurrency){ |
| group = bundle.currencyGroup || group; |
| decimal = bundle.currencyDecimal || decimal; |
| } |
| } |
| |
| //TODO: handle quoted escapes |
| var patternList = pattern.split(';'); |
| if(patternList.length == 1){ |
| patternList.push("-" + patternList[0]); |
| } |
| |
| var re = dojo.regexp.buildGroupRE(patternList, function(pattern){ |
| pattern = "(?:"+dojo.regexp.escapeString(pattern, '.')+")"; |
| return pattern.replace(dojo.number._numberPatternRE, function(format){ |
| var flags = { |
| signed: false, |
| separator: options.strict ? group : [group,""], |
| fractional: options.fractional, |
| decimal: decimal, |
| exponent: false}; |
| var parts = format.split('.'); |
| var places = options.places; |
| if(parts.length == 1 || places === 0){flags.fractional = false;} |
| else{ |
| if(typeof places == "undefined"){ places = parts[1].lastIndexOf('0')+1; } |
| if(places && options.fractional == undefined){flags.fractional = true;} // required fractional, unless otherwise specified |
| if(!options.places && (places < parts[1].length)){ places += "," + parts[1].length; } |
| flags.places = places; |
| } |
| var groups = parts[0].split(','); |
| if(groups.length>1){ |
| flags.groupSize = groups.pop().length; |
| if(groups.length>1){ |
| flags.groupSize2 = groups.pop().length; |
| } |
| } |
| return "("+dojo.number._realNumberRegexp(flags)+")"; |
| }); |
| }, true); |
| |
| if(isCurrency){ |
| // substitute the currency symbol for the placeholder in the pattern |
| re = re.replace(/(\s*)(\u00a4{1,3})(\s*)/g, function(match, before, target, after){ |
| var prop = ["symbol", "currency", "displayName"][target.length-1]; |
| var symbol = dojo.regexp.escapeString(options[prop] || options.currency || ""); |
| before = before ? "\\s" : ""; |
| after = after ? "\\s" : ""; |
| if(!options.strict){ |
| if(before){before += "*";} |
| if(after){after += "*";} |
| return "(?:"+before+symbol+after+")?"; |
| } |
| return before+symbol+after; |
| }); |
| } |
| |
| //TODO: substitute localized sign/percent/permille/etc.? |
| |
| // normalize whitespace and return |
| return {regexp: re.replace(/[\xa0 ]/g, "[\\s\\xa0]"), group: group, decimal: decimal, factor: factor}; // Object |
| } |
| |
| /*===== |
| dojo.number.__parseOptions = function(kwArgs){ |
| // pattern: String |
| // override pattern with this string. Default is provided based on |
| // locale. |
| // type: String? |
| // choose a format type based on the locale from the following: |
| // decimal, scientific, percent, currency. decimal by default. |
| // locale: String |
| // override the locale used to determine formatting rules |
| // strict: Boolean? |
| // strict parsing, false by default |
| // currency: Object |
| // object with currency information |
| } |
| =====*/ |
| dojo.number.parse = function(/*String*/expression, /*dojo.number.__parseOptions?*/options){ |
| // summary: |
| // Convert a properly formatted string to a primitive Number, using |
| // locale-specific settings. |
| // description: |
| // Create a Number from a string using a known localized pattern. |
| // Formatting patterns are chosen appropriate to the locale. |
| // Formatting patterns are implemented using the syntax described at |
| // *URL* |
| // expression: |
| // A string representation of a Number |
| var info = dojo.number._parseInfo(options); |
| var results = (new RegExp("^"+info.regexp+"$")).exec(expression); |
| if(!results){ |
| return NaN; //NaN |
| } |
| var absoluteMatch = results[1]; // match for the positive expression |
| if(!results[1]){ |
| if(!results[2]){ |
| return NaN; //NaN |
| } |
| // matched the negative pattern |
| absoluteMatch =results[2]; |
| info.factor *= -1; |
| } |
| |
| // Transform it to something Javascript can parse as a number. Normalize |
| // decimal point and strip out group separators or alternate forms of whitespace |
| absoluteMatch = absoluteMatch. |
| replace(new RegExp("["+info.group + "\\s\\xa0"+"]", "g"), ""). |
| replace(info.decimal, "."); |
| // Adjust for negative sign, percent, etc. as necessary |
| return Number(absoluteMatch) * info.factor; //Number |
| }; |
| |
| /*===== |
| dojo.number.__realNumberRegexpFlags = function(kwArgs){ |
| // places: Number? |
| // The integer number of decimal places or a range given as "n,m". If |
| // not given, the decimal part is optional and the number of places is |
| // unlimited. |
| // decimal: String? |
| // A string for the character used as the decimal point. Default |
| // is ".". |
| // fractional: Boolean|Array? |
| // Whether decimal places are allowed. Can be true, false, or [true, |
| // false]. Default is [true, false] |
| // exponent: Boolean|Array? |
| // Express in exponential notation. Can be true, false, or [true, |
| // false]. Default is [true, false], (i.e. will match if the |
| // exponential part is present are not). |
| // eSigned: Boolean|Array? |
| // The leading plus-or-minus sign on the exponent. Can be true, |
| // false, or [true, false]. Default is [true, false], (i.e. will |
| // match if it is signed or unsigned). flags in regexp.integer can be |
| // applied. |
| } |
| =====*/ |
| |
| dojo.number._realNumberRegexp = function(/*dojo.number.__realNumberRegexpFlags?*/flags){ |
| // summary: |
| // Builds a regular expression to match a real number in exponential |
| // notation |
| // flags: |
| // An object |
| |
| // assign default values to missing paramters |
| flags = flags || {}; |
| if(typeof flags.places == "undefined"){ flags.places = Infinity; } |
| if(typeof flags.decimal != "string"){ flags.decimal = "."; } |
| if(typeof flags.fractional == "undefined" || /^0/.test(flags.places)){ flags.fractional = [true, false]; } |
| if(typeof flags.exponent == "undefined"){ flags.exponent = [true, false]; } |
| if(typeof flags.eSigned == "undefined"){ flags.eSigned = [true, false]; } |
| |
| // integer RE |
| var integerRE = dojo.number._integerRegexp(flags); |
| |
| // decimal RE |
| var decimalRE = dojo.regexp.buildGroupRE(flags.fractional, |
| function(q){ |
| var re = ""; |
| if(q && (flags.places!==0)){ |
| re = "\\" + flags.decimal; |
| if(flags.places == Infinity){ |
| re = "(?:" + re + "\\d+)?"; |
| }else{ |
| re += "\\d{" + flags.places + "}"; |
| } |
| } |
| return re; |
| }, |
| true |
| ); |
| |
| // exponent RE |
| var exponentRE = dojo.regexp.buildGroupRE(flags.exponent, |
| function(q){ |
| if(q){ return "([eE]" + dojo.number._integerRegexp({ signed: flags.eSigned}) + ")"; } |
| return ""; |
| } |
| ); |
| |
| // real number RE |
| var realRE = integerRE + decimalRE; |
| // allow for decimals without integers, e.g. .25 |
| if(decimalRE){realRE = "(?:(?:"+ realRE + ")|(?:" + decimalRE + "))";} |
| return realRE + exponentRE; // String |
| }; |
| |
| /*===== |
| dojo.number.__integerRegexpFlags = function(kwArgs){ |
| // signed: Boolean? |
| // The leading plus-or-minus sign. Can be true, false, or [true, |
| // false]. Default is [true, false], (i.e. will match if it is signed |
| // or unsigned). |
| // separator: String? |
| // The character used as the thousands separator. Default is no |
| // separator. For more than one symbol use an array, e.g. [",", ""], |
| // makes ',' optional. |
| // groupSize: Number? |
| // group size between separators |
| // flags.groupSize2: Number? |
| // second grouping (for India) |
| } |
| =====*/ |
| |
| dojo.number._integerRegexp = function(/*dojo.number.__integerRegexpFlags?*/flags){ |
| // summary: |
| // Builds a regular expression that matches an integer |
| // flags: |
| // An object |
| |
| // assign default values to missing paramters |
| flags = flags || {}; |
| if(typeof flags.signed == "undefined"){ flags.signed = [true, false]; } |
| if(typeof flags.separator == "undefined"){ |
| flags.separator = ""; |
| }else if(typeof flags.groupSize == "undefined"){ |
| flags.groupSize = 3; |
| } |
| // build sign RE |
| var signRE = dojo.regexp.buildGroupRE(flags.signed, |
| function(q) { return q ? "[-+]" : ""; }, |
| true |
| ); |
| |
| // number RE |
| var numberRE = dojo.regexp.buildGroupRE(flags.separator, |
| function(sep){ |
| if(!sep){ |
| return "(?:0|[1-9]\\d*)"; |
| } |
| |
| sep = dojo.regexp.escapeString(sep); |
| if(sep == " "){ sep = "\\s"; } |
| else if(sep == "\xa0"){ sep = "\\s\\xa0"; } |
| |
| var grp = flags.groupSize, grp2 = flags.groupSize2; |
| if(grp2){ |
| var grp2RE = "(?:0|[1-9]\\d{0," + (grp2-1) + "}(?:[" + sep + "]\\d{" + grp2 + "})*[" + sep + "]\\d{" + grp + "})"; |
| return ((grp-grp2) > 0) ? "(?:" + grp2RE + "|(?:0|[1-9]\\d{0," + (grp-1) + "}))" : grp2RE; |
| } |
| return "(?:0|[1-9]\\d{0," + (grp-1) + "}(?:[" + sep + "]\\d{" + grp + "})*)"; |
| }, |
| true |
| ); |
| |
| // integer RE |
| return signRE + numberRE; // String |
| } |
| |
| } |