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.
332 lines
11 KiB
332 lines
11 KiB
// https://d3js.org/d3-format/ Version 1.2.2. Copyright 2018 Mike Bostock.
|
|
(function (global, factory) {
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
|
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
|
(factory((global.d3 = global.d3 || {})));
|
|
}(this, (function (exports) { 'use strict';
|
|
|
|
// Computes the decimal coefficient and exponent of the specified number x with
|
|
// significant digits p, where x is positive and p is in [1, 21] or undefined.
|
|
// For example, formatDecimal(1.23) returns ["123", 0].
|
|
var formatDecimal = function(x, p) {
|
|
if ((i = (x = p ? x.toExponential(p - 1) : x.toExponential()).indexOf("e")) < 0) return null; // NaN, ±Infinity
|
|
var i, coefficient = x.slice(0, i);
|
|
|
|
// The string returned by toExponential either has the form \d\.\d+e[-+]\d+
|
|
// (e.g., 1.2e+3) or the form \de[-+]\d+ (e.g., 1e+3).
|
|
return [
|
|
coefficient.length > 1 ? coefficient[0] + coefficient.slice(2) : coefficient,
|
|
+x.slice(i + 1)
|
|
];
|
|
};
|
|
|
|
var exponent = function(x) {
|
|
return x = formatDecimal(Math.abs(x)), x ? x[1] : NaN;
|
|
};
|
|
|
|
var formatGroup = function(grouping, thousands) {
|
|
return function(value, width) {
|
|
var i = value.length,
|
|
t = [],
|
|
j = 0,
|
|
g = grouping[0],
|
|
length = 0;
|
|
|
|
while (i > 0 && g > 0) {
|
|
if (length + g + 1 > width) g = Math.max(1, width - length);
|
|
t.push(value.substring(i -= g, i + g));
|
|
if ((length += g + 1) > width) break;
|
|
g = grouping[j = (j + 1) % grouping.length];
|
|
}
|
|
|
|
return t.reverse().join(thousands);
|
|
};
|
|
};
|
|
|
|
var formatNumerals = function(numerals) {
|
|
return function(value) {
|
|
return value.replace(/[0-9]/g, function(i) {
|
|
return numerals[+i];
|
|
});
|
|
};
|
|
};
|
|
|
|
var formatDefault = function(x, p) {
|
|
x = x.toPrecision(p);
|
|
|
|
out: for (var n = x.length, i = 1, i0 = -1, i1; i < n; ++i) {
|
|
switch (x[i]) {
|
|
case ".": i0 = i1 = i; break;
|
|
case "0": if (i0 === 0) i0 = i; i1 = i; break;
|
|
case "e": break out;
|
|
default: if (i0 > 0) i0 = 0; break;
|
|
}
|
|
}
|
|
|
|
return i0 > 0 ? x.slice(0, i0) + x.slice(i1 + 1) : x;
|
|
};
|
|
|
|
var prefixExponent;
|
|
|
|
var formatPrefixAuto = function(x, p) {
|
|
var d = formatDecimal(x, p);
|
|
if (!d) return x + "";
|
|
var coefficient = d[0],
|
|
exponent = d[1],
|
|
i = exponent - (prefixExponent = Math.max(-8, Math.min(8, Math.floor(exponent / 3))) * 3) + 1,
|
|
n = coefficient.length;
|
|
return i === n ? coefficient
|
|
: i > n ? coefficient + new Array(i - n + 1).join("0")
|
|
: i > 0 ? coefficient.slice(0, i) + "." + coefficient.slice(i)
|
|
: "0." + new Array(1 - i).join("0") + formatDecimal(x, Math.max(0, p + i - 1))[0]; // less than 1y!
|
|
};
|
|
|
|
var formatRounded = function(x, p) {
|
|
var d = formatDecimal(x, p);
|
|
if (!d) return x + "";
|
|
var coefficient = d[0],
|
|
exponent = d[1];
|
|
return exponent < 0 ? "0." + new Array(-exponent).join("0") + coefficient
|
|
: coefficient.length > exponent + 1 ? coefficient.slice(0, exponent + 1) + "." + coefficient.slice(exponent + 1)
|
|
: coefficient + new Array(exponent - coefficient.length + 2).join("0");
|
|
};
|
|
|
|
var formatTypes = {
|
|
"": formatDefault,
|
|
"%": function(x, p) { return (x * 100).toFixed(p); },
|
|
"b": function(x) { return Math.round(x).toString(2); },
|
|
"c": function(x) { return x + ""; },
|
|
"d": function(x) { return Math.round(x).toString(10); },
|
|
"e": function(x, p) { return x.toExponential(p); },
|
|
"f": function(x, p) { return x.toFixed(p); },
|
|
"g": function(x, p) { return x.toPrecision(p); },
|
|
"o": function(x) { return Math.round(x).toString(8); },
|
|
"p": function(x, p) { return formatRounded(x * 100, p); },
|
|
"r": formatRounded,
|
|
"s": formatPrefixAuto,
|
|
"X": function(x) { return Math.round(x).toString(16).toUpperCase(); },
|
|
"x": function(x) { return Math.round(x).toString(16); }
|
|
};
|
|
|
|
// [[fill]align][sign][symbol][0][width][,][.precision][type]
|
|
var re = /^(?:(.)?([<>=^]))?([+\-\( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?([a-z%])?$/i;
|
|
|
|
function formatSpecifier(specifier) {
|
|
return new FormatSpecifier(specifier);
|
|
}
|
|
|
|
formatSpecifier.prototype = FormatSpecifier.prototype; // instanceof
|
|
|
|
function FormatSpecifier(specifier) {
|
|
if (!(match = re.exec(specifier))) throw new Error("invalid format: " + specifier);
|
|
|
|
var match,
|
|
fill = match[1] || " ",
|
|
align = match[2] || ">",
|
|
sign = match[3] || "-",
|
|
symbol = match[4] || "",
|
|
zero = !!match[5],
|
|
width = match[6] && +match[6],
|
|
comma = !!match[7],
|
|
precision = match[8] && +match[8].slice(1),
|
|
type = match[9] || "";
|
|
|
|
// The "n" type is an alias for ",g".
|
|
if (type === "n") comma = true, type = "g";
|
|
|
|
// Map invalid types to the default format.
|
|
else if (!formatTypes[type]) type = "";
|
|
|
|
// If zero fill is specified, padding goes after sign and before digits.
|
|
if (zero || (fill === "0" && align === "=")) zero = true, fill = "0", align = "=";
|
|
|
|
this.fill = fill;
|
|
this.align = align;
|
|
this.sign = sign;
|
|
this.symbol = symbol;
|
|
this.zero = zero;
|
|
this.width = width;
|
|
this.comma = comma;
|
|
this.precision = precision;
|
|
this.type = type;
|
|
}
|
|
|
|
FormatSpecifier.prototype.toString = function() {
|
|
return this.fill
|
|
+ this.align
|
|
+ this.sign
|
|
+ this.symbol
|
|
+ (this.zero ? "0" : "")
|
|
+ (this.width == null ? "" : Math.max(1, this.width | 0))
|
|
+ (this.comma ? "," : "")
|
|
+ (this.precision == null ? "" : "." + Math.max(0, this.precision | 0))
|
|
+ this.type;
|
|
};
|
|
|
|
var identity = function(x) {
|
|
return x;
|
|
};
|
|
|
|
var prefixes = ["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];
|
|
|
|
var formatLocale = function(locale) {
|
|
var group = locale.grouping && locale.thousands ? formatGroup(locale.grouping, locale.thousands) : identity,
|
|
currency = locale.currency,
|
|
decimal = locale.decimal,
|
|
numerals = locale.numerals ? formatNumerals(locale.numerals) : identity,
|
|
percent = locale.percent || "%";
|
|
|
|
function newFormat(specifier) {
|
|
specifier = formatSpecifier(specifier);
|
|
|
|
var fill = specifier.fill,
|
|
align = specifier.align,
|
|
sign = specifier.sign,
|
|
symbol = specifier.symbol,
|
|
zero = specifier.zero,
|
|
width = specifier.width,
|
|
comma = specifier.comma,
|
|
precision = specifier.precision,
|
|
type = specifier.type;
|
|
|
|
// Compute the prefix and suffix.
|
|
// For SI-prefix, the suffix is lazily computed.
|
|
var prefix = symbol === "$" ? currency[0] : symbol === "#" && /[boxX]/.test(type) ? "0" + type.toLowerCase() : "",
|
|
suffix = symbol === "$" ? currency[1] : /[%p]/.test(type) ? percent : "";
|
|
|
|
// What format function should we use?
|
|
// Is this an integer type?
|
|
// Can this type generate exponential notation?
|
|
var formatType = formatTypes[type],
|
|
maybeSuffix = !type || /[defgprs%]/.test(type);
|
|
|
|
// Set the default precision if not specified,
|
|
// or clamp the specified precision to the supported range.
|
|
// For significant precision, it must be in [1, 21].
|
|
// For fixed precision, it must be in [0, 20].
|
|
precision = precision == null ? (type ? 6 : 12)
|
|
: /[gprs]/.test(type) ? Math.max(1, Math.min(21, precision))
|
|
: Math.max(0, Math.min(20, precision));
|
|
|
|
function format(value) {
|
|
var valuePrefix = prefix,
|
|
valueSuffix = suffix,
|
|
i, n, c;
|
|
|
|
if (type === "c") {
|
|
valueSuffix = formatType(value) + valueSuffix;
|
|
value = "";
|
|
} else {
|
|
value = +value;
|
|
|
|
// Perform the initial formatting.
|
|
var valueNegative = value < 0;
|
|
value = formatType(Math.abs(value), precision);
|
|
|
|
// If a negative value rounds to zero during formatting, treat as positive.
|
|
if (valueNegative && +value === 0) valueNegative = false;
|
|
|
|
// Compute the prefix and suffix.
|
|
valuePrefix = (valueNegative ? (sign === "(" ? sign : "-") : sign === "-" || sign === "(" ? "" : sign) + valuePrefix;
|
|
valueSuffix = (type === "s" ? prefixes[8 + prefixExponent / 3] : "") + valueSuffix + (valueNegative && sign === "(" ? ")" : "");
|
|
|
|
// Break the formatted value into the integer “value” part that can be
|
|
// grouped, and fractional or exponential “suffix” part that is not.
|
|
if (maybeSuffix) {
|
|
i = -1, n = value.length;
|
|
while (++i < n) {
|
|
if (c = value.charCodeAt(i), 48 > c || c > 57) {
|
|
valueSuffix = (c === 46 ? decimal + value.slice(i + 1) : value.slice(i)) + valueSuffix;
|
|
value = value.slice(0, i);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If the fill character is not "0", grouping is applied before padding.
|
|
if (comma && !zero) value = group(value, Infinity);
|
|
|
|
// Compute the padding.
|
|
var length = valuePrefix.length + value.length + valueSuffix.length,
|
|
padding = length < width ? new Array(width - length + 1).join(fill) : "";
|
|
|
|
// If the fill character is "0", grouping is applied after padding.
|
|
if (comma && zero) value = group(padding + value, padding.length ? width - valueSuffix.length : Infinity), padding = "";
|
|
|
|
// Reconstruct the final output based on the desired alignment.
|
|
switch (align) {
|
|
case "<": value = valuePrefix + value + valueSuffix + padding; break;
|
|
case "=": value = valuePrefix + padding + value + valueSuffix; break;
|
|
case "^": value = padding.slice(0, length = padding.length >> 1) + valuePrefix + value + valueSuffix + padding.slice(length); break;
|
|
default: value = padding + valuePrefix + value + valueSuffix; break;
|
|
}
|
|
|
|
return numerals(value);
|
|
}
|
|
|
|
format.toString = function() {
|
|
return specifier + "";
|
|
};
|
|
|
|
return format;
|
|
}
|
|
|
|
function formatPrefix(specifier, value) {
|
|
var f = newFormat((specifier = formatSpecifier(specifier), specifier.type = "f", specifier)),
|
|
e = Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3,
|
|
k = Math.pow(10, -e),
|
|
prefix = prefixes[8 + e / 3];
|
|
return function(value) {
|
|
return f(k * value) + prefix;
|
|
};
|
|
}
|
|
|
|
return {
|
|
format: newFormat,
|
|
formatPrefix: formatPrefix
|
|
};
|
|
};
|
|
|
|
var locale;
|
|
|
|
|
|
|
|
defaultLocale({
|
|
decimal: ".",
|
|
thousands: ",",
|
|
grouping: [3],
|
|
currency: ["$", ""]
|
|
});
|
|
|
|
function defaultLocale(definition) {
|
|
locale = formatLocale(definition);
|
|
exports.format = locale.format;
|
|
exports.formatPrefix = locale.formatPrefix;
|
|
return locale;
|
|
}
|
|
|
|
var precisionFixed = function(step) {
|
|
return Math.max(0, -exponent(Math.abs(step)));
|
|
};
|
|
|
|
var precisionPrefix = function(step, value) {
|
|
return Math.max(0, Math.max(-8, Math.min(8, Math.floor(exponent(value) / 3))) * 3 - exponent(Math.abs(step)));
|
|
};
|
|
|
|
var precisionRound = function(step, max) {
|
|
step = Math.abs(step), max = Math.abs(max) - step;
|
|
return Math.max(0, exponent(max) - exponent(step)) + 1;
|
|
};
|
|
|
|
exports.formatDefaultLocale = defaultLocale;
|
|
exports.formatLocale = formatLocale;
|
|
exports.formatSpecifier = formatSpecifier;
|
|
exports.precisionFixed = precisionFixed;
|
|
exports.precisionPrefix = precisionPrefix;
|
|
exports.precisionRound = precisionRound;
|
|
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
|
|
})));
|