@syncfusion/ej2-base
Version:
A common package of Essential JS 2 base libraries, methods and class definitions
1,239 lines (1,238 loc) • 48.1 kB
JavaScript
import { getValue, isNullOrUndefined, extend, isBlazor } from '../util';
import { ParserBase as parser, getBlazorCurrencySymbol } from './parser-base';
import { isUndefined } from '../util';
/**
* Specifies default currency code to be considered
*
* @private
*/
export var defaultCurrencyCode = 'USD';
var NumberFormat = null;
var DateFormat = null;
export function setDefaultCurrencyCode(value) { defaultCurrencyCode = value; }
export function setNumberFormat(value) { NumberFormat = value; }
export function setDateFormat(value) { DateFormat = value; }
var regExp = RegExp;
export var blazorCultureFormats = {
'en-US': {
'd': 'M/d/y',
'D': 'EEEE, MMMM d, y',
'f': 'EEEE, MMMM d, y h:mm a',
'F': 'EEEE, MMMM d, y h:mm:s a',
'g': 'M/d/y h:mm a',
'G': 'M/d/yyyy h:mm:ss tt',
'm': 'MMMM d',
'M': 'MMMM d',
'r': 'ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'',
'R': 'ddd, dd MMM yyyy HH\':\'mm\':\'ss \'GMT\'',
's': 'yyyy\'-\'MM\'-\'dd\'T\'HH\':\'mm\':\'ss',
't': 'h:mm tt',
'T': 'h:m:s tt',
'u': 'yyyy\'-\'MM\'-\'dd HH\':\'mm\':\'ss\'Z\'',
'U': 'dddd, MMMM d, yyyy h:mm:ss tt',
'y': 'MMMM yyyy',
'Y': 'MMMM yyyy'
}
};
/**
* Date base common constants and function for date parser and formatter.
*/
// eslint-disable-next-line @typescript-eslint/no-namespace
export var IntlBase;
(function (IntlBase) {
// eslint-disable-next-line security/detect-unsafe-regex
IntlBase.negativeDataRegex = /^(('[^']+'|''|[^*#@0,.E])*)(\*.)?((([#,]*[0,]*0+)(\.0*[0-9]*#*)?)|([#,]*@+#*))(E\+?0+)?(('[^']+'|''|[^*#@0,.E])*)$/;
// eslint-disable-next-line security/detect-unsafe-regex
IntlBase.customRegex = /^(('[^']+'|''|[^*#@0,.])*)(\*.)?((([0#,]*[0,]*[0#]*[0# ]*)(\.[0#]*)?)|([#,]*@+#*))(E\+?0+)?(('[^']+'|''|[^*#@0,.E])*)$/;
IntlBase.latnParseRegex = /0|1|2|3|4|5|6|7|8|9/g;
var fractionRegex = /[0-9]/g;
IntlBase.defaultCurrency = '$';
var mapper = ['infinity', 'nan', 'group', 'decimal'];
var patternRegex = /G|M|L|H|c|'| a|yy|y|EEEE|E/g;
var patternMatch = {
'G': '',
'M': 'm',
'L': 'm',
'H': 'h',
'c': 'd',
'\'': '"',
' a': ' AM/PM',
'yy': 'yy',
'y': 'yyyy',
'EEEE': 'dddd',
'E': 'ddd'
};
IntlBase.dateConverterMapper = /dddd|ddd/ig;
var defaultFirstDay = 'sun';
IntlBase.islamicRegex = /^islamic/;
var firstDayMapper = {
'sun': 0,
'mon': 1,
'tue': 2,
'wed': 3,
'thu': 4,
'fri': 5,
'sat': 6
};
IntlBase.formatRegex = new regExp('(^[ncpae]{1})([0-1]?[0-9]|20)?$', 'i');
IntlBase.currencyFormatRegex = new regExp('(^[ca]{1})([0-1]?[0-9]|20)?$', 'i');
IntlBase.curWithoutNumberRegex = /(c|a)$/ig;
var typeMapper = {
'$': 'isCurrency',
'%': 'isPercent',
'-': 'isNegative',
0: 'nlead',
1: 'nend'
};
IntlBase.dateParseRegex = /([a-z])\1*|'([^']|'')+'|''|./gi;
IntlBase.basicPatterns = ['short', 'medium', 'long', 'full'];
IntlBase.defaultObject = {
'dates': {
'calendars': {
'gregorian': {
'months': {
'stand-alone': {
'abbreviated': {
'1': 'Jan',
'2': 'Feb',
'3': 'Mar',
'4': 'Apr',
'5': 'May',
'6': 'Jun',
'7': 'Jul',
'8': 'Aug',
'9': 'Sep',
'10': 'Oct',
'11': 'Nov',
'12': 'Dec'
},
'narrow': {
'1': 'J',
'2': 'F',
'3': 'M',
'4': 'A',
'5': 'M',
'6': 'J',
'7': 'J',
'8': 'A',
'9': 'S',
'10': 'O',
'11': 'N',
'12': 'D'
},
'wide': {
'1': 'January',
'2': 'February',
'3': 'March',
'4': 'April',
'5': 'May',
'6': 'June',
'7': 'July',
'8': 'August',
'9': 'September',
'10': 'October',
'11': 'November',
'12': 'December'
}
}
},
'days': {
'stand-alone': {
'abbreviated': {
'sun': 'Sun',
'mon': 'Mon',
'tue': 'Tue',
'wed': 'Wed',
'thu': 'Thu',
'fri': 'Fri',
'sat': 'Sat'
},
'narrow': {
'sun': 'S',
'mon': 'M',
'tue': 'T',
'wed': 'W',
'thu': 'T',
'fri': 'F',
'sat': 'S'
},
'short': {
'sun': 'Su',
'mon': 'Mo',
'tue': 'Tu',
'wed': 'We',
'thu': 'Th',
'fri': 'Fr',
'sat': 'Sa'
},
'wide': {
'sun': 'Sunday',
'mon': 'Monday',
'tue': 'Tuesday',
'wed': 'Wednesday',
'thu': 'Thursday',
'fri': 'Friday',
'sat': 'Saturday'
}
}
},
'dayPeriods': {
'format': {
'wide': {
'am': 'AM',
'pm': 'PM'
}
}
},
'eras': {
'eraNames': {
'0': 'Before Christ',
'0-alt-variant': 'Before Common Era',
'1': 'Anno Domini',
'1-alt-variant': 'Common Era'
},
'eraAbbr': {
'0': 'BC',
'0-alt-variant': 'BCE',
'1': 'AD',
'1-alt-variant': 'CE'
},
'eraNarrow': {
'0': 'B',
'0-alt-variant': 'BCE',
'1': 'A',
'1-alt-variant': 'CE'
}
},
'dateFormats': {
'full': 'EEEE, MMMM d, y',
'long': 'MMMM d, y',
'medium': 'MMM d, y',
'short': 'M/d/yy'
},
'timeFormats': {
'full': 'h:mm:ss a zzzz',
'long': 'h:mm:ss a z',
'medium': 'h:mm:ss a',
'short': 'h:mm a'
},
'dateTimeFormats': {
'full': '{1} \'at\' {0}',
'long': '{1} \'at\' {0}',
'medium': '{1}, {0}',
'short': '{1}, {0}',
'availableFormats': {
'd': 'd',
'E': 'ccc',
'Ed': 'd E',
'Ehm': 'E h:mm a',
'EHm': 'E HH:mm',
'Ehms': 'E h:mm:ss a',
'EHms': 'E HH:mm:ss',
'Gy': 'y G',
'GyMMM': 'MMM y G',
'GyMMMd': 'MMM d, y G',
'GyMMMEd': 'E, MMM d, y G',
'h': 'h a',
'H': 'HH',
'hm': 'h:mm a',
'Hm': 'HH:mm',
'hms': 'h:mm:ss a',
'Hms': 'HH:mm:ss',
'hmsv': 'h:mm:ss a v',
'Hmsv': 'HH:mm:ss v',
'hmv': 'h:mm a v',
'Hmv': 'HH:mm v',
'M': 'L',
'Md': 'M/d',
'MEd': 'E, M/d',
'MMM': 'LLL',
'MMMd': 'MMM d',
'MMMEd': 'E, MMM d',
'MMMMd': 'MMMM d',
'ms': 'mm:ss',
'y': 'y',
'yM': 'M/y',
'yMd': 'M/d/y',
'yMEd': 'E, M/d/y',
'yMMM': 'MMM y',
'yMMMd': 'MMM d, y',
'yMMMEd': 'E, MMM d, y',
'yMMMM': 'MMMM y'
}
}
},
'islamic': {
'months': {
'stand-alone': {
'abbreviated': {
'1': 'Muh.',
'2': 'Saf.',
'3': 'Rab. I',
'4': 'Rab. II',
'5': 'Jum. I',
'6': 'Jum. II',
'7': 'Raj.',
'8': 'Sha.',
'9': 'Ram.',
'10': 'Shaw.',
'11': 'Dhuʻl-Q.',
'12': 'Dhuʻl-H.'
},
'narrow': {
'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7',
'8': '8',
'9': '9',
'10': '10',
'11': '11',
'12': '12'
},
'wide': {
'1': 'Muharram',
'2': 'Safar',
'3': 'Rabiʻ I',
'4': 'Rabiʻ II',
'5': 'Jumada I',
'6': 'Jumada II',
'7': 'Rajab',
'8': 'Shaʻban',
'9': 'Ramadan',
'10': 'Shawwal',
'11': 'Dhuʻl-Qiʻdah',
'12': 'Dhuʻl-Hijjah'
}
}
},
'days': {
'stand-alone': {
'abbreviated': {
'sun': 'Sun',
'mon': 'Mon',
'tue': 'Tue',
'wed': 'Wed',
'thu': 'Thu',
'fri': 'Fri',
'sat': 'Sat'
},
'narrow': {
'sun': 'S',
'mon': 'M',
'tue': 'T',
'wed': 'W',
'thu': 'T',
'fri': 'F',
'sat': 'S'
},
'short': {
'sun': 'Su',
'mon': 'Mo',
'tue': 'Tu',
'wed': 'We',
'thu': 'Th',
'fri': 'Fr',
'sat': 'Sa'
},
'wide': {
'sun': 'Sunday',
'mon': 'Monday',
'tue': 'Tuesday',
'wed': 'Wednesday',
'thu': 'Thursday',
'fri': 'Friday',
'sat': 'Saturday'
}
}
},
'dayPeriods': {
'format': {
'wide': {
'am': 'AM',
'pm': 'PM'
}
}
},
'eras': {
'eraNames': {
'0': 'AH'
},
'eraAbbr': {
'0': 'AH'
},
'eraNarrow': {
'0': 'AH'
}
},
'dateFormats': {
'full': 'EEEE, MMMM d, y G',
'long': 'MMMM d, y G',
'medium': 'MMM d, y G',
'short': 'M/d/y GGGGG'
},
'timeFormats': {
'full': 'h:mm:ss a zzzz',
'long': 'h:mm:ss a z',
'medium': 'h:mm:ss a',
'short': 'h:mm a'
},
'dateTimeFormats': {
'full': '{1} \'at\' {0}',
'long': '{1} \'at\' {0}',
'medium': '{1}, {0}',
'short': '{1}, {0}',
'availableFormats': {
'd': 'd',
'E': 'ccc',
'Ed': 'd E',
'Ehm': 'E h:mm a',
'EHm': 'E HH:mm',
'Ehms': 'E h:mm:ss a',
'EHms': 'E HH:mm:ss',
'Gy': 'y G',
'GyMMM': 'MMM y G',
'GyMMMd': 'MMM d, y G',
'GyMMMEd': 'E, MMM d, y G',
'h': 'h a',
'H': 'HH',
'hm': 'h:mm a',
'Hm': 'HH:mm',
'hms': 'h:mm:ss a',
'Hms': 'HH:mm:ss',
'M': 'L',
'Md': 'M/d',
'MEd': 'E, M/d',
'MMM': 'LLL',
'MMMd': 'MMM d',
'MMMEd': 'E, MMM d',
'MMMMd': 'MMMM d',
'ms': 'mm:ss',
'y': 'y G',
'yyyy': 'y G',
'yyyyM': 'M/y GGGGG',
'yyyyMd': 'M/d/y GGGGG',
'yyyyMEd': 'E, M/d/y GGGGG',
'yyyyMMM': 'MMM y G',
'yyyyMMMd': 'MMM d, y G',
'yyyyMMMEd': 'E, MMM d, y G',
'yyyyMMMM': 'MMMM y G',
'yyyyQQQ': 'QQQ y G',
'yyyyQQQQ': 'QQQQ y G'
}
}
}
},
'timeZoneNames': {
'hourFormat': '+HH:mm;-HH:mm',
'gmtFormat': 'GMT{0}',
'gmtZeroFormat': 'GMT'
}
},
'numbers': {
'currencies': {
'USD': {
'displayName': 'US Dollar',
'symbol': '$',
'symbol-alt-narrow': '$'
},
'EUR': {
'displayName': 'Euro',
'symbol': '€',
'symbol-alt-narrow': '€'
},
'GBP': {
'displayName': 'British Pound',
'symbol-alt-narrow': '£'
}
},
'defaultNumberingSystem': 'latn',
'minimumGroupingDigits': '1',
'symbols-numberSystem-latn': {
'decimal': '.',
'group': ',',
'list': ';',
'percentSign': '%',
'plusSign': '+',
'minusSign': '-',
'exponential': 'E',
'superscriptingExponent': '×',
'perMille': '‰',
'infinity': '∞',
'nan': 'NaN',
'timeSeparator': ':'
},
'decimalFormats-numberSystem-latn': {
'standard': '#,##0.###'
},
'percentFormats-numberSystem-latn': {
'standard': '#,##0%'
},
'currencyFormats-numberSystem-latn': {
'standard': '¤#,##0.00',
'accounting': '¤#,##0.00;(¤#,##0.00)'
},
'scientificFormats-numberSystem-latn': {
'standard': '#E0'
}
}
};
IntlBase.blazorDefaultObject = {
'numbers': {
'mapper': {
'0': '0',
'1': '1',
'2': '2',
'3': '3',
'4': '4',
'5': '5',
'6': '6',
'7': '7',
'8': '8',
'9': '9'
},
'mapperDigits': '0123456789',
'numberSymbols': {
'decimal': '.',
'group': ',',
'plusSign': '+',
'minusSign': '-',
'percentSign': '%',
'nan': 'NaN',
'timeSeparator': ':',
'infinity': '∞'
},
'timeSeparator': ':',
'currencySymbol': '$',
'currencypData': {
'nlead': '$',
'nend': '',
'groupSeparator': ',',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
},
'percentpData': {
'nlead': '',
'nend': '%',
'groupSeparator': ',',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
},
'percentnData': {
'nlead': '-',
'nend': '%',
'groupSeparator': ',',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
},
'currencynData': {
'nlead': '($',
'nend': ')',
'groupSeparator': ',',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
},
'decimalnData': {
'nlead': '-',
'nend': '',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
},
'decimalpData': {
'nlead': '',
'nend': '',
'groupData': {
'primary': 3
},
'maximumFraction': 2,
'minimumFraction': 2
}
},
'dates': {
'dayPeriods': {
'am': 'AM',
'pm': 'PM'
},
'dateSeperator': '/',
'days': {
'abbreviated': {
'sun': 'Sun',
'mon': 'Mon',
'tue': 'Tue',
'wed': 'Wed',
'thu': 'Thu',
'fri': 'Fri',
'sat': 'Sat'
},
'short': {
'sun': 'Su',
'mon': 'Mo',
'tue': 'Tu',
'wed': 'We',
'thu': 'Th',
'fri': 'Fr',
'sat': 'Sa'
},
'wide': {
'sun': 'Sunday',
'mon': 'Monday',
'tue': 'Tuesday',
'wed': 'Wednesday',
'thu': 'Thursday',
'fri': 'Friday',
'sat': 'Saturday'
}
},
'months': {
'abbreviated': {
'1': 'Jan',
'2': 'Feb',
'3': 'Mar',
'4': 'Apr',
'5': 'May',
'6': 'Jun',
'7': 'Jul',
'8': 'Aug',
'9': 'Sep',
'10': 'Oct',
'11': 'Nov',
'12': 'Dec'
},
'wide': {
'1': 'January',
'2': 'February',
'3': 'March',
'4': 'April',
'5': 'May',
'6': 'June',
'7': 'July',
'8': 'August',
'9': 'September',
'10': 'October',
'11': 'November',
'12': 'December'
}
},
'eras': {
'1': 'AD'
}
}
};
IntlBase.monthIndex = {
3: 'abbreviated',
4: 'wide',
5: 'narrow',
1: 'abbreviated'
};
/**
*
*/
IntlBase.month = 'months';
IntlBase.days = 'days';
/**
* Default numerber Object
*/
IntlBase.patternMatcher = {
C: 'currency',
P: 'percent',
N: 'decimal',
A: 'currency',
E: 'scientific'
};
/**
* Returns the resultant pattern based on the skeleton, dateObject and the type provided
*
* @private
* @param {string} skeleton ?
* @param {Object} dateObject ?
* @param {string} type ?
* @param {boolean} isIslamic ?
* @param {string} blazorCulture ?
* @returns {string} ?
*/
function getResultantPattern(skeleton, dateObject, type, isIslamic, blazorCulture) {
var resPattern;
var iType = type || 'date';
if (blazorCulture) {
resPattern = compareBlazorDateFormats({ skeleton: skeleton }, blazorCulture).format ||
compareBlazorDateFormats({ skeleton: 'd' }, 'en-US').format;
}
else {
if (IntlBase.basicPatterns.indexOf(skeleton) !== -1) {
resPattern = getValue(iType + 'Formats.' + skeleton, dateObject);
if (iType === 'dateTime') {
var dPattern = getValue('dateFormats.' + skeleton, dateObject);
var tPattern = getValue('timeFormats.' + skeleton, dateObject);
resPattern = resPattern.replace('{1}', dPattern).replace('{0}', tPattern);
}
}
else {
resPattern = getValue('dateTimeFormats.availableFormats.' + skeleton, dateObject);
}
if (isUndefined(resPattern) && skeleton === 'yMd') {
resPattern = 'M/d/y';
}
}
return resPattern;
}
IntlBase.getResultantPattern = getResultantPattern;
/**
* Returns the dependable object for provided cldr data and culture
*
* @private
* @param {Object} cldr ?
* @param {string} culture ?
* @param {string} mode ?
* @param {boolean} isNumber ?
* @returns {any} ?
*/
function getDependables(cldr, culture, mode, isNumber) {
var ret = {};
var calendartype = mode || 'gregorian';
ret.parserObject = parser.getMainObject(cldr, culture) || (isBlazor() ? IntlBase.blazorDefaultObject : IntlBase.defaultObject);
if (isNumber) {
ret.numericObject = getValue('numbers', ret.parserObject);
}
else {
var dateString = isBlazor() ? 'dates' : ('dates.calendars.' + calendartype);
ret.dateObject = getValue(dateString, ret.parserObject);
}
return ret;
}
IntlBase.getDependables = getDependables;
/**
* Returns the symbol pattern for provided parameters
*
* @private
* @param {string} type ?
* @param {string} numSystem ?
* @param {Object} obj ?
* @param {boolean} isAccount ?
* @returns {string} ?
*/
function getSymbolPattern(type, numSystem, obj, isAccount) {
return getValue(type + 'Formats-numberSystem-' +
numSystem + (isAccount ? '.accounting' : '.standard'), obj) || (isAccount ? getValue(type + 'Formats-numberSystem-' +
numSystem + '.standard', obj) : '');
}
IntlBase.getSymbolPattern = getSymbolPattern;
/**
*
* @param {string} format ?
* @returns {string} ?
*/
function ConvertDateToWeekFormat(format) {
var convertMapper = format.match(IntlBase.dateConverterMapper);
if (convertMapper && isBlazor()) {
var tempString = convertMapper[0].length === 3 ? 'EEE' : 'EEEE';
return format.replace(IntlBase.dateConverterMapper, tempString);
}
return format;
}
IntlBase.ConvertDateToWeekFormat = ConvertDateToWeekFormat;
/**
*
* @param {DateFormatOptions} formatOptions ?
* @param {string} culture ?
* @returns {DateFormatOptions} ?
*/
function compareBlazorDateFormats(formatOptions, culture) {
var format = formatOptions.format || formatOptions.skeleton;
var curFormatMapper = getValue((culture || 'en-US') + '.' + format, blazorCultureFormats);
if (!curFormatMapper) {
curFormatMapper = getValue('en-US.' + format, blazorCultureFormats);
}
if (curFormatMapper) {
curFormatMapper = ConvertDateToWeekFormat(curFormatMapper);
formatOptions.format = curFormatMapper.replace(/tt/, 'a');
}
return formatOptions;
}
IntlBase.compareBlazorDateFormats = compareBlazorDateFormats;
/**
* Returns proper numeric skeleton
*
* @private
* @param {string} skeleton ?
* @returns {any} ?
*/
function getProperNumericSkeleton(skeleton) {
var matches = skeleton.match(IntlBase.formatRegex);
var ret = {};
var pattern = matches[1].toUpperCase();
ret.isAccount = (pattern === 'A');
ret.type = IntlBase.patternMatcher["" + pattern];
if (skeleton.length > 1) {
ret.fractionDigits = parseInt(matches[2], 10);
}
return ret;
}
IntlBase.getProperNumericSkeleton = getProperNumericSkeleton;
/**
* Returns format data for number formatting like minimum fraction, maximum fraction, etc..,
*
* @private
* @param {string} pattern ?
* @param {boolean} needFraction ?
* @param {string} cSymbol ?
* @param {boolean} fractionOnly ?
* @returns {any} ?
*/
function getFormatData(pattern, needFraction, cSymbol, fractionOnly) {
var nData = fractionOnly ? {} : { nlead: '', nend: '' };
var match = pattern.match(IntlBase.customRegex);
if (match) {
if (!fractionOnly) {
nData.nlead = changeCurrencySymbol(match[1], cSymbol);
nData.nend = changeCurrencySymbol(match[10], cSymbol);
nData.groupPattern = match[4];
}
var fraction = match[7];
if (fraction && needFraction) {
var fmatch = fraction.match(fractionRegex);
if (!isNullOrUndefined(fmatch)) {
nData.minimumFraction = fmatch.length;
}
else {
nData.minimumFraction = 0;
}
nData.maximumFraction = fraction.length - 1;
}
}
return nData;
}
IntlBase.getFormatData = getFormatData;
/**
* Changes currency symbol
*
* @private
* @param {string} val ?
* @param {string} sym ?
* @returns {string} ?
*/
function changeCurrencySymbol(val, sym) {
if (val) {
val = val.replace(IntlBase.defaultCurrency, sym);
return (sym === '') ? val.trim() : val;
}
return '';
}
IntlBase.changeCurrencySymbol = changeCurrencySymbol;
/**
* Returns currency symbol based on currency code ?
*
* @private
* @param {Object} numericObject ?
* @param {string} currencyCode ?
* @param {string} altSymbol ?
* @param {string} ignoreCurrency ?
* @returns {string} ?
*/
function getCurrencySymbol(numericObject, currencyCode, altSymbol, ignoreCurrency) {
var symbol = altSymbol ? ('.' + altSymbol) : '.symbol';
var getCurrency = ignoreCurrency ? '$' : getValue('currencies.' + currencyCode + symbol, numericObject) ||
getValue('currencies.' + currencyCode + '.symbol-alt-narrow', numericObject) || '$';
return getCurrency;
}
IntlBase.getCurrencySymbol = getCurrencySymbol;
/**
* Returns formatting options for custom number format
*
* @private
* @param {string} format ?
* @param {CommonOptions} dOptions ?
* @param {any} obj ?
* @returns {any} ?
*/
function customFormat(format, dOptions, obj) {
var options = {};
var formatSplit = format.split(';');
var data = ['pData', 'nData', 'zeroData'];
for (var i = 0; i < formatSplit.length; i++) {
options["" + data[parseInt(i.toString(), 10)]] = customNumberFormat(formatSplit[parseInt(i.toString(), 10)], dOptions, obj);
}
if (isNullOrUndefined(options.nData)) {
options.nData = extend({}, options.pData);
options.nData.nlead = isNullOrUndefined(dOptions) ? '-' + options.nData.nlead : dOptions.minusSymbol + options.nData.nlead;
}
return options;
}
IntlBase.customFormat = customFormat;
/**
* Returns custom formatting options
*
* @private
* @param {string} format ?
* @param {CommonOptions} dOptions ?
* @param {Object} numObject ?
* @returns {any} ?
*/
function customNumberFormat(format, dOptions, numObject) {
var cOptions = { type: 'decimal', minimumFractionDigits: 0, maximumFractionDigits: 0 };
var pattern = format.match(IntlBase.customRegex);
if (isNullOrUndefined(pattern) || (pattern[5] === '' && format !== 'N/A')) {
cOptions.type = undefined;
return cOptions;
}
cOptions.nlead = pattern[1];
cOptions.nend = pattern[10];
var integerPart = pattern[6];
var spaceCapture = integerPart.match(/ $/g) ? true : false;
var spaceGrouping = integerPart.replace(/ $/g, '').indexOf(' ') !== -1;
cOptions.useGrouping = integerPart.indexOf(',') !== -1 || spaceGrouping;
integerPart = integerPart.replace(/,/g, '');
integerPart = (/\s$/.test(integerPart)) ? integerPart.replace(/ /g, '') : integerPart;
var fractionPart = pattern[7];
if (integerPart.indexOf('0') !== -1) {
cOptions.minimumIntegerDigits = integerPart.length - integerPart.indexOf('0');
}
if (!isNullOrUndefined(fractionPart)) {
cOptions.minimumFractionDigits = fractionPart.lastIndexOf('0');
cOptions.maximumFractionDigits = fractionPart.lastIndexOf('#');
if (cOptions.minimumFractionDigits === -1) {
cOptions.minimumFractionDigits = 0;
}
if (cOptions.maximumFractionDigits === -1 || cOptions.maximumFractionDigits < cOptions.minimumFractionDigits) {
cOptions.maximumFractionDigits = cOptions.minimumFractionDigits;
}
}
if (!isNullOrUndefined(dOptions)) {
dOptions.isCustomFormat = true;
extend(cOptions, isCurrencyPercent([cOptions.nlead, cOptions.nend], '$', dOptions.currencySymbol));
if (!cOptions.isCurrency) {
extend(cOptions, isCurrencyPercent([cOptions.nlead, cOptions.nend], '%', dOptions.percentSymbol));
}
}
else {
extend(cOptions, isCurrencyPercent([cOptions.nlead, cOptions.nend], '%', '%'));
}
if (!isNullOrUndefined(numObject)) {
var symbolPattern = getSymbolPattern(cOptions.type, dOptions.numberMapper.numberSystem, numObject, false);
if (cOptions.useGrouping) {
cOptions.groupSeparator = spaceGrouping ? ' ' : dOptions.numberMapper.numberSymbols[mapper[2]];
cOptions.groupData = NumberFormat.getGroupingDetails(symbolPattern.split(';')[0]);
}
cOptions.nlead = cOptions.nlead.replace(/'/g, '');
cOptions.nend = spaceCapture ? ' ' + cOptions.nend.replace(/'/g, '') : cOptions.nend.replace(/'/g, '');
}
return cOptions;
}
IntlBase.customNumberFormat = customNumberFormat;
/**
* Returns formatting options for currency or percent type
*
* @private
* @param {string[]} parts ?
* @param {string} actual ?
* @param {string} symbol ?
* @returns {any} ?
*/
function isCurrencyPercent(parts, actual, symbol) {
var options = { nlead: parts[0], nend: parts[1] };
for (var i = 0; i < 2; i++) {
var part = parts[parseInt(i.toString(), 10)];
var loc = part.indexOf(actual);
if ((loc !== -1) && ((loc < part.indexOf('\'')) || (loc > part.lastIndexOf('\'')))) {
options["" + typeMapper[parseInt(i.toString(), 10)]] = part.substr(0, loc) + symbol + part.substr(loc + 1);
options["" + typeMapper["" + actual]] = true;
options.type = options.isCurrency ? 'currency' : 'percent';
break;
}
}
return options;
}
IntlBase.isCurrencyPercent = isCurrencyPercent;
/**
* Returns culture based date separator
*
* @private
* @param {Object} dateObj ?
* @returns {string} ?
*/
function getDateSeparator(dateObj) {
var value = (getValue('dateFormats.short', dateObj) || '').match(/[dM]([^dM])[dM]/i);
return value ? value[1] : '/';
}
IntlBase.getDateSeparator = getDateSeparator;
/**
* Returns Native Date Time pattern
*
* @private
* @param {string} culture ?
* @param {DateFormatOptions} options ?
* @param {Object} cldr ?
* @param {boolean} isExcelFormat ?
* @returns {string} ?
*/
function getActualDateTimeFormat(culture, options, cldr, isExcelFormat) {
var dependable = getDependables(cldr, culture, options.calendar);
if (isBlazor()) {
options = compareBlazorDateFormats(options, culture);
}
var actualPattern = options.format || getResultantPattern(options.skeleton, dependable.dateObject, options.type);
if (isExcelFormat) {
actualPattern = actualPattern.replace(patternRegex, function (pattern) {
return patternMatch["" + pattern];
});
if (actualPattern.indexOf('z') !== -1) {
var tLength = actualPattern.match(/z/g).length;
var timeZonePattern = void 0;
var options_1 = { 'timeZone': {} };
options_1.numMapper = parser.getNumberMapper(dependable.parserObject, parser.getNumberingSystem(cldr));
options_1.timeZone = getValue('dates.timeZoneNames', dependable.parserObject);
var value = new Date();
var timezone = value.getTimezoneOffset();
var pattern = (tLength < 4) ? '+H;-H' : options_1.timeZone.hourFormat;
pattern = pattern.replace(/:/g, options_1.numMapper.timeSeparator);
if (timezone === 0) {
timeZonePattern = options_1.timeZone.gmtZeroFormat;
}
else {
timeZonePattern = DateFormat.getTimeZoneValue(timezone, pattern);
timeZonePattern = options_1.timeZone.gmtFormat.replace(/\{0\}/, timeZonePattern);
}
actualPattern = actualPattern.replace(/[z]+/, '"' + timeZonePattern + '"');
}
actualPattern = actualPattern.replace(/ $/, '');
}
return actualPattern;
}
IntlBase.getActualDateTimeFormat = getActualDateTimeFormat;
/**
*
* @param {string} actual ?
* @param {any} option ?
* @returns {any} ?
*/
function processSymbol(actual, option) {
if (actual.indexOf(',') !== -1) {
var split = actual.split(',');
actual = (split[0] + getValue('numberMapper.numberSymbols.group', option) +
split[1].replace('.', getValue('numberMapper.numberSymbols.decimal', option)));
}
else {
actual = actual.replace('.', getValue('numberMapper.numberSymbols.decimal', option));
}
return actual;
}
IntlBase.processSymbol = processSymbol;
/**
* Returns Native Number pattern
*
* @private
* @param {string} culture ?
* @param {NumberFormatOptions} options ?
* @param {Object} cldr ?
* @param {boolean} isExcel ?
* @returns {string} ?
*/
function getActualNumberFormat(culture, options, cldr, isExcel) {
var dependable = getDependables(cldr, culture, '', true);
var parseOptions = { custom: true };
var numrericObject = dependable.numericObject;
var minFrac;
var curObj = {};
var curMatch = (options.format || '').match(IntlBase.currencyFormatRegex);
var type = IntlBase.formatRegex.test(options.format) ? getProperNumericSkeleton(options.format || 'N') : {};
var dOptions = {};
if (curMatch) {
dOptions.numberMapper = isBlazor() ?
extend({}, dependable.numericObject) :
parser.getNumberMapper(dependable.parserObject, parser.getNumberingSystem(cldr), true);
var curCode = isBlazor() ? getValue('currencySymbol', dependable.numericObject) :
getCurrencySymbol(dependable.numericObject, options.currency || defaultCurrencyCode, options.altSymbol);
var symbolPattern = getSymbolPattern('currency', dOptions.numberMapper.numberSystem, dependable.numericObject, (/a/i).test(options.format));
symbolPattern = symbolPattern.replace(/\u00A4/g, curCode);
var split = symbolPattern.split(';');
curObj.hasNegativePattern = isBlazor() ? true : (split.length > 1);
curObj.nData = isBlazor() ? getValue(type.type + 'nData', numrericObject) :
getFormatData(split[1] || '-' + split[0], true, curCode);
curObj.pData = isBlazor() ? getValue(type.type + 'pData', numrericObject) :
getFormatData(split[0], false, curCode);
if (!curMatch[2] && !options.minimumFractionDigits && !options.maximumFractionDigits) {
minFrac = getFormatData(symbolPattern.split(';')[0], true, '', true).minimumFraction;
}
}
var actualPattern;
if ((IntlBase.formatRegex.test(options.format)) || !(options.format)) {
extend(parseOptions, getProperNumericSkeleton(options.format || 'N'));
parseOptions.custom = false;
actualPattern = '###0';
if (parseOptions.fractionDigits || options.minimumFractionDigits || options.maximumFractionDigits || minFrac) {
var defaultMinimum = 0;
if (parseOptions.fractionDigits) {
options.minimumFractionDigits = options.maximumFractionDigits = parseOptions.fractionDigits;
}
actualPattern = fractionDigitsPattern(actualPattern, minFrac || parseOptions.fractionDigits ||
options.minimumFractionDigits || defaultMinimum, options.maximumFractionDigits || defaultMinimum);
}
if (options.minimumIntegerDigits) {
actualPattern = minimumIntegerPattern(actualPattern, options.minimumIntegerDigits);
}
if (options.useGrouping) {
actualPattern = groupingPattern(actualPattern);
}
if (parseOptions.type === 'currency' || (parseOptions.type && isBlazor())) {
if (isBlazor() && parseOptions.type !== 'currency') {
curObj.pData = getValue(parseOptions.type + 'pData', numrericObject);
curObj.nData = getValue(parseOptions.type + 'nData', numrericObject);
}
var cPattern = actualPattern;
actualPattern = curObj.pData.nlead + cPattern + curObj.pData.nend;
if (curObj.hasNegativePattern || isBlazor()) {
actualPattern += ';' + curObj.nData.nlead + cPattern + curObj.nData.nend;
}
}
if (parseOptions.type === 'percent' && !isBlazor()) {
actualPattern += ' %';
}
}
else {
actualPattern = options.format.replace(/'/g, '"');
}
if (Object.keys(dOptions).length > 0) {
actualPattern = !isExcel ? processSymbol(actualPattern, dOptions) : actualPattern;
}
return actualPattern;
}
IntlBase.getActualNumberFormat = getActualNumberFormat;
/**
*
* @param {string} pattern ?
* @param {number} minDigits ?
* @param {number} maxDigits ?
* @returns {string} ?
*/
function fractionDigitsPattern(pattern, minDigits, maxDigits) {
pattern += '.';
for (var a = 0; a < minDigits; a++) {
pattern += '0';
}
if (minDigits < maxDigits) {
var diff = maxDigits - minDigits;
for (var b = 0; b < diff; b++) {
pattern += '#';
}
}
return pattern;
}
IntlBase.fractionDigitsPattern = fractionDigitsPattern;
/**
*
* @param {string} pattern ?
* @param {number} digits ?
* @returns {string} ?
*/
function minimumIntegerPattern(pattern, digits) {
var temp = pattern.split('.');
var integer = '';
for (var x = 0; x < digits; x++) {
integer += '0';
}
return temp[1] ? (integer + '.' + temp[1]) : integer;
}
IntlBase.minimumIntegerPattern = minimumIntegerPattern;
/**
*
* @param {string} pattern ?
* @returns {string} ?
*/
function groupingPattern(pattern) {
var temp = pattern.split('.');
var integer = temp[0];
var no = 3 - integer.length % 3;
var hash = (no && no === 1) ? '#' : (no === 2 ? '##' : '');
integer = hash + integer;
pattern = '';
for (var x = integer.length - 1; x > 0; x = x - 3) {
pattern = ',' + integer[x - 2] + integer[x - 1] + integer[parseInt(x.toString(), 10)] + pattern;
}
pattern = pattern.slice(1);
return temp[1] ? (pattern + '.' + temp[1]) : pattern;
}
IntlBase.groupingPattern = groupingPattern;
/**
*
* @param {string} culture ?
* @param {Object} cldr ?
* @returns {number} ?
*/
function getWeekData(culture, cldr) {
var firstDay = defaultFirstDay;
var mapper = getValue('supplemental.weekData.firstDay', cldr);
var iCulture = culture;
if ((/en-/).test(iCulture)) {
iCulture = iCulture.slice(3);
}
iCulture = iCulture.slice(0, 2).toUpperCase() + iCulture.substr(2);
if (mapper) {
firstDay = mapper["" + iCulture] || mapper[iCulture.slice(0, 2)] || defaultFirstDay;
}
return firstDayMapper["" + firstDay];
}
IntlBase.getWeekData = getWeekData;
/**
* @private
* @param {any} pData ?
* @param {string} aCurrency ?
* @param {string} rCurrency ?
* @returns {void} ?
*/
function replaceBlazorCurrency(pData, aCurrency, rCurrency) {
var iCurrency = getBlazorCurrencySymbol(rCurrency);
if (aCurrency !== iCurrency) {
for (var _i = 0, pData_1 = pData; _i < pData_1.length; _i++) {
var data = pData_1[_i];
data.nend = data.nend.replace(aCurrency, iCurrency);
data.nlead = data.nlead.replace(aCurrency, iCurrency);
}
}
}
IntlBase.replaceBlazorCurrency = replaceBlazorCurrency;
/**
* @private
* @param {Date} date ?
* @param {number} firstDayOfWeek ?
* @returns {number} ?
*/
function getWeekOfYear(date, firstDayOfWeek) {
var newYear = new Date(date.getFullYear(), 0, 1);
var day = newYear.getDay();
var weeknum;
day = (day >= 0 ? day : day + 7);
var daynum = Math.floor((date.getTime() - newYear.getTime() -
(date.getTimezoneOffset() - newYear.getTimezoneOffset()) * 60000) / 86400000) + 1;
if (day < 4) {
weeknum = Math.floor((daynum + day - firstDayOfWeek - 1) / 7) + 1;
if (weeknum > 52) {
var nYear = new Date(date.getFullYear() + 1, 0, 1);
var nday = nYear.getDay();
nday = nday >= 0 ? nday : nday + 7;
weeknum = nday < 4 ? 1 : 53;
}
}
else {
weeknum = Math.floor((daynum + day - firstDayOfWeek - 1) / 7);
}
return weeknum;
}
IntlBase.getWeekOfYear = getWeekOfYear;
})(IntlBase || (IntlBase = {}));