@phensley/cldr-core
Version:
Core library for @phensley/cldr
128 lines • 5.53 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Provides a context to set number formatting parameters, combining user-supplied
* options with defaults based on modes and the number pattern.
*/
var NumberContext = /** @class */ (function () {
function NumberContext(options, compact, currencyDigits) {
if (currencyDigits === void 0) { currencyDigits = -1; }
this.minInt = -1;
this.maxFrac = -1;
this.minFrac = -1;
this.maxSig = -1;
this.minSig = -1;
this.currencyDigits = -1;
var o = options;
this.options = o;
this.roundingMode = options.round || 'half-even';
this.currencyDigits = currencyDigits;
// Determine if we should use default or significant digit modes. If we're in compact mode
// we will use significant digits unless any fraction option is set. Otherwise we use
// significant digits if any significant digit option is set.
var optFrac = o.minimumFractionDigits !== undefined || o.maximumFractionDigits !== undefined;
var optSig = o.minimumSignificantDigits !== undefined || o.maximumSignificantDigits !== undefined;
this.useSignificant = (compact && !optFrac) || optSig;
}
/**
* Set a pattern.
*/
NumberContext.prototype.setPattern = function (pattern) {
this._setPattern(pattern, -1, -1, -1);
};
/**
* Set a compact pattern.
*/
NumberContext.prototype.setCompact = function (pattern, integerDigits, divisor, maxFracDigits) {
if (maxFracDigits === void 0) { maxFracDigits = -1; }
var maxSigDigits = Math.max(pattern.minInt, integerDigits);
if (integerDigits === 1) {
maxSigDigits++;
}
this._setPattern(pattern, maxSigDigits, 1, maxFracDigits);
};
/**
* Adjust the scale of the number using the resolved parameters.
*/
NumberContext.prototype.adjust = function (n) {
if (this.useSignificant && this.minSig > 0 && this.maxSig > 0) {
if (n.precision() > this.maxSig) {
// Scale the number to have at most the maximum significant digits.
var scale = this.maxSig - n.precision() + n.scale();
n = n.setScale(scale, this.roundingMode);
}
// Ensure that one less digit is emitted if the number is exactly zero.
n = n.stripTrailingZeros();
var zero = n.signum() === 0;
var precision = n.precision();
if (zero && n.scale() === 1) {
precision--;
}
// scale the number to have at least the minimum significant digits
if (precision < this.minSig) {
var scale = this.minSig - precision + n.scale();
n = n.setScale(scale, this.roundingMode);
}
}
else {
// Precise control over number of integer and decimal digits to include, e.g. when
// formatting exact currency values.
var scale = Math.max(this.minFrac, Math.min(n.scale(), this.maxFrac));
n = n.setScale(scale, this.roundingMode);
n = n.stripTrailingZeros();
// Ensure minimum fraction digits is met.
if (n.scale() < this.minFrac) {
n = n.setScale(this.minFrac, this.roundingMode);
}
}
return n;
};
/**
* Set context parameters from options, pattern and significant digit arguments.
*/
NumberContext.prototype._setPattern = function (pattern, maxSigDigits, minSigDigits, maxFracDigits) {
var o = this.options;
this.minInt = orDefault(o.minimumIntegerDigits, pattern.minInt);
this.minFrac = this.currencyDigits === -1 ? pattern.minFrac : this.currencyDigits;
this.maxFrac = this.currencyDigits === -1 ? pattern.maxFrac : this.currencyDigits;
var minFrac = o.minimumFractionDigits;
var maxFrac = o.maximumFractionDigits;
if (minFrac === undefined && maxFrac === undefined && maxFracDigits > -1) {
maxFrac = maxFracDigits;
}
if (maxFrac !== undefined && maxFrac > -1) {
this.maxFrac = maxFrac;
}
if (minFrac !== undefined && minFrac > -1) {
this.minFrac = maxFrac !== undefined && maxFrac > -1 ? (maxFrac < minFrac ? maxFrac : minFrac) : minFrac;
if (this.minFrac > this.maxFrac) {
this.maxFrac = this.minFrac;
}
}
if (maxFrac !== undefined && maxFrac > -1) {
if (this.maxFrac < this.minFrac || this.minFrac === -1) {
this.minFrac = this.maxFrac;
}
}
if (this.useSignificant) {
var minSig = orDefault(o.minimumSignificantDigits, minSigDigits);
var maxSig = orDefault(o.maximumSignificantDigits, maxSigDigits);
if (minSig !== -1 && minSig > maxSig) {
maxSig = minSig;
}
if (maxSig !== -1 && maxSig < minSig) {
minSig = maxSig;
}
this.minSig = minSig === -1 ? maxSig : minSig;
this.maxSig = maxSig === -1 ? minSig : maxSig;
}
else {
this.maxSig = -1;
this.minSig = -1;
}
};
return NumberContext;
}());
exports.NumberContext = NumberContext;
var orDefault = function (n, alt) { return n === undefined ? alt : n; };
//# sourceMappingURL=context.js.map