You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
308 lines
12 KiB
308 lines
12 KiB
var __assign = (this && this.__assign) || function () {
|
|
__assign = Object.assign || function(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
|
|
t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
/**
|
|
* https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
|
|
* Credit: https://github.com/caridy/intl-datetimeformat-pattern/blob/master/index.js
|
|
* with some tweaks
|
|
*/
|
|
var DATE_TIME_REGEX = /(?:[Eec]{1,6}|G{1,5}|[Qq]{1,5}|(?:[yYur]+|U{1,5})|[ML]{1,5}|d{1,2}|D{1,3}|F{1}|[abB]{1,5}|[hkHK]{1,2}|w{1,2}|W{1}|m{1,2}|s{1,2}|[zZOvVxX]{1,4})(?=([^']*'[^']*')*[^']*$)/g;
|
|
/**
|
|
* Parse Date time skeleton into Intl.DateTimeFormatOptions
|
|
* Ref: https://unicode.org/reports/tr35/tr35-dates.html#Date_Field_Symbol_Table
|
|
* @public
|
|
* @param skeleton skeleton string
|
|
*/
|
|
export function parseDateTimeSkeleton(skeleton) {
|
|
var result = {};
|
|
skeleton.replace(DATE_TIME_REGEX, function (match) {
|
|
var len = match.length;
|
|
switch (match[0]) {
|
|
// Era
|
|
case 'G':
|
|
result.era = len === 4 ? 'long' : len === 5 ? 'narrow' : 'short';
|
|
break;
|
|
// Year
|
|
case 'y':
|
|
result.year = len === 2 ? '2-digit' : 'numeric';
|
|
break;
|
|
case 'Y':
|
|
case 'u':
|
|
case 'U':
|
|
case 'r':
|
|
throw new RangeError('`Y/u/U/r` (year) patterns are not supported, use `y` instead');
|
|
// Quarter
|
|
case 'q':
|
|
case 'Q':
|
|
throw new RangeError('`q/Q` (quarter) patterns are not supported');
|
|
// Month
|
|
case 'M':
|
|
case 'L':
|
|
result.month = ['numeric', '2-digit', 'short', 'long', 'narrow'][len - 1];
|
|
break;
|
|
// Week
|
|
case 'w':
|
|
case 'W':
|
|
throw new RangeError('`w/W` (week) patterns are not supported');
|
|
case 'd':
|
|
result.day = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'D':
|
|
case 'F':
|
|
case 'g':
|
|
throw new RangeError('`D/F/g` (day) patterns are not supported, use `d` instead');
|
|
// Weekday
|
|
case 'E':
|
|
result.weekday = len === 4 ? 'short' : len === 5 ? 'narrow' : 'short';
|
|
break;
|
|
case 'e':
|
|
if (len < 4) {
|
|
throw new RangeError('`e..eee` (weekday) patterns are not supported');
|
|
}
|
|
result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
|
|
break;
|
|
case 'c':
|
|
if (len < 4) {
|
|
throw new RangeError('`c..ccc` (weekday) patterns are not supported');
|
|
}
|
|
result.weekday = ['short', 'long', 'narrow', 'short'][len - 4];
|
|
break;
|
|
// Period
|
|
case 'a': // AM, PM
|
|
result.hour12 = true;
|
|
break;
|
|
case 'b': // am, pm, noon, midnight
|
|
case 'B': // flexible day periods
|
|
throw new RangeError('`b/B` (period) patterns are not supported, use `a` instead');
|
|
// Hour
|
|
case 'h':
|
|
result.hourCycle = 'h12';
|
|
result.hour = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'H':
|
|
result.hourCycle = 'h23';
|
|
result.hour = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'K':
|
|
result.hourCycle = 'h11';
|
|
result.hour = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'k':
|
|
result.hourCycle = 'h24';
|
|
result.hour = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'j':
|
|
case 'J':
|
|
case 'C':
|
|
throw new RangeError('`j/J/C` (hour) patterns are not supported, use `h/H/K/k` instead');
|
|
// Minute
|
|
case 'm':
|
|
result.minute = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
// Second
|
|
case 's':
|
|
result.second = ['numeric', '2-digit'][len - 1];
|
|
break;
|
|
case 'S':
|
|
case 'A':
|
|
throw new RangeError('`S/A` (second) pattenrs are not supported, use `s` instead');
|
|
// Zone
|
|
case 'z': // 1..3, 4: specific non-location format
|
|
result.timeZoneName = len < 4 ? 'short' : 'long';
|
|
break;
|
|
case 'Z': // 1..3, 4, 5: The ISO8601 varios formats
|
|
case 'O': // 1, 4: miliseconds in day short, long
|
|
case 'v': // 1, 4: generic non-location format
|
|
case 'V': // 1, 2, 3, 4: time zone ID or city
|
|
case 'X': // 1, 2, 3, 4: The ISO8601 varios formats
|
|
case 'x': // 1, 2, 3, 4: The ISO8601 varios formats
|
|
throw new RangeError('`Z/O/v/V/X/x` (timeZone) pattenrs are not supported, use `z` instead');
|
|
}
|
|
return '';
|
|
});
|
|
return result;
|
|
}
|
|
function icuUnitToEcma(unit) {
|
|
return unit.replace(/^(.*?)-/, '');
|
|
}
|
|
var FRACTION_PRECISION_REGEX = /^\.(?:(0+)(\+|#+)?)?$/g;
|
|
var SIGNIFICANT_PRECISION_REGEX = /^(@+)?(\+|#+)?$/g;
|
|
function parseSignificantPrecision(str) {
|
|
var result = {};
|
|
str.replace(SIGNIFICANT_PRECISION_REGEX, function (_, g1, g2) {
|
|
// @@@ case
|
|
if (typeof g2 !== 'string') {
|
|
result.minimumSignificantDigits = g1.length;
|
|
result.maximumSignificantDigits = g1.length;
|
|
}
|
|
// @@@+ case
|
|
else if (g2 === '+') {
|
|
result.minimumSignificantDigits = g1.length;
|
|
}
|
|
// .### case
|
|
else if (g1[0] === '#') {
|
|
result.maximumSignificantDigits = g1.length;
|
|
}
|
|
// .@@## or .@@@ case
|
|
else {
|
|
result.minimumSignificantDigits = g1.length;
|
|
result.maximumSignificantDigits =
|
|
g1.length + (typeof g2 === 'string' ? g2.length : 0);
|
|
}
|
|
return '';
|
|
});
|
|
return result;
|
|
}
|
|
function parseSign(str) {
|
|
switch (str) {
|
|
case 'sign-auto':
|
|
return {
|
|
signDisplay: 'auto',
|
|
};
|
|
case 'sign-accounting':
|
|
return {
|
|
currencySign: 'accounting',
|
|
};
|
|
case 'sign-always':
|
|
return {
|
|
signDisplay: 'always',
|
|
};
|
|
case 'sign-accounting-always':
|
|
return {
|
|
signDisplay: 'always',
|
|
currencySign: 'accounting',
|
|
};
|
|
case 'sign-except-zero':
|
|
return {
|
|
signDisplay: 'exceptZero',
|
|
};
|
|
case 'sign-accounting-except-zero':
|
|
return {
|
|
signDisplay: 'exceptZero',
|
|
currencySign: 'accounting',
|
|
};
|
|
case 'sign-never':
|
|
return {
|
|
signDisplay: 'never',
|
|
};
|
|
}
|
|
}
|
|
function parseNotationOptions(opt) {
|
|
var result = {};
|
|
var signOpts = parseSign(opt);
|
|
if (signOpts) {
|
|
return signOpts;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#skeleton-stems-and-options
|
|
*/
|
|
export function convertNumberSkeletonToNumberFormatOptions(tokens) {
|
|
var result = {};
|
|
for (var _i = 0, tokens_1 = tokens; _i < tokens_1.length; _i++) {
|
|
var token = tokens_1[_i];
|
|
switch (token.stem) {
|
|
case 'percent':
|
|
result.style = 'percent';
|
|
continue;
|
|
case 'currency':
|
|
result.style = 'currency';
|
|
result.currency = token.options[0];
|
|
continue;
|
|
case 'group-off':
|
|
result.useGrouping = false;
|
|
continue;
|
|
case 'precision-integer':
|
|
result.maximumFractionDigits = 0;
|
|
continue;
|
|
case 'measure-unit':
|
|
result.style = 'unit';
|
|
result.unit = icuUnitToEcma(token.options[0]);
|
|
continue;
|
|
case 'compact-short':
|
|
result.notation = 'compact';
|
|
result.compactDisplay = 'short';
|
|
continue;
|
|
case 'compact-long':
|
|
result.notation = 'compact';
|
|
result.compactDisplay = 'long';
|
|
continue;
|
|
case 'scientific':
|
|
result = __assign(__assign(__assign({}, result), { notation: 'scientific' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
|
|
continue;
|
|
case 'engineering':
|
|
result = __assign(__assign(__assign({}, result), { notation: 'engineering' }), token.options.reduce(function (all, opt) { return (__assign(__assign({}, all), parseNotationOptions(opt))); }, {}));
|
|
continue;
|
|
case 'notation-simple':
|
|
result.notation = 'standard';
|
|
continue;
|
|
// https://github.com/unicode-org/icu/blob/master/icu4c/source/i18n/unicode/unumberformatter.h
|
|
case 'unit-width-narrow':
|
|
result.currencyDisplay = 'narrowSymbol';
|
|
result.unitDisplay = 'narrow';
|
|
continue;
|
|
case 'unit-width-short':
|
|
result.currencyDisplay = 'code';
|
|
result.unitDisplay = 'short';
|
|
continue;
|
|
case 'unit-width-full-name':
|
|
result.currencyDisplay = 'name';
|
|
result.unitDisplay = 'long';
|
|
continue;
|
|
case 'unit-width-iso-code':
|
|
result.currencyDisplay = 'symbol';
|
|
continue;
|
|
}
|
|
// Precision
|
|
// https://github.com/unicode-org/icu/blob/master/docs/userguide/format_parse/numbers/skeletons.md#fraction-precision
|
|
if (FRACTION_PRECISION_REGEX.test(token.stem)) {
|
|
if (token.options.length > 1) {
|
|
throw new RangeError('Fraction-precision stems only accept a single optional option');
|
|
}
|
|
token.stem.replace(FRACTION_PRECISION_REGEX, function (match, g1, g2) {
|
|
// precision-integer case
|
|
if (match === '.') {
|
|
result.maximumFractionDigits = 0;
|
|
}
|
|
// .000+ case
|
|
else if (g2 === '+') {
|
|
result.minimumFractionDigits = g2.length;
|
|
}
|
|
// .### case
|
|
else if (g1[0] === '#') {
|
|
result.maximumFractionDigits = g1.length;
|
|
}
|
|
// .00## or .000 case
|
|
else {
|
|
result.minimumFractionDigits = g1.length;
|
|
result.maximumFractionDigits =
|
|
g1.length + (typeof g2 === 'string' ? g2.length : 0);
|
|
}
|
|
return '';
|
|
});
|
|
if (token.options.length) {
|
|
result = __assign(__assign({}, result), parseSignificantPrecision(token.options[0]));
|
|
}
|
|
continue;
|
|
}
|
|
if (SIGNIFICANT_PRECISION_REGEX.test(token.stem)) {
|
|
result = __assign(__assign({}, result), parseSignificantPrecision(token.stem));
|
|
continue;
|
|
}
|
|
var signOpts = parseSign(token.stem);
|
|
if (signOpts) {
|
|
result = __assign(__assign({}, result), signOpts);
|
|
}
|
|
}
|
|
return result;
|
|
}
|