You've already forked wakapi-readme-stats
Bar graph added.
This commit is contained in:
prabhatdev
956
node_modules/vega-scale/build/vega-scale.js
generated
vendored
Normal file
956
node_modules/vega-scale/build/vega-scale.js
generated
vendored
Normal file
@@ -0,0 +1,956 @@
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-util'), require('d3-array'), require('d3-scale'), require('d3-interpolate'), require('vega-time')) :
|
||||
typeof define === 'function' && define.amd ? define(['exports', 'vega-util', 'd3-array', 'd3-scale', 'd3-interpolate', 'vega-time'], factory) :
|
||||
(global = global || self, factory(global.vega = {}, global.vega, global.d3, global.d3, global.d3, global.vega));
|
||||
}(this, (function (exports, vegaUtil, d3Array, $, $$1, vegaTime) { 'use strict';
|
||||
|
||||
function bandSpace(count, paddingInner, paddingOuter) {
|
||||
var space = count - paddingInner + paddingOuter * 2;
|
||||
return count ? (space > 0 ? space : 1) : 0;
|
||||
}
|
||||
|
||||
const Identity = 'identity';
|
||||
|
||||
const Linear = 'linear';
|
||||
const Log = 'log';
|
||||
const Pow = 'pow';
|
||||
const Sqrt = 'sqrt';
|
||||
const Symlog = 'symlog';
|
||||
|
||||
const Time = 'time';
|
||||
const UTC = 'utc';
|
||||
|
||||
const Sequential = 'sequential';
|
||||
const Diverging = 'diverging';
|
||||
|
||||
const Quantile = 'quantile';
|
||||
const Quantize = 'quantize';
|
||||
const Threshold = 'threshold';
|
||||
|
||||
const Ordinal = 'ordinal';
|
||||
const Point = 'point';
|
||||
const Band = 'band';
|
||||
const BinOrdinal = 'bin-ordinal';
|
||||
|
||||
// categories
|
||||
const Continuous = 'continuous';
|
||||
const Discrete = 'discrete';
|
||||
const Discretizing = 'discretizing';
|
||||
const Interpolating = 'interpolating';
|
||||
const Temporal = 'temporal';
|
||||
|
||||
function invertRange(scale) {
|
||||
return function(_) {
|
||||
var lo = _[0],
|
||||
hi = _[1],
|
||||
t;
|
||||
|
||||
if (hi < lo) {
|
||||
t = lo;
|
||||
lo = hi;
|
||||
hi = t;
|
||||
}
|
||||
|
||||
return [
|
||||
scale.invert(lo),
|
||||
scale.invert(hi)
|
||||
];
|
||||
};
|
||||
}
|
||||
|
||||
function invertRangeExtent(scale) {
|
||||
return function(_) {
|
||||
var range = scale.range(),
|
||||
lo = _[0],
|
||||
hi = _[1],
|
||||
min = -1, max, t, i, n;
|
||||
|
||||
if (hi < lo) {
|
||||
t = lo;
|
||||
lo = hi;
|
||||
hi = t;
|
||||
}
|
||||
|
||||
for (i=0, n=range.length; i<n; ++i) {
|
||||
if (range[i] >= lo && range[i] <= hi) {
|
||||
if (min < 0) min = i;
|
||||
max = i;
|
||||
}
|
||||
}
|
||||
|
||||
if (min < 0) return undefined;
|
||||
|
||||
lo = scale.invertExtent(range[min]);
|
||||
hi = scale.invertExtent(range[max]);
|
||||
|
||||
return [
|
||||
lo[0] === undefined ? lo[1] : lo[0],
|
||||
hi[1] === undefined ? hi[0] : hi[1]
|
||||
];
|
||||
};
|
||||
}
|
||||
|
||||
function band() {
|
||||
var scale = $.scaleOrdinal().unknown(undefined),
|
||||
domain = scale.domain,
|
||||
ordinalRange = scale.range,
|
||||
range = [0, 1],
|
||||
step,
|
||||
bandwidth,
|
||||
round = false,
|
||||
paddingInner = 0,
|
||||
paddingOuter = 0,
|
||||
align = 0.5;
|
||||
|
||||
delete scale.unknown;
|
||||
|
||||
function rescale() {
|
||||
var n = domain().length,
|
||||
reverse = range[1] < range[0],
|
||||
start = range[reverse - 0],
|
||||
stop = range[1 - reverse],
|
||||
space = bandSpace(n, paddingInner, paddingOuter);
|
||||
|
||||
step = (stop - start) / (space || 1);
|
||||
if (round) {
|
||||
step = Math.floor(step);
|
||||
}
|
||||
start += (stop - start - step * (n - paddingInner)) * align;
|
||||
bandwidth = step * (1 - paddingInner);
|
||||
if (round) {
|
||||
start = Math.round(start);
|
||||
bandwidth = Math.round(bandwidth);
|
||||
}
|
||||
var values = d3Array.range(n).map(function(i) { return start + step * i; });
|
||||
return ordinalRange(reverse ? values.reverse() : values);
|
||||
}
|
||||
|
||||
scale.domain = function(_) {
|
||||
if (arguments.length) {
|
||||
domain(_);
|
||||
return rescale();
|
||||
} else {
|
||||
return domain();
|
||||
}
|
||||
};
|
||||
|
||||
scale.range = function(_) {
|
||||
if (arguments.length) {
|
||||
range = [+_[0], +_[1]];
|
||||
return rescale();
|
||||
} else {
|
||||
return range.slice();
|
||||
}
|
||||
};
|
||||
|
||||
scale.rangeRound = function(_) {
|
||||
range = [+_[0], +_[1]];
|
||||
round = true;
|
||||
return rescale();
|
||||
};
|
||||
|
||||
scale.bandwidth = function() {
|
||||
return bandwidth;
|
||||
};
|
||||
|
||||
scale.step = function() {
|
||||
return step;
|
||||
};
|
||||
|
||||
scale.round = function(_) {
|
||||
if (arguments.length) {
|
||||
round = !!_;
|
||||
return rescale();
|
||||
} else {
|
||||
return round;
|
||||
}
|
||||
};
|
||||
|
||||
scale.padding = function(_) {
|
||||
if (arguments.length) {
|
||||
paddingOuter = Math.max(0, Math.min(1, _));
|
||||
paddingInner = paddingOuter;
|
||||
return rescale();
|
||||
} else {
|
||||
return paddingInner;
|
||||
}
|
||||
};
|
||||
|
||||
scale.paddingInner = function(_) {
|
||||
if (arguments.length) {
|
||||
paddingInner = Math.max(0, Math.min(1, _));
|
||||
return rescale();
|
||||
} else {
|
||||
return paddingInner;
|
||||
}
|
||||
};
|
||||
|
||||
scale.paddingOuter = function(_) {
|
||||
if (arguments.length) {
|
||||
paddingOuter = Math.max(0, Math.min(1, _));
|
||||
return rescale();
|
||||
} else {
|
||||
return paddingOuter;
|
||||
}
|
||||
};
|
||||
|
||||
scale.align = function(_) {
|
||||
if (arguments.length) {
|
||||
align = Math.max(0, Math.min(1, _));
|
||||
return rescale();
|
||||
} else {
|
||||
return align;
|
||||
}
|
||||
};
|
||||
|
||||
scale.invertRange = function(_) {
|
||||
// bail if range has null or undefined values
|
||||
if (_[0] == null || _[1] == null) return;
|
||||
|
||||
var lo = +_[0],
|
||||
hi = +_[1],
|
||||
reverse = range[1] < range[0],
|
||||
values = reverse ? ordinalRange().reverse() : ordinalRange(),
|
||||
n = values.length - 1, a, b, t;
|
||||
|
||||
// bail if either range endpoint is invalid
|
||||
if (lo !== lo || hi !== hi) return;
|
||||
|
||||
// order range inputs, bail if outside of scale range
|
||||
if (hi < lo) {
|
||||
t = lo;
|
||||
lo = hi;
|
||||
hi = t;
|
||||
}
|
||||
if (hi < values[0] || lo > range[1-reverse]) return;
|
||||
|
||||
// binary search to index into scale range
|
||||
a = Math.max(0, d3Array.bisectRight(values, lo) - 1);
|
||||
b = lo===hi ? a : d3Array.bisectRight(values, hi) - 1;
|
||||
|
||||
// increment index a if lo is within padding gap
|
||||
if (lo - values[a] > bandwidth + 1e-10) ++a;
|
||||
|
||||
if (reverse) {
|
||||
// map + swap
|
||||
t = a;
|
||||
a = n - b;
|
||||
b = n - t;
|
||||
}
|
||||
return (a > b) ? undefined : domain().slice(a, b+1);
|
||||
};
|
||||
|
||||
scale.invert = function(_) {
|
||||
var value = scale.invertRange([_, _]);
|
||||
return value ? value[0] : value;
|
||||
};
|
||||
|
||||
scale.copy = function() {
|
||||
return band()
|
||||
.domain(domain())
|
||||
.range(range)
|
||||
.round(round)
|
||||
.paddingInner(paddingInner)
|
||||
.paddingOuter(paddingOuter)
|
||||
.align(align);
|
||||
};
|
||||
|
||||
return rescale();
|
||||
}
|
||||
|
||||
function pointish(scale) {
|
||||
var copy = scale.copy;
|
||||
|
||||
scale.padding = scale.paddingOuter;
|
||||
delete scale.paddingInner;
|
||||
|
||||
scale.copy = function() {
|
||||
return pointish(copy());
|
||||
};
|
||||
|
||||
return scale;
|
||||
}
|
||||
|
||||
function point() {
|
||||
return pointish(band().paddingInner(1));
|
||||
}
|
||||
|
||||
var map = Array.prototype.map;
|
||||
|
||||
function numbers(_) {
|
||||
return map.call(_, function(x) { return +x; });
|
||||
}
|
||||
|
||||
var slice = Array.prototype.slice;
|
||||
|
||||
function scaleBinOrdinal() {
|
||||
var domain = [],
|
||||
range = [];
|
||||
|
||||
function scale(x) {
|
||||
return x == null || x !== x
|
||||
? undefined
|
||||
: range[(d3Array.bisect(domain, x) - 1) % range.length];
|
||||
}
|
||||
|
||||
scale.domain = function(_) {
|
||||
if (arguments.length) {
|
||||
domain = numbers(_);
|
||||
return scale;
|
||||
} else {
|
||||
return domain.slice();
|
||||
}
|
||||
};
|
||||
|
||||
scale.range = function(_) {
|
||||
if (arguments.length) {
|
||||
range = slice.call(_);
|
||||
return scale;
|
||||
} else {
|
||||
return range.slice();
|
||||
}
|
||||
};
|
||||
|
||||
scale.tickFormat = function(count, specifier) {
|
||||
return $.tickFormat(domain[0], vegaUtil.peek(domain), count == null ? 10 : count, specifier);
|
||||
};
|
||||
|
||||
scale.copy = function() {
|
||||
return scaleBinOrdinal().domain(scale.domain()).range(scale.range());
|
||||
};
|
||||
|
||||
return scale;
|
||||
}
|
||||
|
||||
// scale registry
|
||||
const scales = {};
|
||||
|
||||
/**
|
||||
* Augment scales with their type and needed inverse methods.
|
||||
*/
|
||||
function create(type, constructor, metadata) {
|
||||
const ctr = function scale() {
|
||||
var s = constructor();
|
||||
|
||||
if (!s.invertRange) {
|
||||
s.invertRange = s.invert ? invertRange(s)
|
||||
: s.invertExtent ? invertRangeExtent(s)
|
||||
: undefined;
|
||||
}
|
||||
|
||||
s.type = type;
|
||||
return s;
|
||||
};
|
||||
|
||||
ctr.metadata = vegaUtil.toSet(vegaUtil.array(metadata));
|
||||
|
||||
return ctr;
|
||||
}
|
||||
|
||||
function scale(type, scale, metadata) {
|
||||
if (arguments.length > 1) {
|
||||
scales[type] = create(type, scale, metadata);
|
||||
return this;
|
||||
} else {
|
||||
return isValidScaleType(type) ? scales[type] : undefined;
|
||||
}
|
||||
}
|
||||
|
||||
// identity scale
|
||||
scale(Identity, $.scaleIdentity);
|
||||
|
||||
// continuous scales
|
||||
scale(Linear, $.scaleLinear, Continuous);
|
||||
scale(Log, $.scaleLog, [Continuous, Log]);
|
||||
scale(Pow, $.scalePow, Continuous);
|
||||
scale(Sqrt, $.scaleSqrt, Continuous);
|
||||
scale(Symlog, $.scaleSymlog, Continuous);
|
||||
scale(Time, $.scaleTime, [Continuous, Temporal]);
|
||||
scale(UTC, $.scaleUtc, [Continuous, Temporal]);
|
||||
|
||||
// sequential scales
|
||||
scale(Sequential, $.scaleSequential, [Continuous, Interpolating]); // backwards compat
|
||||
scale(`${Sequential}-${Linear}`, $.scaleSequential, [Continuous, Interpolating]);
|
||||
scale(`${Sequential}-${Log}`, $.scaleSequentialLog, [Continuous, Interpolating, Log]);
|
||||
scale(`${Sequential}-${Pow}`, $.scaleSequentialPow, [Continuous, Interpolating]);
|
||||
scale(`${Sequential}-${Sqrt}`, $.scaleSequentialSqrt, [Continuous, Interpolating]);
|
||||
scale(`${Sequential}-${Symlog}`, $.scaleSequentialSymlog, [Continuous, Interpolating]);
|
||||
|
||||
// diverging scales
|
||||
scale(`${Diverging}-${Linear}`, $.scaleDiverging, [Continuous, Interpolating]);
|
||||
scale(`${Diverging}-${Log}`, $.scaleDivergingLog, [Continuous, Interpolating, Log]);
|
||||
scale(`${Diverging}-${Pow}`, $.scaleDivergingPow, [Continuous, Interpolating]);
|
||||
scale(`${Diverging}-${Sqrt}`, $.scaleDivergingSqrt, [Continuous, Interpolating]);
|
||||
scale(`${Diverging}-${Symlog}`, $.scaleDivergingSymlog, [Continuous, Interpolating]);
|
||||
|
||||
// discretizing scales
|
||||
scale(Quantile, $.scaleQuantile, [Discretizing, Quantile]);
|
||||
scale(Quantize, $.scaleQuantize, Discretizing);
|
||||
scale(Threshold, $.scaleThreshold, Discretizing);
|
||||
|
||||
// discrete scales
|
||||
scale(BinOrdinal, scaleBinOrdinal, [Discrete, Discretizing]);
|
||||
scale(Ordinal, $.scaleOrdinal, Discrete);
|
||||
scale(Band, band, Discrete);
|
||||
scale(Point, point, Discrete);
|
||||
|
||||
function isValidScaleType(type) {
|
||||
return vegaUtil.hasOwnProperty(scales, type);
|
||||
}
|
||||
|
||||
function hasType(key, type) {
|
||||
const s = scales[key];
|
||||
return s && s.metadata[type];
|
||||
}
|
||||
|
||||
function isContinuous(key) {
|
||||
return hasType(key, Continuous);
|
||||
}
|
||||
|
||||
function isDiscrete(key) {
|
||||
return hasType(key, Discrete);
|
||||
}
|
||||
|
||||
function isDiscretizing(key) {
|
||||
return hasType(key, Discretizing);
|
||||
}
|
||||
|
||||
function isLogarithmic(key) {
|
||||
return hasType(key, Log);
|
||||
}
|
||||
|
||||
function isTemporal(key) {
|
||||
return hasType(key, Temporal);
|
||||
}
|
||||
|
||||
function isInterpolating(key) {
|
||||
return hasType(key, Interpolating);
|
||||
}
|
||||
|
||||
function isQuantile(key) {
|
||||
return hasType(key, Quantile);
|
||||
}
|
||||
|
||||
const scaleProps = ['clamp', 'base', 'constant', 'exponent'];
|
||||
|
||||
function interpolateRange(interpolator, range) {
|
||||
var start = range[0],
|
||||
span = vegaUtil.peek(range) - start;
|
||||
return function(i) { return interpolator(start + i * span); };
|
||||
}
|
||||
|
||||
function interpolateColors(colors, type, gamma) {
|
||||
return $$1.piecewise(interpolate(type || 'rgb', gamma), colors);
|
||||
}
|
||||
|
||||
function quantizeInterpolator(interpolator, count) {
|
||||
var samples = new Array(count),
|
||||
n = count + 1;
|
||||
for (var i = 0; i < count;) samples[i] = interpolator(++i / n);
|
||||
return samples;
|
||||
}
|
||||
|
||||
function scaleCopy(scale) {
|
||||
const t = scale.type,
|
||||
s = scale.copy();
|
||||
s.type = t;
|
||||
return s;
|
||||
}
|
||||
|
||||
function scaleFraction(scale$1, min, max) {
|
||||
var delta = max - min, i, t, s;
|
||||
|
||||
if (!delta || !Number.isFinite(delta)) {
|
||||
return vegaUtil.constant(0.5);
|
||||
} else {
|
||||
i = (t = scale$1.type).indexOf('-');
|
||||
t = i < 0 ? t : t.slice(i + 1);
|
||||
s = scale(t)().domain([min, max]).range([0, 1]);
|
||||
scaleProps.forEach(m => scale$1[m] ? s[m](scale$1[m]()) : 0);
|
||||
return s;
|
||||
}
|
||||
}
|
||||
|
||||
function interpolate(type, gamma) {
|
||||
var interp = $$1[method(type)];
|
||||
return (gamma != null && interp && interp.gamma)
|
||||
? interp.gamma(gamma)
|
||||
: interp;
|
||||
}
|
||||
|
||||
function method(type) {
|
||||
return 'interpolate' + type.toLowerCase()
|
||||
.split('-')
|
||||
.map(function(s) { return s[0].toUpperCase() + s.slice(1); })
|
||||
.join('');
|
||||
}
|
||||
|
||||
const continuous = {
|
||||
blues: 'cfe1f2bed8eca8cee58fc1de74b2d75ba3cf4592c63181bd206fb2125ca40a4a90',
|
||||
greens: 'd3eecdc0e6baabdda594d3917bc77d60ba6c46ab5e329a512089430e7735036429',
|
||||
greys: 'e2e2e2d4d4d4c4c4c4b1b1b19d9d9d8888887575756262624d4d4d3535351e1e1e',
|
||||
oranges: 'fdd8b3fdc998fdb87bfda55efc9244f87f2cf06b18e4580bd14904b93d029f3303',
|
||||
purples: 'e2e1efd4d4e8c4c5e0b4b3d6a3a0cc928ec3827cb97566ae684ea25c3696501f8c',
|
||||
reds: 'fdc9b4fcb49afc9e80fc8767fa7051f6573fec3f2fdc2a25c81b1db21218970b13',
|
||||
|
||||
blueGreen: 'd5efedc1e8e0a7ddd18bd2be70c6a958ba9144ad77319c5d2089460e7736036429',
|
||||
bluePurple: 'ccddecbad0e4a8c2dd9ab0d4919cc98d85be8b6db28a55a6873c99822287730f71',
|
||||
greenBlue: 'd3eecec5e8c3b1e1bb9bd8bb82cec269c2ca51b2cd3c9fc7288abd1675b10b60a1',
|
||||
orangeRed: 'fddcaffdcf9bfdc18afdad77fb9562f67d53ee6545e24932d32d1ebf130da70403',
|
||||
purpleBlue: 'dbdaebc8cee4b1c3de97b7d87bacd15b9fc93a90c01e7fb70b70ab056199045281',
|
||||
purpleBlueGreen: 'dbd8eac8cee4b0c3de93b7d872acd1549fc83892bb1c88a3097f8702736b016353',
|
||||
purpleRed: 'dcc9e2d3b3d7ce9eccd186c0da6bb2e14da0e23189d91e6fc61159ab07498f023a',
|
||||
redPurple: 'fccfccfcbec0faa9b8f98faff571a5ec539ddb3695c41b8aa908808d0179700174',
|
||||
yellowGreen: 'e4f4acd1eca0b9e2949ed68880c97c62bb6e47aa5e3297502083440e723b036034',
|
||||
yellowOrangeBrown: 'feeaa1fedd84fecc63feb746fca031f68921eb7215db5e0bc54c05ab3d038f3204',
|
||||
yellowOrangeRed: 'fee087fed16ffebd59fea849fd903efc7335f9522bee3423de1b20ca0b22af0225',
|
||||
|
||||
blueOrange: '134b852f78b35da2cb9dcae1d2e5eff2f0ebfce0bafbbf74e8932fc5690d994a07',
|
||||
brownBlueGreen: '704108a0651ac79548e3c78af3e6c6eef1eac9e9e48ed1c74da79e187a72025147',
|
||||
purpleGreen: '5b1667834792a67fb6c9aed3e6d6e8eff0efd9efd5aedda971bb75368e490e5e29',
|
||||
purpleOrange: '4114696647968f83b7b9b4d6dadbebf3eeeafce0bafbbf74e8932fc5690d994a07',
|
||||
redBlue: '8c0d25bf363adf745ef4ae91fbdbc9f2efeed2e5ef9dcae15da2cb2f78b3134b85',
|
||||
redGrey: '8c0d25bf363adf745ef4ae91fcdccbfaf4f1e2e2e2c0c0c0969696646464343434',
|
||||
yellowGreenBlue: 'eff9bddbf1b4bde5b594d5b969c5be45b4c22c9ec02182b82163aa23479c1c3185',
|
||||
redYellowBlue: 'a50026d4322cf16e43fcac64fedd90faf8c1dcf1ecabd6e875abd04a74b4313695',
|
||||
redYellowGreen: 'a50026d4322cf16e43fcac63fedd8df9f7aed7ee8ea4d86e64bc6122964f006837',
|
||||
pinkYellowGreen: '8e0152c0267edd72adf0b3d6faddedf5f3efe1f2cab6de8780bb474f9125276419',
|
||||
spectral: '9e0142d13c4bf0704afcac63fedd8dfbf8b0e0f3a1a9dda269bda94288b55e4fa2',
|
||||
|
||||
viridis: '440154470e61481a6c482575472f7d443a834144873d4e8a39568c35608d31688e2d708e2a788e27818e23888e21918d1f988b1fa08822a8842ab07f35b77943bf7154c56866cc5d7ad1518fd744a5db36bcdf27d2e21be9e51afde725',
|
||||
magma: '0000040404130b0924150e3720114b2c11603b0f704a107957157e651a80721f817f24828c29819a2e80a8327db6377ac43c75d1426fde4968e95462f1605df76f5cfa7f5efc8f65fe9f6dfeaf78febf84fece91fddea0fcedaffcfdbf',
|
||||
inferno: '0000040403130c0826170c3b240c4f330a5f420a68500d6c5d126e6b176e781c6d86216b932667a12b62ae305cbb3755c73e4cd24644dd513ae65c30ed6925f3771af8850ffb9506fca50afcb519fac62df6d645f2e661f3f484fcffa4',
|
||||
plasma: '0d088723069033059742039d5002a25d01a66a00a87801a88405a7900da49c179ea72198b12a90ba3488c33d80cb4779d35171da5a69e16462e76e5bed7953f2834cf68f44fa9a3dfca636fdb32ffec029fcce25f9dc24f5ea27f0f921',
|
||||
|
||||
rainbow: '6e40aa883eb1a43db3bf3cafd83fa4ee4395fe4b83ff576eff6659ff7847ff8c38f3a130e2b72fcfcc36bee044aff05b8ff4576ff65b52f6673af27828ea8d1ddfa319d0b81cbecb23abd82f96e03d82e14c6edb5a5dd0664dbf6e40aa',
|
||||
sinebow: 'ff4040fc582af47218e78d0bd5a703bfbf00a7d5038de70b72f41858fc2a40ff402afc5818f4720be78d03d5a700bfbf03a7d50b8de71872f42a58fc4040ff582afc7218f48d0be7a703d5bf00bfd503a7e70b8df41872fc2a58ff4040',
|
||||
|
||||
browns: 'eedbbdecca96e9b97ae4a865dc9856d18954c7784cc0673fb85536ad44339f3632',
|
||||
tealBlues: 'bce4d89dd3d181c3cb65b3c245a2b9368fae347da0306a932c5985',
|
||||
teals: 'bbdfdfa2d4d58ac9c975bcbb61b0af4da5a43799982b8b8c1e7f7f127273006667',
|
||||
warmGreys: 'dcd4d0cec5c1c0b8b4b3aaa7a59c9998908c8b827f7e7673726866665c5a59504e',
|
||||
|
||||
goldGreen: 'f4d166d5ca60b6c35c98bb597cb25760a6564b9c533f8f4f33834a257740146c36',
|
||||
goldOrange: 'f4d166f8be5cf8aa4cf5983bf3852aef701be2621fd65322c54923b142239e3a26',
|
||||
goldRed: 'f4d166f6be59f9aa51fc964ef6834bee734ae56249db5247cf4244c43141b71d3e',
|
||||
|
||||
lightGreyRed: 'efe9e6e1dad7d5cbc8c8bdb9bbaea9cd967ddc7b43e15f19df4011dc000b',
|
||||
lightGreyTeal: 'e4eaead6dcddc8ced2b7c2c7a6b4bc64b0bf22a6c32295c11f85be1876bc',
|
||||
lightMulti: 'e0f1f2c4e9d0b0de9fd0e181f6e072f6c053f3993ef77440ef4a3c',
|
||||
lightOrange: 'f2e7daf7d5baf9c499fab184fa9c73f68967ef7860e8645bde515bd43d5b',
|
||||
lightTealBlue: 'e3e9e0c0dccf9aceca7abfc859afc0389fb9328dad2f7ca0276b95255988',
|
||||
|
||||
darkBlue: '3232322d46681a5c930074af008cbf05a7ce25c0dd38daed50f3faffffff',
|
||||
darkGold: '3c3c3c584b37725e348c7631ae8b2bcfa424ecc31ef9de30fff184ffffff',
|
||||
darkGreen: '3a3a3a215748006f4d048942489e4276b340a6c63dd2d836ffeb2cffffaa',
|
||||
darkMulti: '3737371f5287197d8c29a86995ce3fffe800ffffff',
|
||||
darkRed: '3434347036339e3c38cc4037e75d1eec8620eeab29f0ce32ffeb2c'
|
||||
};
|
||||
|
||||
const discrete = {
|
||||
category10: '1f77b4ff7f0e2ca02cd627289467bd8c564be377c27f7f7fbcbd2217becf',
|
||||
category20: '1f77b4aec7e8ff7f0effbb782ca02c98df8ad62728ff98969467bdc5b0d58c564bc49c94e377c2f7b6d27f7f7fc7c7c7bcbd22dbdb8d17becf9edae5',
|
||||
category20b: '393b795254a36b6ecf9c9ede6379398ca252b5cf6bcedb9c8c6d31bd9e39e7ba52e7cb94843c39ad494ad6616be7969c7b4173a55194ce6dbdde9ed6',
|
||||
category20c: '3182bd6baed69ecae1c6dbefe6550dfd8d3cfdae6bfdd0a231a35474c476a1d99bc7e9c0756bb19e9ac8bcbddcdadaeb636363969696bdbdbdd9d9d9',
|
||||
tableau10: '4c78a8f58518e4575672b7b254a24beeca3bb279a2ff9da69d755dbab0ac',
|
||||
tableau20: '4c78a89ecae9f58518ffbf7954a24b88d27ab79a20f2cf5b43989483bcb6e45756ff9d9879706ebab0acd67195fcbfd2b279a2d6a5c99e765fd8b5a5',
|
||||
accent: '7fc97fbeaed4fdc086ffff99386cb0f0027fbf5b17666666',
|
||||
dark2: '1b9e77d95f027570b3e7298a66a61ee6ab02a6761d666666',
|
||||
paired: 'a6cee31f78b4b2df8a33a02cfb9a99e31a1cfdbf6fff7f00cab2d66a3d9affff99b15928',
|
||||
pastel1: 'fbb4aeb3cde3ccebc5decbe4fed9a6ffffcce5d8bdfddaecf2f2f2',
|
||||
pastel2: 'b3e2cdfdcdaccbd5e8f4cae4e6f5c9fff2aef1e2cccccccc',
|
||||
set1: 'e41a1c377eb84daf4a984ea3ff7f00ffff33a65628f781bf999999',
|
||||
set2: '66c2a5fc8d628da0cbe78ac3a6d854ffd92fe5c494b3b3b3',
|
||||
set3: '8dd3c7ffffb3bebadafb807280b1d3fdb462b3de69fccde5d9d9d9bc80bdccebc5ffed6f'
|
||||
};
|
||||
|
||||
function colors(palette) {
|
||||
var n = palette.length / 6 | 0, c = new Array(n), i = 0;
|
||||
while (i < n) c[i] = '#' + palette.slice(i * 6, ++i * 6);
|
||||
return c;
|
||||
}
|
||||
|
||||
function apply(_, f) {
|
||||
for (let k in _) scheme(k, f(_[k]));
|
||||
}
|
||||
|
||||
const schemes = {};
|
||||
apply(discrete, colors);
|
||||
apply(continuous, _ => interpolateColors(colors(_)));
|
||||
|
||||
function scheme(name, scheme) {
|
||||
name = name && name.toLowerCase();
|
||||
if (arguments.length > 1) {
|
||||
schemes[name] = scheme;
|
||||
return this;
|
||||
} else {
|
||||
return schemes[name];
|
||||
}
|
||||
}
|
||||
|
||||
var SymbolLegend = 'symbol';
|
||||
var DiscreteLegend = 'discrete';
|
||||
var GradientLegend = 'gradient';
|
||||
|
||||
const defaultFormatter = value => vegaUtil.isArray(value)
|
||||
? value.map(v => String(v))
|
||||
: String(value);
|
||||
|
||||
const ascending = (a, b) => a[1] - b[1];
|
||||
const descending = (a, b) => b[1] - a[1];
|
||||
|
||||
/**
|
||||
* Determine the tick count or interval function.
|
||||
* @param {Scale} scale - The scale for which to generate tick values.
|
||||
* @param {*} count - The desired tick count or interval specifier.
|
||||
* @param {number} minStep - The desired minimum step between tick values.
|
||||
* @return {*} - The tick count or interval function.
|
||||
*/
|
||||
function tickCount(scale, count, minStep) {
|
||||
var step;
|
||||
|
||||
if (vegaUtil.isNumber(count)) {
|
||||
if (scale.bins) {
|
||||
count = Math.max(count, scale.bins.length);
|
||||
}
|
||||
if (minStep != null) {
|
||||
count = Math.min(
|
||||
count,
|
||||
Math.floor((vegaUtil.span(scale.domain()) / minStep) || 1)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (vegaUtil.isObject(count)) {
|
||||
step = count.step;
|
||||
count = count.interval;
|
||||
}
|
||||
|
||||
if (vegaUtil.isString(count)) {
|
||||
count = scale.type === Time ? vegaTime.timeInterval(count)
|
||||
: scale.type == UTC ? vegaTime.utcInterval(count)
|
||||
: vegaUtil.error('Only time and utc scales accept interval strings.');
|
||||
if (step) count = count.every(step);
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
/**
|
||||
* Filter a set of candidate tick values, ensuring that only tick values
|
||||
* that lie within the scale range are included.
|
||||
* @param {Scale} scale - The scale for which to generate tick values.
|
||||
* @param {Array<*>} ticks - The candidate tick values.
|
||||
* @param {*} count - The tick count or interval function.
|
||||
* @return {Array<*>} - The filtered tick values.
|
||||
*/
|
||||
function validTicks(scale, ticks, count) {
|
||||
let range = scale.range(),
|
||||
lo = range[0],
|
||||
hi = vegaUtil.peek(range),
|
||||
cmp = ascending;
|
||||
|
||||
if (lo > hi) {
|
||||
range = hi;
|
||||
hi = lo;
|
||||
lo = range;
|
||||
cmp = descending;
|
||||
}
|
||||
|
||||
lo = Math.floor(lo);
|
||||
hi = Math.ceil(hi);
|
||||
|
||||
// filter ticks to valid values within the range
|
||||
// additionally sort ticks in range order (#2579)
|
||||
ticks = ticks.map(v => [v, scale(v)])
|
||||
.filter(_ => lo <= _[1] && _[1] <= hi)
|
||||
.sort(cmp)
|
||||
.map(_ => _[0]);
|
||||
|
||||
if (count > 0 && ticks.length > 1) {
|
||||
const endpoints = [ticks[0], vegaUtil.peek(ticks)];
|
||||
while (ticks.length > count && ticks.length >= 3) {
|
||||
ticks = ticks.filter((_, i) => !(i % 2));
|
||||
}
|
||||
if (ticks.length < 3) {
|
||||
ticks = endpoints;
|
||||
}
|
||||
}
|
||||
|
||||
return ticks;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate tick values for the given scale and approximate tick count or
|
||||
* interval value. If the scale has a 'ticks' method, it will be used to
|
||||
* generate the ticks, with the count argument passed as a parameter. If the
|
||||
* scale lacks a 'ticks' method, the full scale domain will be returned.
|
||||
* @param {Scale} scale - The scale for which to generate tick values.
|
||||
* @param {*} [count] - The approximate number of desired ticks.
|
||||
* @return {Array<*>} - The generated tick values.
|
||||
*/
|
||||
function tickValues(scale, count) {
|
||||
return scale.bins ? validTicks(scale, scale.bins)
|
||||
: scale.ticks ? scale.ticks(count)
|
||||
: scale.domain();
|
||||
}
|
||||
|
||||
/**
|
||||
* Generate a label format function for a scale. If the scale has a
|
||||
* 'tickFormat' method, it will be used to generate the formatter, with the
|
||||
* count and specifier arguments passed as parameters. If the scale lacks a
|
||||
* 'tickFormat' method, the returned formatter performs simple string coercion.
|
||||
* If the input scale is a logarithmic scale and the format specifier does not
|
||||
* indicate a desired decimal precision, a special variable precision formatter
|
||||
* that automatically trims trailing zeroes will be generated.
|
||||
* @param {Scale} scale - The scale for which to generate the label formatter.
|
||||
* @param {*} [count] - The approximate number of desired ticks.
|
||||
* @param {string} [specifier] - The format specifier. Must be a legal d3
|
||||
* specifier string (see https://github.com/d3/d3-format#formatSpecifier) or
|
||||
* time multi-format specifier object.
|
||||
* @return {function(*):string} - The generated label formatter.
|
||||
*/
|
||||
function tickFormat(locale, scale, count, specifier, formatType, noSkip) {
|
||||
var type = scale.type;
|
||||
let format = defaultFormatter;
|
||||
|
||||
if (type === Time || formatType === Time) {
|
||||
format = locale.timeFormat(specifier);
|
||||
}
|
||||
else if (type === UTC || formatType === UTC) {
|
||||
format = locale.utcFormat(specifier);
|
||||
}
|
||||
else if (isLogarithmic(type)) {
|
||||
const varfmt = locale.formatFloat(specifier);
|
||||
if (noSkip || scale.bins) {
|
||||
format = varfmt;
|
||||
} else {
|
||||
const test = tickLog(scale, count, false);
|
||||
format = _ => test(_) ? varfmt(_) : '';
|
||||
}
|
||||
}
|
||||
else if (scale.tickFormat) {
|
||||
// if d3 scale has tickFormat, it must be continuous
|
||||
const d = scale.domain();
|
||||
format = locale.formatSpan(d[0], d[d.length - 1], count, specifier);
|
||||
}
|
||||
else if (specifier) {
|
||||
format = locale.format(specifier);
|
||||
}
|
||||
|
||||
return format;
|
||||
}
|
||||
|
||||
function tickLog(scale, count, values) {
|
||||
const ticks = tickValues(scale, count),
|
||||
base = scale.base(),
|
||||
logb = Math.log(base),
|
||||
k = Math.max(1, base * count / ticks.length);
|
||||
|
||||
// apply d3-scale's log format filter criteria
|
||||
const test = d => {
|
||||
let i = d / Math.pow(base, Math.round(Math.log(d) / logb));
|
||||
if (i * base < base - 0.5) i *= base;
|
||||
return i <= k;
|
||||
};
|
||||
|
||||
return values ? ticks.filter(test) : test;
|
||||
}
|
||||
|
||||
const symbols = {
|
||||
[Quantile]: 'quantiles',
|
||||
[Quantize]: 'thresholds',
|
||||
[Threshold]: 'domain'
|
||||
};
|
||||
|
||||
const formats = {
|
||||
[Quantile]: 'quantiles',
|
||||
[Quantize]: 'domain'
|
||||
};
|
||||
|
||||
function labelValues(scale, count) {
|
||||
return scale.bins ? binValues(scale.bins)
|
||||
: scale.type === Log ? tickLog(scale, count, true)
|
||||
: symbols[scale.type] ? thresholdValues(scale[symbols[scale.type]]())
|
||||
: tickValues(scale, count);
|
||||
}
|
||||
|
||||
function thresholdFormat(locale, scale, specifier) {
|
||||
var _ = scale[formats[scale.type]](),
|
||||
n = _.length,
|
||||
d = n > 1 ? _[1] - _[0] : _[0], i;
|
||||
|
||||
for (i=1; i<n; ++i) {
|
||||
d = Math.min(d, _[i] - _[i-1]);
|
||||
}
|
||||
|
||||
// tickCount = 3 ticks times 10 for increased resolution
|
||||
return locale.formatSpan(0, d, 3 * 10, specifier);
|
||||
}
|
||||
|
||||
function thresholdValues(thresholds) {
|
||||
const values = [-Infinity].concat(thresholds);
|
||||
values.max = +Infinity;
|
||||
return values;
|
||||
}
|
||||
|
||||
function binValues(bins) {
|
||||
const values = bins.slice(0, -1);
|
||||
values.max = vegaUtil.peek(bins);
|
||||
return values;
|
||||
}
|
||||
|
||||
function isDiscreteRange(scale) {
|
||||
return symbols[scale.type] || scale.bins;
|
||||
}
|
||||
|
||||
function labelFormat(locale, scale, count, type, specifier, formatType, noSkip) {
|
||||
const format = formats[scale.type] && formatType !== Time && formatType !== UTC
|
||||
? thresholdFormat(locale, scale, specifier)
|
||||
: tickFormat(locale, scale, count, specifier, formatType, noSkip);
|
||||
|
||||
return type === SymbolLegend && isDiscreteRange(scale) ? formatRange(format)
|
||||
: type === DiscreteLegend ? formatDiscrete(format)
|
||||
: formatPoint(format);
|
||||
}
|
||||
|
||||
function formatRange(format) {
|
||||
return (value, index, array) => {
|
||||
var limit = get(array[index + 1], get(array.max, +Infinity)),
|
||||
lo = formatValue(value, format),
|
||||
hi = formatValue(limit, format);
|
||||
return lo && hi ? lo + ' \u2013 ' + hi : hi ? '< ' + hi : '\u2265 ' + lo;
|
||||
};
|
||||
}
|
||||
|
||||
function get(value, dflt) {
|
||||
return value != null ? value : dflt;
|
||||
}
|
||||
|
||||
function formatDiscrete(format) {
|
||||
return (value, index) => index ? format(value) : null;
|
||||
}
|
||||
|
||||
function formatPoint(format) {
|
||||
return value => format(value);
|
||||
}
|
||||
|
||||
function formatValue(value, format) {
|
||||
return Number.isFinite(value) ? format(value) : null;
|
||||
}
|
||||
|
||||
function labelFraction(scale) {
|
||||
var domain = scale.domain(),
|
||||
count = domain.length - 1,
|
||||
lo = +domain[0],
|
||||
hi = +vegaUtil.peek(domain),
|
||||
span = hi - lo;
|
||||
|
||||
if (scale.type === Threshold) {
|
||||
const adjust = count ? span / count : 0.1;
|
||||
lo -= adjust;
|
||||
hi += adjust;
|
||||
span = hi - lo;
|
||||
}
|
||||
|
||||
return value => (value - lo) / span;
|
||||
}
|
||||
|
||||
function format(locale, scale, specifier, formatType) {
|
||||
const type = formatType || scale.type;
|
||||
|
||||
// replace abbreviated time specifiers to improve screen reader experience
|
||||
if (vegaUtil.isString(specifier) && isTemporal(type)) {
|
||||
specifier = specifier.replace(/%a/g, '%A').replace(/%b/g, '%B');
|
||||
}
|
||||
|
||||
return !specifier && type === Time ? locale.timeFormat('%A, %d %B %Y, %X')
|
||||
: !specifier && type === UTC ? locale.utcFormat('%A, %d %B %Y, %X UTC')
|
||||
: labelFormat(locale, scale, 5, null, specifier, formatType, true);
|
||||
}
|
||||
|
||||
function domainCaption(locale, scale, opt) {
|
||||
opt = opt || {};
|
||||
const max = Math.max(3, opt.maxlen || 7),
|
||||
fmt = format(locale, scale, opt.format, opt.formatType);
|
||||
|
||||
// if scale breaks domain into bins, describe boundaries
|
||||
if (isDiscretizing(scale.type)) {
|
||||
const v = labelValues(scale).slice(1).map(fmt),
|
||||
n = v.length;
|
||||
return `${n} boundar${n === 1 ? 'y' : 'ies'}: ${v.join(', ')}`;
|
||||
}
|
||||
|
||||
// if scale domain is discrete, list values
|
||||
else if (isDiscrete(scale.type)) {
|
||||
const d = scale.domain(),
|
||||
n = d.length,
|
||||
v = n > max
|
||||
? d.slice(0, max - 2).map(fmt).join(', ')
|
||||
+ ', ending with ' + d.slice(-1).map(fmt)
|
||||
: d.map(fmt).join(', ');
|
||||
return `${n} value${n === 1 ? '' : 's'}: ${v}`;
|
||||
}
|
||||
|
||||
// if scale domain is continuous, describe value range
|
||||
else {
|
||||
const d = scale.domain();
|
||||
return `values from ${fmt(d[0])} to ${fmt(vegaUtil.peek(d))}`;
|
||||
}
|
||||
}
|
||||
|
||||
Object.defineProperty(exports, 'scaleImplicit', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return $.scaleImplicit;
|
||||
}
|
||||
});
|
||||
exports.Band = Band;
|
||||
exports.BinOrdinal = BinOrdinal;
|
||||
exports.DiscreteLegend = DiscreteLegend;
|
||||
exports.Diverging = Diverging;
|
||||
exports.GradientLegend = GradientLegend;
|
||||
exports.Identity = Identity;
|
||||
exports.Linear = Linear;
|
||||
exports.Log = Log;
|
||||
exports.Ordinal = Ordinal;
|
||||
exports.Point = Point;
|
||||
exports.Pow = Pow;
|
||||
exports.Quantile = Quantile;
|
||||
exports.Quantize = Quantize;
|
||||
exports.Sequential = Sequential;
|
||||
exports.Sqrt = Sqrt;
|
||||
exports.SymbolLegend = SymbolLegend;
|
||||
exports.Symlog = Symlog;
|
||||
exports.Threshold = Threshold;
|
||||
exports.Time = Time;
|
||||
exports.UTC = UTC;
|
||||
exports.bandSpace = bandSpace;
|
||||
exports.domainCaption = domainCaption;
|
||||
exports.interpolate = interpolate;
|
||||
exports.interpolateColors = interpolateColors;
|
||||
exports.interpolateRange = interpolateRange;
|
||||
exports.isContinuous = isContinuous;
|
||||
exports.isDiscrete = isDiscrete;
|
||||
exports.isDiscretizing = isDiscretizing;
|
||||
exports.isInterpolating = isInterpolating;
|
||||
exports.isLogarithmic = isLogarithmic;
|
||||
exports.isQuantile = isQuantile;
|
||||
exports.isTemporal = isTemporal;
|
||||
exports.isValidScaleType = isValidScaleType;
|
||||
exports.labelFormat = labelFormat;
|
||||
exports.labelFraction = labelFraction;
|
||||
exports.labelValues = labelValues;
|
||||
exports.quantizeInterpolator = quantizeInterpolator;
|
||||
exports.scale = scale;
|
||||
exports.scaleCopy = scaleCopy;
|
||||
exports.scaleFraction = scaleFraction;
|
||||
exports.scheme = scheme;
|
||||
exports.tickCount = tickCount;
|
||||
exports.tickFormat = tickFormat;
|
||||
exports.tickValues = tickValues;
|
||||
exports.validTicks = validTicks;
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
})));
|
||||
1
node_modules/vega-scale/build/vega-scale.min.js
generated
vendored
Normal file
1
node_modules/vega-scale/build/vega-scale.min.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user