META-INF.resources.bower_components.globalize.src.number.parse-properties.js Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jwebmp-globalize Show documentation
Show all versions of jwebmp-globalize Show documentation
The JWebSwing implementation for a full Globalization
define([
"./format-properties",
"./symbol/inverted-map",
"../util/always-array",
"../util/object/map",
"../util/regexp/cf-g",
"../util/regexp/dash-g",
"../util/regexp/escape",
"../util/regexp/zs-g",
"../util/remove-literal-quotes"
], function (numberFormatProperties, numberSymbolInvertedMap, alwaysArray, objectMap, regexpCfG,
regexpDashG, regexpEscape, regexpZsG, removeLiteralQuotes) {
/**
* parseProperties( pattern, cldr )
*
* @pattern [String] raw pattern for numbers.
*
* @cldr [Cldr instance].
*
* Return parser properties, used to feed parser function.
*
* TODO:
* - Scientific_notation;
* - Padding;
*/
return function (pattern, cldr, options) {
var aux, decimalSymbolRe, digitsRe, groupingSeparatorRe, infinitySymbol, invertedNuDigitsMap,
invertedSymbolMap, maximumFractionDigits, maximumSignificantDigits,
minimumSignificantDigits, nanSymbol, negativePrefix, negativeSuffix, nuDigitsMap,
numberTokenizer, prefix, primaryGroupingSize, secondaryGroupingSize, suffix, symbolMap,
formatProperties = numberFormatProperties(pattern, cldr, options);
// Loose Matching:
// - Ignore all format characters, which includes RLM, LRM or ALM used to control BIDI
// formatting.
// - Map all characters in [:Zs:] to U+0020 SPACE;
// - Map all characters in [:Dash:] to U+002D HYPHEN-MINUS;
function looseMatching(value) {
return value
.replace(regexpCfG, "")
.replace(regexpDashG, "-")
.replace(regexpZsG, " ");
}
prefix = looseMatching(formatProperties[0]);
maximumFractionDigits = formatProperties[4];
minimumSignificantDigits = formatProperties[5];
maximumSignificantDigits = formatProperties[6];
primaryGroupingSize = formatProperties[8];
secondaryGroupingSize = formatProperties[9];
suffix = looseMatching(formatProperties[10]);
negativePrefix = looseMatching(formatProperties[13]);
negativeSuffix = looseMatching(formatProperties[14]);
infinitySymbol = looseMatching(formatProperties[16]);
nanSymbol = looseMatching(formatProperties[17]);
symbolMap = objectMap(formatProperties[18], function (pair) {
return [pair[0], looseMatching(pair[1])];
});
nuDigitsMap = formatProperties[19];
invertedSymbolMap = objectMap(numberSymbolInvertedMap(cldr), function (pair) {
return [looseMatching(pair[0]), pair[1]];
});
digitsRe = nuDigitsMap ? "[" + nuDigitsMap + "]" : "\\d";
groupingSeparatorRe = regexpEscape(symbolMap[","]);
decimalSymbolRe = regexpEscape(symbolMap["."]);
if (nuDigitsMap) {
invertedNuDigitsMap = nuDigitsMap.split("").reduce(function (object, localizedDigit, i) {
object[localizedDigit] = String(i);
return object;
}, {});
}
aux = [prefix, suffix, negativePrefix, negativeSuffix].map(function (value) {
return value.replace(/('([^']|'')+'|'')|./g, function (character, literal) {
// Literals
if (literal) {
return removeLiteralQuotes(literal);
}
// Symbols
character = character.replace(/[\-+E%\u2030]/, function (symbol) {
return symbolMap[symbol];
});
return character;
});
});
prefix = aux[0];
suffix = aux[1];
negativePrefix = aux[2];
negativeSuffix = aux[3];
// Number
//
// number_re = integer fraction?
//
// integer = digits | digits_using_grouping_separators
//
// fraction = regexp((.\d+)?)
//
// digits = regexp(\d+)
//
// digits_w_grouping_separators = digits_w_1_grouping_separators |
// digits_w_2_grouping_separators
//
// digits_w_1_grouping_separators = regexp(\d{1,3}(,\d{3})+)
//
// digits_w_2_grouping_separators = regexp(\d{1,2}((,\d{2})*(,\d{3})))
// Integer part
numberTokenizer = digitsRe + "+";
// Grouping separators
if (primaryGroupingSize) {
if (secondaryGroupingSize) {
aux = digitsRe + "{1," + secondaryGroupingSize + "}((" + groupingSeparatorRe +
digitsRe + "{" + secondaryGroupingSize + "})*(" + groupingSeparatorRe +
digitsRe + "{" + primaryGroupingSize + "}))";
} else {
aux = digitsRe + "{1," + primaryGroupingSize + "}(" + groupingSeparatorRe +
digitsRe + "{" + primaryGroupingSize + "})+";
}
numberTokenizer = "(" + aux + "|" + numberTokenizer + ")";
}
// Fraction part? Only included if 1 or 2.
// 1: Using significant digit format.
// 2: Using integer and fractional format && it has a maximumFractionDigits.
if (!isNaN(minimumSignificantDigits * maximumSignificantDigits) || /* 1 */
maximumFractionDigits /* 2 */) {
aux = decimalSymbolRe + digitsRe + "+";
numberTokenizer = numberTokenizer + "(" + aux + ")?" +
// Handle non-padded decimals, e.g., `".12"` => `0.12` by making the integer part
// optional.
"|(" + numberTokenizer + ")?" + aux;
numberTokenizer = "(" + numberTokenizer + ")";
}
// 0: @invertedSymbolMap [Object] Inverted symbol map.
// 1: @invertedNuDigitsMap [Object] Inverted digits map if numbering system is different than
// `latn`.
// 2: @tokenizer [Object] Tokenizer map, used by parser to consume input.
return [
invertedSymbolMap,
invertedNuDigitsMap,
{
infinity: new RegExp("^" + regexpEscape(infinitySymbol)),
nan: new RegExp("^" + regexpEscape(nanSymbol)),
negativePrefix: new RegExp("^" + regexpEscape(negativePrefix)),
negativeSuffix: new RegExp("^" + regexpEscape(negativeSuffix)),
number: new RegExp("^" + numberTokenizer),
prefix: new RegExp("^" + regexpEscape(prefix)),
suffix: new RegExp("^" + regexpEscape(suffix))
}
];
};
});