orange
/
yudao-ui-admin-vue3
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
yudao-ui-admin-vue3/node_modules/.vite/deps/chunk-TCVRGDT4.js

2816 lines
92 KiB
JavaScript
Raw Normal View History

first commit
2025-04-07 09:42:53 +00:00
import {
ONE_DAY,
ONE_HOUR,
ONE_MINUTE,
ONE_SECOND,
ONE_YEAR,
OrientedBoundingRect_default,
addCommas,
createRenderPlanner,
dateGetterName,
dateSetterName,
enableClassManagement,
format,
fullLeveledFormatter,
fullYearGetterName,
fullYearSetterName,
getDefaultFormatPrecisionOfInterval,
getPixelPrecision,
getPrecision,
getPrimaryTimeUnit,
getStackedDimension,
getUnitValue,
hoursGetterName,
hoursSetterName,
isDimensionStacked,
isPrimaryTimeUnit,
leveledFormat,
linearMap,
makeInner,
millisecondsGetterName,
millisecondsSetterName,
minutesGetterName,
minutesSetterName,
monthGetterName,
monthSetterName,
nice,
parseDate,
parsePercent as parsePercent2,
quantity,
quantityExponent,
round,
secondsGetterName,
secondsSetterName,
timeUnits,
warn
} from "./chunk-HOOPLKFT.js";
import {
BoundingRect_default,
__extends,
applyTransform,
assert,
createHashMap,
defaults,
each,
eqNaN,
filter,
getBoundingRect,
identity,
invert,
isArray,
isFunction,
isNumber,
isObject,
isString,
keys,
map,
max,
min,
mul,
parsePercent,
windingLine
} from "./chunk-M6ZIMNOI.js";
// node_modules/.pnpm/zrender@5.6.0/node_modules/zrender/lib/contain/polygon.js
var EPSILON = 1e-8;
function isAroundEqual(a, b) {
return Math.abs(a - b) < EPSILON;
}
function contain(points, x, y) {
var w = 0;
var p = points[0];
if (!p) {
return false;
}
for (var i = 1; i < points.length; i++) {
var p2 = points[i];
w += windingLine(p[0], p[1], p2[0], p2[1], x, y);
p = p2;
}
var p0 = points[0];
if (!isAroundEqual(p[0], p0[0]) || !isAroundEqual(p[1], p0[1])) {
w += windingLine(p[0], p[1], p0[0], p0[1], x, y);
}
return w !== 0;
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/geo/Region.js
var TMP_TRANSFORM = [];
function transformPoints(points, transform) {
for (var p = 0; p < points.length; p++) {
applyTransform(points[p], points[p], transform);
}
}
function updateBBoxFromPoints(points, min2, max2, projection) {
for (var i = 0; i < points.length; i++) {
var p = points[i];
if (projection) {
p = projection.project(p);
}
if (p && isFinite(p[0]) && isFinite(p[1])) {
min(min2, min2, p);
max(max2, max2, p);
}
}
}
function centroid(points) {
var signedArea = 0;
var cx = 0;
var cy = 0;
var len = points.length;
var x0 = points[len - 1][0];
var y0 = points[len - 1][1];
for (var i = 0; i < len; i++) {
var x1 = points[i][0];
var y1 = points[i][1];
var a = x0 * y1 - x1 * y0;
signedArea += a;
cx += (x0 + x1) * a;
cy += (y0 + y1) * a;
x0 = x1;
y0 = y1;
}
return signedArea ? [cx / signedArea / 3, cy / signedArea / 3, signedArea] : [points[0][0] || 0, points[0][1] || 0];
}
var Region = (
/** @class */
function() {
function Region2(name) {
this.name = name;
}
Region2.prototype.setCenter = function(center) {
this._center = center;
};
Region2.prototype.getCenter = function() {
var center = this._center;
if (!center) {
center = this._center = this.calcCenter();
}
return center;
};
return Region2;
}()
);
var GeoJSONPolygonGeometry = (
/** @class */
/* @__PURE__ */ function() {
function GeoJSONPolygonGeometry2(exterior, interiors) {
this.type = "polygon";
this.exterior = exterior;
this.interiors = interiors;
}
return GeoJSONPolygonGeometry2;
}()
);
var GeoJSONLineStringGeometry = (
/** @class */
/* @__PURE__ */ function() {
function GeoJSONLineStringGeometry2(points) {
this.type = "linestring";
this.points = points;
}
return GeoJSONLineStringGeometry2;
}()
);
var GeoJSONRegion = (
/** @class */
function(_super) {
__extends(GeoJSONRegion2, _super);
function GeoJSONRegion2(name, geometries, cp) {
var _this = _super.call(this, name) || this;
_this.type = "geoJSON";
_this.geometries = geometries;
_this._center = cp && [cp[0], cp[1]];
return _this;
}
GeoJSONRegion2.prototype.calcCenter = function() {
var geometries = this.geometries;
var largestGeo;
var largestGeoSize = 0;
for (var i = 0; i < geometries.length; i++) {
var geo = geometries[i];
var exterior = geo.exterior;
var size = exterior && exterior.length;
if (size > largestGeoSize) {
largestGeo = geo;
largestGeoSize = size;
}
}
if (largestGeo) {
return centroid(largestGeo.exterior);
}
var rect = this.getBoundingRect();
return [rect.x + rect.width / 2, rect.y + rect.height / 2];
};
GeoJSONRegion2.prototype.getBoundingRect = function(projection) {
var rect = this._rect;
if (rect && !projection) {
return rect;
}
var min2 = [Infinity, Infinity];
var max2 = [-Infinity, -Infinity];
var geometries = this.geometries;
each(geometries, function(geo) {
if (geo.type === "polygon") {
updateBBoxFromPoints(geo.exterior, min2, max2, projection);
} else {
each(geo.points, function(points) {
updateBBoxFromPoints(points, min2, max2, projection);
});
}
});
if (!(isFinite(min2[0]) && isFinite(min2[1]) && isFinite(max2[0]) && isFinite(max2[1]))) {
min2[0] = min2[1] = max2[0] = max2[1] = 0;
}
rect = new BoundingRect_default(min2[0], min2[1], max2[0] - min2[0], max2[1] - min2[1]);
if (!projection) {
this._rect = rect;
}
return rect;
};
GeoJSONRegion2.prototype.contain = function(coord) {
var rect = this.getBoundingRect();
var geometries = this.geometries;
if (!rect.contain(coord[0], coord[1])) {
return false;
}
loopGeo:
for (var i = 0, len = geometries.length; i < len; i++) {
var geo = geometries[i];
if (geo.type !== "polygon") {
continue;
}
var exterior = geo.exterior;
var interiors = geo.interiors;
if (contain(exterior, coord[0], coord[1])) {
for (var k = 0; k < (interiors ? interiors.length : 0); k++) {
if (contain(interiors[k], coord[0], coord[1])) {
continue loopGeo;
}
}
return true;
}
}
return false;
};
GeoJSONRegion2.prototype.transformTo = function(x, y, width, height) {
var rect = this.getBoundingRect();
var aspect = rect.width / rect.height;
if (!width) {
width = aspect * height;
} else if (!height) {
height = width / aspect;
}
var target = new BoundingRect_default(x, y, width, height);
var transform = rect.calculateTransform(target);
var geometries = this.geometries;
for (var i = 0; i < geometries.length; i++) {
var geo = geometries[i];
if (geo.type === "polygon") {
transformPoints(geo.exterior, transform);
each(geo.interiors, function(interior) {
transformPoints(interior, transform);
});
} else {
each(geo.points, function(points) {
transformPoints(points, transform);
});
}
}
rect = this._rect;
rect.copy(target);
this._center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
};
GeoJSONRegion2.prototype.cloneShallow = function(name) {
name == null && (name = this.name);
var newRegion = new GeoJSONRegion2(name, this.geometries, this._center);
newRegion._rect = this._rect;
newRegion.transformTo = null;
return newRegion;
};
return GeoJSONRegion2;
}(Region)
);
var GeoSVGRegion = (
/** @class */
function(_super) {
__extends(GeoSVGRegion2, _super);
function GeoSVGRegion2(name, elOnlyForCalculate) {
var _this = _super.call(this, name) || this;
_this.type = "geoSVG";
_this._elOnlyForCalculate = elOnlyForCalculate;
return _this;
}
GeoSVGRegion2.prototype.calcCenter = function() {
var el = this._elOnlyForCalculate;
var rect = el.getBoundingRect();
var center = [rect.x + rect.width / 2, rect.y + rect.height / 2];
var mat = identity(TMP_TRANSFORM);
var target = el;
while (target && !target.isGeoSVGGraphicRoot) {
mul(mat, target.getLocalTransform(), mat);
target = target.parent;
}
invert(mat, mat);
applyTransform(center, center, mat);
return center;
};
return GeoSVGRegion2;
}(Region)
);
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/geo/parseGeoJson.js
function decode(json) {
if (!json.UTF8Encoding) {
return json;
}
var jsonCompressed = json;
var encodeScale = jsonCompressed.UTF8Scale;
if (encodeScale == null) {
encodeScale = 1024;
}
var features = jsonCompressed.features;
each(features, function(feature) {
var geometry = feature.geometry;
var encodeOffsets = geometry.encodeOffsets;
var coordinates = geometry.coordinates;
if (!encodeOffsets) {
return;
}
switch (geometry.type) {
case "LineString":
geometry.coordinates = decodeRing(coordinates, encodeOffsets, encodeScale);
break;
case "Polygon":
decodeRings(coordinates, encodeOffsets, encodeScale);
break;
case "MultiLineString":
decodeRings(coordinates, encodeOffsets, encodeScale);
break;
case "MultiPolygon":
each(coordinates, function(rings, idx) {
return decodeRings(rings, encodeOffsets[idx], encodeScale);
});
}
});
jsonCompressed.UTF8Encoding = false;
return jsonCompressed;
}
function decodeRings(rings, encodeOffsets, encodeScale) {
for (var c = 0; c < rings.length; c++) {
rings[c] = decodeRing(rings[c], encodeOffsets[c], encodeScale);
}
}
function decodeRing(coordinate, encodeOffsets, encodeScale) {
var result = [];
var prevX = encodeOffsets[0];
var prevY = encodeOffsets[1];
for (var i = 0; i < coordinate.length; i += 2) {
var x = coordinate.charCodeAt(i) - 64;
var y = coordinate.charCodeAt(i + 1) - 64;
x = x >> 1 ^ -(x & 1);
y = y >> 1 ^ -(y & 1);
x += prevX;
y += prevY;
prevX = x;
prevY = y;
result.push([x / encodeScale, y / encodeScale]);
}
return result;
}
function parseGeoJSON(geoJson, nameProperty) {
geoJson = decode(geoJson);
return map(filter(geoJson.features, function(featureObj) {
return featureObj.geometry && featureObj.properties && featureObj.geometry.coordinates.length > 0;
}), function(featureObj) {
var properties = featureObj.properties;
var geo = featureObj.geometry;
var geometries = [];
switch (geo.type) {
case "Polygon":
var coordinates = geo.coordinates;
geometries.push(new GeoJSONPolygonGeometry(coordinates[0], coordinates.slice(1)));
break;
case "MultiPolygon":
each(geo.coordinates, function(item) {
if (item[0]) {
geometries.push(new GeoJSONPolygonGeometry(item[0], item.slice(1)));
}
});
break;
case "LineString":
geometries.push(new GeoJSONLineStringGeometry([geo.coordinates]));
break;
case "MultiLineString":
geometries.push(new GeoJSONLineStringGeometry(geo.coordinates));
}
var region = new GeoJSONRegion(properties[nameProperty || "name"], geometries, properties.cp);
region.properties = properties;
return region;
});
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/Scale.js
var Scale = (
/** @class */
function() {
function Scale2(setting) {
this._setting = setting || {};
this._extent = [Infinity, -Infinity];
}
Scale2.prototype.getSetting = function(name) {
return this._setting[name];
};
Scale2.prototype.unionExtent = function(other) {
var extent = this._extent;
other[0] < extent[0] && (extent[0] = other[0]);
other[1] > extent[1] && (extent[1] = other[1]);
};
Scale2.prototype.unionExtentFromData = function(data, dim) {
this.unionExtent(data.getApproximateExtent(dim));
};
Scale2.prototype.getExtent = function() {
return this._extent.slice();
};
Scale2.prototype.setExtent = function(start, end) {
var thisExtent = this._extent;
if (!isNaN(start)) {
thisExtent[0] = start;
}
if (!isNaN(end)) {
thisExtent[1] = end;
}
};
Scale2.prototype.isInExtentRange = function(value) {
return this._extent[0] <= value && this._extent[1] >= value;
};
Scale2.prototype.isBlank = function() {
return this._isBlank;
};
Scale2.prototype.setBlank = function(isBlank) {
this._isBlank = isBlank;
};
return Scale2;
}()
);
enableClassManagement(Scale);
var Scale_default = Scale;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/data/OrdinalMeta.js
var uidBase = 0;
var OrdinalMeta = (
/** @class */
function() {
function OrdinalMeta2(opt) {
this.categories = opt.categories || [];
this._needCollect = opt.needCollect;
this._deduplication = opt.deduplication;
this.uid = ++uidBase;
}
OrdinalMeta2.createByAxisModel = function(axisModel) {
var option = axisModel.option;
var data = option.data;
var categories = data && map(data, getName);
return new OrdinalMeta2({
categories,
needCollect: !categories,
// deduplication is default in axis.
deduplication: option.dedplication !== false
});
};
;
OrdinalMeta2.prototype.getOrdinal = function(category) {
return this._getOrCreateMap().get(category);
};
OrdinalMeta2.prototype.parseAndCollect = function(category) {
var index;
var needCollect = this._needCollect;
if (!isString(category) && !needCollect) {
return category;
}
if (needCollect && !this._deduplication) {
index = this.categories.length;
this.categories[index] = category;
return index;
}
var map2 = this._getOrCreateMap();
index = map2.get(category);
if (index == null) {
if (needCollect) {
index = this.categories.length;
this.categories[index] = category;
map2.set(category, index);
} else {
index = NaN;
}
}
return index;
};
OrdinalMeta2.prototype._getOrCreateMap = function() {
return this._map || (this._map = createHashMap(this.categories));
};
return OrdinalMeta2;
}()
);
function getName(obj) {
if (isObject(obj) && obj.value != null) {
return obj.value;
} else {
return obj + "";
}
}
var OrdinalMeta_default = OrdinalMeta;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/helper.js
function isValueNice(val) {
var exp10 = Math.pow(10, quantityExponent(Math.abs(val)));
var f = Math.abs(val / exp10);
return f === 0 || f === 1 || f === 2 || f === 3 || f === 5;
}
function isIntervalOrLogScale(scale2) {
return scale2.type === "interval" || scale2.type === "log";
}
function intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval) {
var result = {};
var span = extent[1] - extent[0];
var interval = result.interval = nice(span / splitNumber, true);
if (minInterval != null && interval < minInterval) {
interval = result.interval = minInterval;
}
if (maxInterval != null && interval > maxInterval) {
interval = result.interval = maxInterval;
}
var precision = result.intervalPrecision = getIntervalPrecision(interval);
var niceTickExtent = result.niceTickExtent = [round(Math.ceil(extent[0] / interval) * interval, precision), round(Math.floor(extent[1] / interval) * interval, precision)];
fixExtent(niceTickExtent, extent);
return result;
}
function increaseInterval(interval) {
var exp10 = Math.pow(10, quantityExponent(interval));
var f = interval / exp10;
if (!f) {
f = 1;
} else if (f === 2) {
f = 3;
} else if (f === 3) {
f = 5;
} else {
f *= 2;
}
return round(f * exp10);
}
function getIntervalPrecision(interval) {
return getPrecision(interval) + 2;
}
function clamp(niceTickExtent, idx, extent) {
niceTickExtent[idx] = Math.max(Math.min(niceTickExtent[idx], extent[1]), extent[0]);
}
function fixExtent(niceTickExtent, extent) {
!isFinite(niceTickExtent[0]) && (niceTickExtent[0] = extent[0]);
!isFinite(niceTickExtent[1]) && (niceTickExtent[1] = extent[1]);
clamp(niceTickExtent, 0, extent);
clamp(niceTickExtent, 1, extent);
if (niceTickExtent[0] > niceTickExtent[1]) {
niceTickExtent[0] = niceTickExtent[1];
}
}
function contain2(val, extent) {
return val >= extent[0] && val <= extent[1];
}
function normalize(val, extent) {
if (extent[1] === extent[0]) {
return 0.5;
}
return (val - extent[0]) / (extent[1] - extent[0]);
}
function scale(val, extent) {
return val * (extent[1] - extent[0]) + extent[0];
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/Ordinal.js
var OrdinalScale = (
/** @class */
function(_super) {
__extends(OrdinalScale2, _super);
function OrdinalScale2(setting) {
var _this = _super.call(this, setting) || this;
_this.type = "ordinal";
var ordinalMeta = _this.getSetting("ordinalMeta");
if (!ordinalMeta) {
ordinalMeta = new OrdinalMeta_default({});
}
if (isArray(ordinalMeta)) {
ordinalMeta = new OrdinalMeta_default({
categories: map(ordinalMeta, function(item) {
return isObject(item) ? item.value : item;
})
});
}
_this._ordinalMeta = ordinalMeta;
_this._extent = _this.getSetting("extent") || [0, ordinalMeta.categories.length - 1];
return _this;
}
OrdinalScale2.prototype.parse = function(val) {
if (val == null) {
return NaN;
}
return isString(val) ? this._ordinalMeta.getOrdinal(val) : Math.round(val);
};
OrdinalScale2.prototype.contain = function(rank) {
rank = this.parse(rank);
return contain2(rank, this._extent) && this._ordinalMeta.categories[rank] != null;
};
OrdinalScale2.prototype.normalize = function(val) {
val = this._getTickNumber(this.parse(val));
return normalize(val, this._extent);
};
OrdinalScale2.prototype.scale = function(val) {
val = Math.round(scale(val, this._extent));
return this.getRawOrdinalNumber(val);
};
OrdinalScale2.prototype.getTicks = function() {
var ticks = [];
var extent = this._extent;
var rank = extent[0];
while (rank <= extent[1]) {
ticks.push({
value: rank
});
rank++;
}
return ticks;
};
OrdinalScale2.prototype.getMinorTicks = function(splitNumber) {
return;
};
OrdinalScale2.prototype.setSortInfo = function(info) {
if (info == null) {
this._ordinalNumbersByTick = this._ticksByOrdinalNumber = null;
return;
}
var infoOrdinalNumbers = info.ordinalNumbers;
var ordinalsByTick = this._ordinalNumbersByTick = [];
var ticksByOrdinal = this._ticksByOrdinalNumber = [];
var tickNum = 0;
var allCategoryLen = this._ordinalMeta.categories.length;
for (var len = Math.min(allCategoryLen, infoOrdinalNumbers.length); tickNum < len; ++tickNum) {
var ordinalNumber = infoOrdinalNumbers[tickNum];
ordinalsByTick[tickNum] = ordinalNumber;
ticksByOrdinal[ordinalNumber] = tickNum;
}
var unusedOrdinal = 0;
for (; tickNum < allCategoryLen; ++tickNum) {
while (ticksByOrdinal[unusedOrdinal] != null) {
unusedOrdinal++;
}
;
ordinalsByTick.push(unusedOrdinal);
ticksByOrdinal[unusedOrdinal] = tickNum;
}
};
OrdinalScale2.prototype._getTickNumber = function(ordinal) {
var ticksByOrdinalNumber = this._ticksByOrdinalNumber;
return ticksByOrdinalNumber && ordinal >= 0 && ordinal < ticksByOrdinalNumber.length ? ticksByOrdinalNumber[ordinal] : ordinal;
};
OrdinalScale2.prototype.getRawOrdinalNumber = function(tickNumber) {
var ordinalNumbersByTick = this._ordinalNumbersByTick;
return ordinalNumbersByTick && tickNumber >= 0 && tickNumber < ordinalNumbersByTick.length ? ordinalNumbersByTick[tickNumber] : tickNumber;
};
OrdinalScale2.prototype.getLabel = function(tick) {
if (!this.isBlank()) {
var ordinalNumber = this.getRawOrdinalNumber(tick.value);
var cateogry = this._ordinalMeta.categories[ordinalNumber];
return cateogry == null ? "" : cateogry + "";
}
};
OrdinalScale2.prototype.count = function() {
return this._extent[1] - this._extent[0] + 1;
};
OrdinalScale2.prototype.unionExtentFromData = function(data, dim) {
this.unionExtent(data.getApproximateExtent(dim));
};
OrdinalScale2.prototype.isInExtentRange = function(value) {
value = this._getTickNumber(value);
return this._extent[0] <= value && this._extent[1] >= value;
};
OrdinalScale2.prototype.getOrdinalMeta = function() {
return this._ordinalMeta;
};
OrdinalScale2.prototype.calcNiceTicks = function() {
};
OrdinalScale2.prototype.calcNiceExtent = function() {
};
OrdinalScale2.type = "ordinal";
return OrdinalScale2;
}(Scale_default)
);
Scale_default.registerClass(OrdinalScale);
var Ordinal_default = OrdinalScale;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/Interval.js
var roundNumber = round;
var IntervalScale = (
/** @class */
function(_super) {
__extends(IntervalScale2, _super);
function IntervalScale2() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.type = "interval";
_this._interval = 0;
_this._intervalPrecision = 2;
return _this;
}
IntervalScale2.prototype.parse = function(val) {
return val;
};
IntervalScale2.prototype.contain = function(val) {
return contain2(val, this._extent);
};
IntervalScale2.prototype.normalize = function(val) {
return normalize(val, this._extent);
};
IntervalScale2.prototype.scale = function(val) {
return scale(val, this._extent);
};
IntervalScale2.prototype.setExtent = function(start, end) {
var thisExtent = this._extent;
if (!isNaN(start)) {
thisExtent[0] = parseFloat(start);
}
if (!isNaN(end)) {
thisExtent[1] = parseFloat(end);
}
};
IntervalScale2.prototype.unionExtent = function(other) {
var extent = this._extent;
other[0] < extent[0] && (extent[0] = other[0]);
other[1] > extent[1] && (extent[1] = other[1]);
this.setExtent(extent[0], extent[1]);
};
IntervalScale2.prototype.getInterval = function() {
return this._interval;
};
IntervalScale2.prototype.setInterval = function(interval) {
this._interval = interval;
this._niceExtent = this._extent.slice();
this._intervalPrecision = getIntervalPrecision(interval);
};
IntervalScale2.prototype.getTicks = function(expandToNicedExtent) {
var interval = this._interval;
var extent = this._extent;
var niceTickExtent = this._niceExtent;
var intervalPrecision = this._intervalPrecision;
var ticks = [];
if (!interval) {
return ticks;
}
var safeLimit = 1e4;
if (extent[0] < niceTickExtent[0]) {
if (expandToNicedExtent) {
ticks.push({
value: roundNumber(niceTickExtent[0] - interval, intervalPrecision)
});
} else {
ticks.push({
value: extent[0]
});
}
}
var tick = niceTickExtent[0];
while (tick <= niceTickExtent[1]) {
ticks.push({
value: tick
});
tick = roundNumber(tick + interval, intervalPrecision);
if (tick === ticks[ticks.length - 1].value) {
break;
}
if (ticks.length > safeLimit) {
return [];
}
}
var lastNiceTick = ticks.length ? ticks[ticks.length - 1].value : niceTickExtent[1];
if (extent[1] > lastNiceTick) {
if (expandToNicedExtent) {
ticks.push({
value: roundNumber(lastNiceTick + interval, intervalPrecision)
});
} else {
ticks.push({
value: extent[1]
});
}
}
return ticks;
};
IntervalScale2.prototype.getMinorTicks = function(splitNumber) {
var ticks = this.getTicks(true);
var minorTicks = [];
var extent = this.getExtent();
for (var i = 1; i < ticks.length; i++) {
var nextTick = ticks[i];
var prevTick = ticks[i - 1];
var count = 0;
var minorTicksGroup = [];
var interval = nextTick.value - prevTick.value;
var minorInterval = interval / splitNumber;
while (count < splitNumber - 1) {
var minorTick = roundNumber(prevTick.value + (count + 1) * minorInterval);
if (minorTick > extent[0] && minorTick < extent[1]) {
minorTicksGroup.push(minorTick);
}
count++;
}
minorTicks.push(minorTicksGroup);
}
return minorTicks;
};
IntervalScale2.prototype.getLabel = function(data, opt) {
if (data == null) {
return "";
}
var precision = opt && opt.precision;
if (precision == null) {
precision = getPrecision(data.value) || 0;
} else if (precision === "auto") {
precision = this._intervalPrecision;
}
var dataNum = roundNumber(data.value, precision, true);
return addCommas(dataNum);
};
IntervalScale2.prototype.calcNiceTicks = function(splitNumber, minInterval, maxInterval) {
splitNumber = splitNumber || 5;
var extent = this._extent;
var span = extent[1] - extent[0];
if (!isFinite(span)) {
return;
}
if (span < 0) {
span = -span;
extent.reverse();
}
var result = intervalScaleNiceTicks(extent, splitNumber, minInterval, maxInterval);
this._intervalPrecision = result.intervalPrecision;
this._interval = result.interval;
this._niceExtent = result.niceTickExtent;
};
IntervalScale2.prototype.calcNiceExtent = function(opt) {
var extent = this._extent;
if (extent[0] === extent[1]) {
if (extent[0] !== 0) {
var expandSize = Math.abs(extent[0]);
if (!opt.fixMax) {
extent[1] += expandSize / 2;
extent[0] -= expandSize / 2;
} else {
extent[0] -= expandSize / 2;
}
} else {
extent[1] = 1;
}
}
var span = extent[1] - extent[0];
if (!isFinite(span)) {
extent[0] = 0;
extent[1] = 1;
}
this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
var interval = this._interval;
if (!opt.fixMin) {
extent[0] = roundNumber(Math.floor(extent[0] / interval) * interval);
}
if (!opt.fixMax) {
extent[1] = roundNumber(Math.ceil(extent[1] / interval) * interval);
}
};
IntervalScale2.prototype.setNiceExtent = function(min2, max2) {
this._niceExtent = [min2, max2];
};
IntervalScale2.type = "interval";
return IntervalScale2;
}(Scale_default)
);
Scale_default.registerClass(IntervalScale);
var Interval_default = IntervalScale;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/util/vendor.js
var supportFloat32Array = typeof Float32Array !== "undefined";
var Float32ArrayCtor = !supportFloat32Array ? Array : Float32Array;
function createFloat32Array(arg) {
if (isArray(arg)) {
return supportFloat32Array ? new Float32Array(arg) : arg;
}
return new Float32ArrayCtor(arg);
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/layout/barGrid.js
var STACK_PREFIX = "__ec_stack_";
function getSeriesStackId(seriesModel) {
return seriesModel.get("stack") || STACK_PREFIX + seriesModel.seriesIndex;
}
function getAxisKey(axis) {
return axis.dim + axis.index;
}
function getLayoutOnAxis(opt) {
var params = [];
var baseAxis = opt.axis;
var axisKey = "axis0";
if (baseAxis.type !== "category") {
return;
}
var bandWidth = baseAxis.getBandWidth();
for (var i = 0; i < opt.count || 0; i++) {
params.push(defaults({
bandWidth,
axisKey,
stackId: STACK_PREFIX + i
}, opt));
}
var widthAndOffsets = doCalBarWidthAndOffset(params);
var result = [];
for (var i = 0; i < opt.count; i++) {
var item = widthAndOffsets[axisKey][STACK_PREFIX + i];
item.offsetCenter = item.offset + item.width / 2;
result.push(item);
}
return result;
}
function prepareLayoutBarSeries(seriesType, ecModel) {
var seriesModels = [];
ecModel.eachSeriesByType(seriesType, function(seriesModel) {
if (isOnCartesian(seriesModel)) {
seriesModels.push(seriesModel);
}
});
return seriesModels;
}
function getValueAxesMinGaps(barSeries) {
var axisValues = {};
each(barSeries, function(seriesModel) {
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
if (baseAxis.type !== "time" && baseAxis.type !== "value") {
return;
}
var data = seriesModel.getData();
var key2 = baseAxis.dim + "_" + baseAxis.index;
var dimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
var store = data.getStore();
for (var i = 0, cnt = store.count(); i < cnt; ++i) {
var value = store.get(dimIdx, i);
if (!axisValues[key2]) {
axisValues[key2] = [value];
} else {
axisValues[key2].push(value);
}
}
});
var axisMinGaps = {};
for (var key in axisValues) {
if (axisValues.hasOwnProperty(key)) {
var valuesInAxis = axisValues[key];
if (valuesInAxis) {
valuesInAxis.sort(function(a, b) {
return a - b;
});
var min2 = null;
for (var j = 1; j < valuesInAxis.length; ++j) {
var delta = valuesInAxis[j] - valuesInAxis[j - 1];
if (delta > 0) {
min2 = min2 === null ? delta : Math.min(min2, delta);
}
}
axisMinGaps[key] = min2;
}
}
}
return axisMinGaps;
}
function makeColumnLayout(barSeries) {
var axisMinGaps = getValueAxesMinGaps(barSeries);
var seriesInfoList = [];
each(barSeries, function(seriesModel) {
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var axisExtent = baseAxis.getExtent();
var bandWidth;
if (baseAxis.type === "category") {
bandWidth = baseAxis.getBandWidth();
} else if (baseAxis.type === "value" || baseAxis.type === "time") {
var key = baseAxis.dim + "_" + baseAxis.index;
var minGap = axisMinGaps[key];
var extentSpan = Math.abs(axisExtent[1] - axisExtent[0]);
var scale2 = baseAxis.scale.getExtent();
var scaleSpan = Math.abs(scale2[1] - scale2[0]);
bandWidth = minGap ? extentSpan / scaleSpan * minGap : extentSpan;
} else {
var data = seriesModel.getData();
bandWidth = Math.abs(axisExtent[1] - axisExtent[0]) / data.count();
}
var barWidth = parsePercent2(seriesModel.get("barWidth"), bandWidth);
var barMaxWidth = parsePercent2(seriesModel.get("barMaxWidth"), bandWidth);
var barMinWidth = parsePercent2(
// barMinWidth by default is 0.5 / 1 in cartesian. Because in value axis,
// the auto-calculated bar width might be less than 0.5 / 1.
seriesModel.get("barMinWidth") || (isInLargeMode(seriesModel) ? 0.5 : 1),
bandWidth
);
var barGap = seriesModel.get("barGap");
var barCategoryGap = seriesModel.get("barCategoryGap");
seriesInfoList.push({
bandWidth,
barWidth,
barMaxWidth,
barMinWidth,
barGap,
barCategoryGap,
axisKey: getAxisKey(baseAxis),
stackId: getSeriesStackId(seriesModel)
});
});
return doCalBarWidthAndOffset(seriesInfoList);
}
function doCalBarWidthAndOffset(seriesInfoList) {
var columnsMap = {};
each(seriesInfoList, function(seriesInfo, idx) {
var axisKey = seriesInfo.axisKey;
var bandWidth = seriesInfo.bandWidth;
var columnsOnAxis = columnsMap[axisKey] || {
bandWidth,
remainedWidth: bandWidth,
autoWidthCount: 0,
categoryGap: null,
gap: "20%",
stacks: {}
};
var stacks = columnsOnAxis.stacks;
columnsMap[axisKey] = columnsOnAxis;
var stackId = seriesInfo.stackId;
if (!stacks[stackId]) {
columnsOnAxis.autoWidthCount++;
}
stacks[stackId] = stacks[stackId] || {
width: 0,
maxWidth: 0
};
var barWidth = seriesInfo.barWidth;
if (barWidth && !stacks[stackId].width) {
stacks[stackId].width = barWidth;
barWidth = Math.min(columnsOnAxis.remainedWidth, barWidth);
columnsOnAxis.remainedWidth -= barWidth;
}
var barMaxWidth = seriesInfo.barMaxWidth;
barMaxWidth && (stacks[stackId].maxWidth = barMaxWidth);
var barMinWidth = seriesInfo.barMinWidth;
barMinWidth && (stacks[stackId].minWidth = barMinWidth);
var barGap = seriesInfo.barGap;
barGap != null && (columnsOnAxis.gap = barGap);
var barCategoryGap = seriesInfo.barCategoryGap;
barCategoryGap != null && (columnsOnAxis.categoryGap = barCategoryGap);
});
var result = {};
each(columnsMap, function(columnsOnAxis, coordSysName) {
result[coordSysName] = {};
var stacks = columnsOnAxis.stacks;
var bandWidth = columnsOnAxis.bandWidth;
var categoryGapPercent = columnsOnAxis.categoryGap;
if (categoryGapPercent == null) {
var columnCount = keys(stacks).length;
categoryGapPercent = Math.max(35 - columnCount * 4, 15) + "%";
}
var categoryGap = parsePercent2(categoryGapPercent, bandWidth);
var barGapPercent = parsePercent2(columnsOnAxis.gap, 1);
var remainedWidth = columnsOnAxis.remainedWidth;
var autoWidthCount = columnsOnAxis.autoWidthCount;
var autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
autoWidth = Math.max(autoWidth, 0);
each(stacks, function(column) {
var maxWidth = column.maxWidth;
var minWidth = column.minWidth;
if (!column.width) {
var finalWidth = autoWidth;
if (maxWidth && maxWidth < finalWidth) {
finalWidth = Math.min(maxWidth, remainedWidth);
}
if (minWidth && minWidth > finalWidth) {
finalWidth = minWidth;
}
if (finalWidth !== autoWidth) {
column.width = finalWidth;
remainedWidth -= finalWidth + barGapPercent * finalWidth;
autoWidthCount--;
}
} else {
var finalWidth = column.width;
if (maxWidth) {
finalWidth = Math.min(finalWidth, maxWidth);
}
if (minWidth) {
finalWidth = Math.max(finalWidth, minWidth);
}
column.width = finalWidth;
remainedWidth -= finalWidth + barGapPercent * finalWidth;
autoWidthCount--;
}
});
autoWidth = (remainedWidth - categoryGap) / (autoWidthCount + (autoWidthCount - 1) * barGapPercent);
autoWidth = Math.max(autoWidth, 0);
var widthSum = 0;
var lastColumn;
each(stacks, function(column, idx) {
if (!column.width) {
column.width = autoWidth;
}
lastColumn = column;
widthSum += column.width * (1 + barGapPercent);
});
if (lastColumn) {
widthSum -= lastColumn.width * barGapPercent;
}
var offset = -widthSum / 2;
each(stacks, function(column, stackId) {
result[coordSysName][stackId] = result[coordSysName][stackId] || {
bandWidth,
offset,
width: column.width
};
offset += column.width * (1 + barGapPercent);
});
});
return result;
}
function retrieveColumnLayout(barWidthAndOffset, axis, seriesModel) {
if (barWidthAndOffset && axis) {
var result = barWidthAndOffset[getAxisKey(axis)];
if (result != null && seriesModel != null) {
return result[getSeriesStackId(seriesModel)];
}
return result;
}
}
function layout(seriesType, ecModel) {
var seriesModels = prepareLayoutBarSeries(seriesType, ecModel);
var barWidthAndOffset = makeColumnLayout(seriesModels);
each(seriesModels, function(seriesModel) {
var data = seriesModel.getData();
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var stackId = getSeriesStackId(seriesModel);
var columnLayoutInfo = barWidthAndOffset[getAxisKey(baseAxis)][stackId];
var columnOffset = columnLayoutInfo.offset;
var columnWidth = columnLayoutInfo.width;
data.setLayout({
bandWidth: columnLayoutInfo.bandWidth,
offset: columnOffset,
size: columnWidth
});
});
}
function createProgressiveLayout(seriesType) {
return {
seriesType,
plan: createRenderPlanner(),
reset: function(seriesModel) {
if (!isOnCartesian(seriesModel)) {
return;
}
var data = seriesModel.getData();
var cartesian = seriesModel.coordinateSystem;
var baseAxis = cartesian.getBaseAxis();
var valueAxis = cartesian.getOtherAxis(baseAxis);
var valueDimIdx = data.getDimensionIndex(data.mapDimension(valueAxis.dim));
var baseDimIdx = data.getDimensionIndex(data.mapDimension(baseAxis.dim));
var drawBackground = seriesModel.get("showBackground", true);
var valueDim = data.mapDimension(valueAxis.dim);
var stackResultDim = data.getCalculationInfo("stackResultDimension");
var stacked = isDimensionStacked(data, valueDim) && !!data.getCalculationInfo("stackedOnSeries");
var isValueAxisH = valueAxis.isHorizontal();
var valueAxisStart = getValueAxisStart(baseAxis, valueAxis);
var isLarge = isInLargeMode(seriesModel);
var barMinHeight = seriesModel.get("barMinHeight") || 0;
var stackedDimIdx = stackResultDim && data.getDimensionIndex(stackResultDim);
var columnWidth = data.getLayout("size");
var columnOffset = data.getLayout("offset");
return {
progress: function(params, data2) {
var count = params.count;
var largePoints = isLarge && createFloat32Array(count * 3);
var largeBackgroundPoints = isLarge && drawBackground && createFloat32Array(count * 3);
var largeDataIndices = isLarge && createFloat32Array(count);
var coordLayout = cartesian.master.getRect();
var bgSize = isValueAxisH ? coordLayout.width : coordLayout.height;
var dataIndex;
var store = data2.getStore();
var idxOffset = 0;
while ((dataIndex = params.next()) != null) {
var value = store.get(stacked ? stackedDimIdx : valueDimIdx, dataIndex);
var baseValue = store.get(baseDimIdx, dataIndex);
var baseCoord = valueAxisStart;
var stackStartValue = void 0;
if (stacked) {
stackStartValue = +value - store.get(valueDimIdx, dataIndex);
}
var x = void 0;
var y = void 0;
var width = void 0;
var height = void 0;
if (isValueAxisH) {
var coord = cartesian.dataToPoint([value, baseValue]);
if (stacked) {
var startCoord = cartesian.dataToPoint([stackStartValue, baseValue]);
baseCoord = startCoord[0];
}
x = baseCoord;
y = coord[1] + columnOffset;
width = coord[0] - baseCoord;
height = columnWidth;
if (Math.abs(width) < barMinHeight) {
width = (width < 0 ? -1 : 1) * barMinHeight;
}
} else {
var coord = cartesian.dataToPoint([baseValue, value]);
if (stacked) {
var startCoord = cartesian.dataToPoint([baseValue, stackStartValue]);
baseCoord = startCoord[1];
}
x = coord[0] + columnOffset;
y = baseCoord;
width = columnWidth;
height = coord[1] - baseCoord;
if (Math.abs(height) < barMinHeight) {
height = (height <= 0 ? -1 : 1) * barMinHeight;
}
}
if (!isLarge) {
data2.setItemLayout(dataIndex, {
x,
y,
width,
height
});
} else {
largePoints[idxOffset] = x;
largePoints[idxOffset + 1] = y;
largePoints[idxOffset + 2] = isValueAxisH ? width : height;
if (largeBackgroundPoints) {
largeBackgroundPoints[idxOffset] = isValueAxisH ? coordLayout.x : x;
largeBackgroundPoints[idxOffset + 1] = isValueAxisH ? y : coordLayout.y;
largeBackgroundPoints[idxOffset + 2] = bgSize;
}
largeDataIndices[dataIndex] = dataIndex;
}
idxOffset += 3;
}
if (isLarge) {
data2.setLayout({
largePoints,
largeDataIndices,
largeBackgroundPoints,
valueAxisHorizontal: isValueAxisH
});
}
}
};
}
};
}
function isOnCartesian(seriesModel) {
return seriesModel.coordinateSystem && seriesModel.coordinateSystem.type === "cartesian2d";
}
function isInLargeMode(seriesModel) {
return seriesModel.pipelineContext && seriesModel.pipelineContext.large;
}
function getValueAxisStart(baseAxis, valueAxis) {
var startValue = valueAxis.model.get("startValue");
if (!startValue) {
startValue = 0;
}
return valueAxis.toGlobalCoord(valueAxis.dataToCoord(valueAxis.type === "log" ? startValue > 0 ? startValue : 1 : startValue));
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/Time.js
var bisect = function(a, x, lo, hi) {
while (lo < hi) {
var mid = lo + hi >>> 1;
if (a[mid][1] < x) {
lo = mid + 1;
} else {
hi = mid;
}
}
return lo;
};
var TimeScale = (
/** @class */
function(_super) {
__extends(TimeScale2, _super);
function TimeScale2(settings) {
var _this = _super.call(this, settings) || this;
_this.type = "time";
return _this;
}
TimeScale2.prototype.getLabel = function(tick) {
var useUTC = this.getSetting("useUTC");
return format(tick.value, fullLeveledFormatter[getDefaultFormatPrecisionOfInterval(getPrimaryTimeUnit(this._minLevelUnit))] || fullLeveledFormatter.second, useUTC, this.getSetting("locale"));
};
TimeScale2.prototype.getFormattedLabel = function(tick, idx, labelFormatter) {
var isUTC = this.getSetting("useUTC");
var lang = this.getSetting("locale");
return leveledFormat(tick, idx, labelFormatter, lang, isUTC);
};
TimeScale2.prototype.getTicks = function() {
var interval = this._interval;
var extent = this._extent;
var ticks = [];
if (!interval) {
return ticks;
}
ticks.push({
value: extent[0],
level: 0
});
var useUTC = this.getSetting("useUTC");
var innerTicks = getIntervalTicks(this._minLevelUnit, this._approxInterval, useUTC, extent);
ticks = ticks.concat(innerTicks);
ticks.push({
value: extent[1],
level: 0
});
return ticks;
};
TimeScale2.prototype.calcNiceExtent = function(opt) {
var extent = this._extent;
if (extent[0] === extent[1]) {
extent[0] -= ONE_DAY;
extent[1] += ONE_DAY;
}
if (extent[1] === -Infinity && extent[0] === Infinity) {
var d = /* @__PURE__ */ new Date();
extent[1] = +new Date(d.getFullYear(), d.getMonth(), d.getDate());
extent[0] = extent[1] - ONE_DAY;
}
this.calcNiceTicks(opt.splitNumber, opt.minInterval, opt.maxInterval);
};
TimeScale2.prototype.calcNiceTicks = function(approxTickNum, minInterval, maxInterval) {
approxTickNum = approxTickNum || 10;
var extent = this._extent;
var span = extent[1] - extent[0];
this._approxInterval = span / approxTickNum;
if (minInterval != null && this._approxInterval < minInterval) {
this._approxInterval = minInterval;
}
if (maxInterval != null && this._approxInterval > maxInterval) {
this._approxInterval = maxInterval;
}
var scaleIntervalsLen = scaleIntervals.length;
var idx = Math.min(bisect(scaleIntervals, this._approxInterval, 0, scaleIntervalsLen), scaleIntervalsLen - 1);
this._interval = scaleIntervals[idx][1];
this._minLevelUnit = scaleIntervals[Math.max(idx - 1, 0)][0];
};
TimeScale2.prototype.parse = function(val) {
return isNumber(val) ? val : +parseDate(val);
};
TimeScale2.prototype.contain = function(val) {
return contain2(this.parse(val), this._extent);
};
TimeScale2.prototype.normalize = function(val) {
return normalize(this.parse(val), this._extent);
};
TimeScale2.prototype.scale = function(val) {
return scale(val, this._extent);
};
TimeScale2.type = "time";
return TimeScale2;
}(Interval_default)
);
var scaleIntervals = [
// Format interval
["second", ONE_SECOND],
["minute", ONE_MINUTE],
["hour", ONE_HOUR],
["quarter-day", ONE_HOUR * 6],
["half-day", ONE_HOUR * 12],
["day", ONE_DAY * 1.2],
["half-week", ONE_DAY * 3.5],
["week", ONE_DAY * 7],
["month", ONE_DAY * 31],
["quarter", ONE_DAY * 95],
["half-year", ONE_YEAR / 2],
["year", ONE_YEAR]
// 1Y
];
function isUnitValueSame(unit, valueA, valueB, isUTC) {
var dateA = parseDate(valueA);
var dateB = parseDate(valueB);
var isSame = function(unit2) {
return getUnitValue(dateA, unit2, isUTC) === getUnitValue(dateB, unit2, isUTC);
};
var isSameYear = function() {
return isSame("year");
};
var isSameMonth = function() {
return isSameYear() && isSame("month");
};
var isSameDay = function() {
return isSameMonth() && isSame("day");
};
var isSameHour = function() {
return isSameDay() && isSame("hour");
};
var isSameMinute = function() {
return isSameHour() && isSame("minute");
};
var isSameSecond = function() {
return isSameMinute() && isSame("second");
};
var isSameMilliSecond = function() {
return isSameSecond() && isSame("millisecond");
};
switch (unit) {
case "year":
return isSameYear();
case "month":
return isSameMonth();
case "day":
return isSameDay();
case "hour":
return isSameHour();
case "minute":
return isSameMinute();
case "second":
return isSameSecond();
case "millisecond":
return isSameMilliSecond();
}
}
function getDateInterval(approxInterval, daysInMonth) {
approxInterval /= ONE_DAY;
return approxInterval > 16 ? 16 : approxInterval > 7.5 ? 7 : approxInterval > 3.5 ? 4 : approxInterval > 1.5 ? 2 : 1;
}
function getMonthInterval(approxInterval) {
var APPROX_ONE_MONTH = 30 * ONE_DAY;
approxInterval /= APPROX_ONE_MONTH;
return approxInterval > 6 ? 6 : approxInterval > 3 ? 3 : approxInterval > 2 ? 2 : 1;
}
function getHourInterval(approxInterval) {
approxInterval /= ONE_HOUR;
return approxInterval > 12 ? 12 : approxInterval > 6 ? 6 : approxInterval > 3.5 ? 4 : approxInterval > 2 ? 2 : 1;
}
function getMinutesAndSecondsInterval(approxInterval, isMinutes) {
approxInterval /= isMinutes ? ONE_MINUTE : ONE_SECOND;
return approxInterval > 30 ? 30 : approxInterval > 20 ? 20 : approxInterval > 15 ? 15 : approxInterval > 10 ? 10 : approxInterval > 5 ? 5 : approxInterval > 2 ? 2 : 1;
}
function getMillisecondsInterval(approxInterval) {
return nice(approxInterval, true);
}
function getFirstTimestampOfUnit(date, unitName, isUTC) {
var outDate = new Date(date);
switch (getPrimaryTimeUnit(unitName)) {
case "year":
case "month":
outDate[monthSetterName(isUTC)](0);
case "day":
outDate[dateSetterName(isUTC)](1);
case "hour":
outDate[hoursSetterName(isUTC)](0);
case "minute":
outDate[minutesSetterName(isUTC)](0);
case "second":
outDate[secondsSetterName(isUTC)](0);
outDate[millisecondsSetterName(isUTC)](0);
}
return outDate.getTime();
}
function getIntervalTicks(bottomUnitName, approxInterval, isUTC, extent) {
var safeLimit = 1e4;
var unitNames = timeUnits;
var iter = 0;
function addTicksInSpan(interval, minTimestamp, maxTimestamp, getMethodName, setMethodName, isDate, out) {
var date = new Date(minTimestamp);
var dateTime = minTimestamp;
var d = date[getMethodName]();
while (dateTime < maxTimestamp && dateTime <= extent[1]) {
out.push({
value: dateTime
});
d += interval;
date[setMethodName](d);
dateTime = date.getTime();
}
out.push({
value: dateTime,
notAdd: true
});
}
function addLevelTicks(unitName, lastLevelTicks, levelTicks2) {
var newAddedTicks = [];
var isFirstLevel = !lastLevelTicks.length;
if (isUnitValueSame(getPrimaryTimeUnit(unitName), extent[0], extent[1], isUTC)) {
return;
}
if (isFirstLevel) {
lastLevelTicks = [{
// TODO Optimize. Not include so may ticks.
value: getFirstTimestampOfUnit(new Date(extent[0]), unitName, isUTC)
}, {
value: extent[1]
}];
}
for (var i2 = 0; i2 < lastLevelTicks.length - 1; i2++) {
var startTick = lastLevelTicks[i2].value;
var endTick = lastLevelTicks[i2 + 1].value;
if (startTick === endTick) {
continue;
}
var interval = void 0;
var getterName = void 0;
var setterName = void 0;
var isDate = false;
switch (unitName) {
case "year":
interval = Math.max(1, Math.round(approxInterval / ONE_DAY / 365));
getterName = fullYearGetterName(isUTC);
setterName = fullYearSetterName(isUTC);
break;
case "half-year":
case "quarter":
case "month":
interval = getMonthInterval(approxInterval);
getterName = monthGetterName(isUTC);
setterName = monthSetterName(isUTC);
break;
case "week":
case "half-week":
case "day":
interval = getDateInterval(approxInterval, 31);
getterName = dateGetterName(isUTC);
setterName = dateSetterName(isUTC);
isDate = true;
break;
case "half-day":
case "quarter-day":
case "hour":
interval = getHourInterval(approxInterval);
getterName = hoursGetterName(isUTC);
setterName = hoursSetterName(isUTC);
break;
case "minute":
interval = getMinutesAndSecondsInterval(approxInterval, true);
getterName = minutesGetterName(isUTC);
setterName = minutesSetterName(isUTC);
break;
case "second":
interval = getMinutesAndSecondsInterval(approxInterval, false);
getterName = secondsGetterName(isUTC);
setterName = secondsSetterName(isUTC);
break;
case "millisecond":
interval = getMillisecondsInterval(approxInterval);
getterName = millisecondsGetterName(isUTC);
setterName = millisecondsSetterName(isUTC);
break;
}
addTicksInSpan(interval, startTick, endTick, getterName, setterName, isDate, newAddedTicks);
if (unitName === "year" && levelTicks2.length > 1 && i2 === 0) {
levelTicks2.unshift({
value: levelTicks2[0].value - interval
});
}
}
for (var i2 = 0; i2 < newAddedTicks.length; i2++) {
levelTicks2.push(newAddedTicks[i2]);
}
return newAddedTicks;
}
var levelsTicks = [];
var currentLevelTicks = [];
var tickCount = 0;
var lastLevelTickCount = 0;
for (var i = 0; i < unitNames.length && iter++ < safeLimit; ++i) {
var primaryTimeUnit = getPrimaryTimeUnit(unitNames[i]);
if (!isPrimaryTimeUnit(unitNames[i])) {
continue;
}
addLevelTicks(unitNames[i], levelsTicks[levelsTicks.length - 1] || [], currentLevelTicks);
var nextPrimaryTimeUnit = unitNames[i + 1] ? getPrimaryTimeUnit(unitNames[i + 1]) : null;
if (primaryTimeUnit !== nextPrimaryTimeUnit) {
if (currentLevelTicks.length) {
lastLevelTickCount = tickCount;
currentLevelTicks.sort(function(a, b) {
return a.value - b.value;
});
var levelTicksRemoveDuplicated = [];
for (var i_1 = 0; i_1 < currentLevelTicks.length; ++i_1) {
var tickValue = currentLevelTicks[i_1].value;
if (i_1 === 0 || currentLevelTicks[i_1 - 1].value !== tickValue) {
levelTicksRemoveDuplicated.push(currentLevelTicks[i_1]);
if (tickValue >= extent[0] && tickValue <= extent[1]) {
tickCount++;
}
}
}
var targetTickNum = (extent[1] - extent[0]) / approxInterval;
if (tickCount > targetTickNum * 1.5 && lastLevelTickCount > targetTickNum / 1.5) {
break;
}
levelsTicks.push(levelTicksRemoveDuplicated);
if (tickCount > targetTickNum || bottomUnitName === unitNames[i]) {
break;
}
}
currentLevelTicks = [];
}
}
if (true) {
if (iter >= safeLimit) {
warn("Exceed safe limit.");
}
}
var levelsTicksInExtent = filter(map(levelsTicks, function(levelTicks2) {
return filter(levelTicks2, function(tick) {
return tick.value >= extent[0] && tick.value <= extent[1] && !tick.notAdd;
});
}), function(levelTicks2) {
return levelTicks2.length > 0;
});
var ticks = [];
var maxLevel = levelsTicksInExtent.length - 1;
for (var i = 0; i < levelsTicksInExtent.length; ++i) {
var levelTicks = levelsTicksInExtent[i];
for (var k = 0; k < levelTicks.length; ++k) {
ticks.push({
value: levelTicks[k].value,
level: maxLevel - i
});
}
}
ticks.sort(function(a, b) {
return a.value - b.value;
});
var result = [];
for (var i = 0; i < ticks.length; ++i) {
if (i === 0 || ticks[i].value !== ticks[i - 1].value) {
result.push(ticks[i]);
}
}
return result;
}
Scale_default.registerClass(TimeScale);
var Time_default = TimeScale;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/scale/Log.js
var scaleProto = Scale_default.prototype;
var intervalScaleProto = Interval_default.prototype;
var roundingErrorFix = round;
var mathFloor = Math.floor;
var mathCeil = Math.ceil;
var mathPow = Math.pow;
var mathLog = Math.log;
var LogScale = (
/** @class */
function(_super) {
__extends(LogScale2, _super);
function LogScale2() {
var _this = _super !== null && _super.apply(this, arguments) || this;
_this.type = "log";
_this.base = 10;
_this._originalScale = new Interval_default();
_this._interval = 0;
return _this;
}
LogScale2.prototype.getTicks = function(expandToNicedExtent) {
var originalScale = this._originalScale;
var extent = this._extent;
var originalExtent = originalScale.getExtent();
var ticks = intervalScaleProto.getTicks.call(this, expandToNicedExtent);
return map(ticks, function(tick) {
var val = tick.value;
var powVal = round(mathPow(this.base, val));
powVal = val === extent[0] && this._fixMin ? fixRoundingError(powVal, originalExtent[0]) : powVal;
powVal = val === extent[1] && this._fixMax ? fixRoundingError(powVal, originalExtent[1]) : powVal;
return {
value: powVal
};
}, this);
};
LogScale2.prototype.setExtent = function(start, end) {
var base = mathLog(this.base);
start = mathLog(Math.max(0, start)) / base;
end = mathLog(Math.max(0, end)) / base;
intervalScaleProto.setExtent.call(this, start, end);
};
LogScale2.prototype.getExtent = function() {
var base = this.base;
var extent = scaleProto.getExtent.call(this);
extent[0] = mathPow(base, extent[0]);
extent[1] = mathPow(base, extent[1]);
var originalScale = this._originalScale;
var originalExtent = originalScale.getExtent();
this._fixMin && (extent[0] = fixRoundingError(extent[0], originalExtent[0]));
this._fixMax && (extent[1] = fixRoundingError(extent[1], originalExtent[1]));
return extent;
};
LogScale2.prototype.unionExtent = function(extent) {
this._originalScale.unionExtent(extent);
var base = this.base;
extent[0] = mathLog(extent[0]) / mathLog(base);
extent[1] = mathLog(extent[1]) / mathLog(base);
scaleProto.unionExtent.call(this, extent);
};
LogScale2.prototype.unionExtentFromData = function(data, dim) {
this.unionExtent(data.getApproximateExtent(dim));
};
LogScale2.prototype.calcNiceTicks = function(approxTickNum) {
approxTickNum = approxTickNum || 10;
var extent = this._extent;
var span = extent[1] - extent[0];
if (span === Infinity || span <= 0) {
return;
}
var interval = quantity(span);
var err = approxTickNum / span * interval;
if (err <= 0.5) {
interval *= 10;
}
while (!isNaN(interval) && Math.abs(interval) < 1 && Math.abs(interval) > 0) {
interval *= 10;
}
var niceExtent = [round(mathCeil(extent[0] / interval) * interval), round(mathFloor(extent[1] / interval) * interval)];
this._interval = interval;
this._niceExtent = niceExtent;
};
LogScale2.prototype.calcNiceExtent = function(opt) {
intervalScaleProto.calcNiceExtent.call(this, opt);
this._fixMin = opt.fixMin;
this._fixMax = opt.fixMax;
};
LogScale2.prototype.parse = function(val) {
return val;
};
LogScale2.prototype.contain = function(val) {
val = mathLog(val) / mathLog(this.base);
return contain2(val, this._extent);
};
LogScale2.prototype.normalize = function(val) {
val = mathLog(val) / mathLog(this.base);
return normalize(val, this._extent);
};
LogScale2.prototype.scale = function(val) {
val = scale(val, this._extent);
return mathPow(this.base, val);
};
LogScale2.type = "log";
return LogScale2;
}(Scale_default)
);
var proto = LogScale.prototype;
proto.getMinorTicks = intervalScaleProto.getMinorTicks;
proto.getLabel = intervalScaleProto.getLabel;
function fixRoundingError(val, originalVal) {
return roundingErrorFix(val, getPrecision(originalVal));
}
Scale_default.registerClass(LogScale);
var Log_default = LogScale;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/scaleRawExtentInfo.js
var ScaleRawExtentInfo = (
/** @class */
function() {
function ScaleRawExtentInfo2(scale2, model, originalExtent) {
this._prepareParams(scale2, model, originalExtent);
}
ScaleRawExtentInfo2.prototype._prepareParams = function(scale2, model, dataExtent) {
if (dataExtent[1] < dataExtent[0]) {
dataExtent = [NaN, NaN];
}
this._dataMin = dataExtent[0];
this._dataMax = dataExtent[1];
var isOrdinal = this._isOrdinal = scale2.type === "ordinal";
this._needCrossZero = scale2.type === "interval" && model.getNeedCrossZero && model.getNeedCrossZero();
var axisMinValue = model.get("min", true);
if (axisMinValue == null) {
axisMinValue = model.get("startValue", true);
}
var modelMinRaw = this._modelMinRaw = axisMinValue;
if (isFunction(modelMinRaw)) {
this._modelMinNum = parseAxisModelMinMax(scale2, modelMinRaw({
min: dataExtent[0],
max: dataExtent[1]
}));
} else if (modelMinRaw !== "dataMin") {
this._modelMinNum = parseAxisModelMinMax(scale2, modelMinRaw);
}
var modelMaxRaw = this._modelMaxRaw = model.get("max", true);
if (isFunction(modelMaxRaw)) {
this._modelMaxNum = parseAxisModelMinMax(scale2, modelMaxRaw({
min: dataExtent[0],
max: dataExtent[1]
}));
} else if (modelMaxRaw !== "dataMax") {
this._modelMaxNum = parseAxisModelMinMax(scale2, modelMaxRaw);
}
if (isOrdinal) {
this._axisDataLen = model.getCategories().length;
} else {
var boundaryGap = model.get("boundaryGap");
var boundaryGapArr = isArray(boundaryGap) ? boundaryGap : [boundaryGap || 0, boundaryGap || 0];
if (typeof boundaryGapArr[0] === "boolean" || typeof boundaryGapArr[1] === "boolean") {
if (true) {
console.warn('Boolean type for boundaryGap is only allowed for ordinal axis. Please use string in percentage instead, e.g., "20%". Currently, boundaryGap is set to be 0.');
}
this._boundaryGapInner = [0, 0];
} else {
this._boundaryGapInner = [parsePercent(boundaryGapArr[0], 1), parsePercent(boundaryGapArr[1], 1)];
}
}
};
ScaleRawExtentInfo2.prototype.calculate = function() {
var isOrdinal = this._isOrdinal;
var dataMin = this._dataMin;
var dataMax = this._dataMax;
var axisDataLen = this._axisDataLen;
var boundaryGapInner = this._boundaryGapInner;
var span = !isOrdinal ? dataMax - dataMin || Math.abs(dataMin) : null;
var min2 = this._modelMinRaw === "dataMin" ? dataMin : this._modelMinNum;
var max2 = this._modelMaxRaw === "dataMax" ? dataMax : this._modelMaxNum;
var minFixed = min2 != null;
var maxFixed = max2 != null;
if (min2 == null) {
min2 = isOrdinal ? axisDataLen ? 0 : NaN : dataMin - boundaryGapInner[0] * span;
}
if (max2 == null) {
max2 = isOrdinal ? axisDataLen ? axisDataLen - 1 : NaN : dataMax + boundaryGapInner[1] * span;
}
(min2 == null || !isFinite(min2)) && (min2 = NaN);
(max2 == null || !isFinite(max2)) && (max2 = NaN);
var isBlank = eqNaN(min2) || eqNaN(max2) || isOrdinal && !axisDataLen;
if (this._needCrossZero) {
if (min2 > 0 && max2 > 0 && !minFixed) {
min2 = 0;
}
if (min2 < 0 && max2 < 0 && !maxFixed) {
max2 = 0;
}
}
var determinedMin = this._determinedMin;
var determinedMax = this._determinedMax;
if (determinedMin != null) {
min2 = determinedMin;
minFixed = true;
}
if (determinedMax != null) {
max2 = determinedMax;
maxFixed = true;
}
return {
min: min2,
max: max2,
minFixed,
maxFixed,
isBlank
};
};
ScaleRawExtentInfo2.prototype.modifyDataMinMax = function(minMaxName, val) {
if (true) {
assert(!this.frozen);
}
this[DATA_MIN_MAX_ATTR[minMaxName]] = val;
};
ScaleRawExtentInfo2.prototype.setDeterminedMinMax = function(minMaxName, val) {
var attr = DETERMINED_MIN_MAX_ATTR[minMaxName];
if (true) {
assert(!this.frozen && this[attr] == null);
}
this[attr] = val;
};
ScaleRawExtentInfo2.prototype.freeze = function() {
this.frozen = true;
};
return ScaleRawExtentInfo2;
}()
);
var DETERMINED_MIN_MAX_ATTR = {
min: "_determinedMin",
max: "_determinedMax"
};
var DATA_MIN_MAX_ATTR = {
min: "_dataMin",
max: "_dataMax"
};
function ensureScaleRawExtentInfo(scale2, model, originalExtent) {
var rawExtentInfo = scale2.rawExtentInfo;
if (rawExtentInfo) {
return rawExtentInfo;
}
rawExtentInfo = new ScaleRawExtentInfo(scale2, model, originalExtent);
scale2.rawExtentInfo = rawExtentInfo;
return rawExtentInfo;
}
function parseAxisModelMinMax(scale2, minMax) {
return minMax == null ? null : eqNaN(minMax) ? NaN : scale2.parse(minMax);
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/axisHelper.js
function getScaleExtent(scale2, model) {
var scaleType = scale2.type;
var rawExtentResult = ensureScaleRawExtentInfo(scale2, model, scale2.getExtent()).calculate();
scale2.setBlank(rawExtentResult.isBlank);
var min2 = rawExtentResult.min;
var max2 = rawExtentResult.max;
var ecModel = model.ecModel;
if (ecModel && scaleType === "time") {
var barSeriesModels = prepareLayoutBarSeries("bar", ecModel);
var isBaseAxisAndHasBarSeries_1 = false;
each(barSeriesModels, function(seriesModel) {
isBaseAxisAndHasBarSeries_1 = isBaseAxisAndHasBarSeries_1 || seriesModel.getBaseAxis() === model.axis;
});
if (isBaseAxisAndHasBarSeries_1) {
var barWidthAndOffset = makeColumnLayout(barSeriesModels);
var adjustedScale = adjustScaleForOverflow(min2, max2, model, barWidthAndOffset);
min2 = adjustedScale.min;
max2 = adjustedScale.max;
}
}
return {
extent: [min2, max2],
// "fix" means "fixed", the value should not be
// changed in the subsequent steps.
fixMin: rawExtentResult.minFixed,
fixMax: rawExtentResult.maxFixed
};
}
function adjustScaleForOverflow(min2, max2, model, barWidthAndOffset) {
var axisExtent = model.axis.getExtent();
var axisLength = axisExtent[1] - axisExtent[0];
var barsOnCurrentAxis = retrieveColumnLayout(barWidthAndOffset, model.axis);
if (barsOnCurrentAxis === void 0) {
return {
min: min2,
max: max2
};
}
var minOverflow = Infinity;
each(barsOnCurrentAxis, function(item) {
minOverflow = Math.min(item.offset, minOverflow);
});
var maxOverflow = -Infinity;
each(barsOnCurrentAxis, function(item) {
maxOverflow = Math.max(item.offset + item.width, maxOverflow);
});
minOverflow = Math.abs(minOverflow);
maxOverflow = Math.abs(maxOverflow);
var totalOverFlow = minOverflow + maxOverflow;
var oldRange = max2 - min2;
var oldRangePercentOfNew = 1 - (minOverflow + maxOverflow) / axisLength;
var overflowBuffer = oldRange / oldRangePercentOfNew - oldRange;
max2 += overflowBuffer * (maxOverflow / totalOverFlow);
min2 -= overflowBuffer * (minOverflow / totalOverFlow);
return {
min: min2,
max: max2
};
}
function niceScaleExtent(scale2, inModel) {
var model = inModel;
var extentInfo = getScaleExtent(scale2, model);
var extent = extentInfo.extent;
var splitNumber = model.get("splitNumber");
if (scale2 instanceof Log_default) {
scale2.base = model.get("logBase");
}
var scaleType = scale2.type;
var interval = model.get("interval");
var isIntervalOrTime = scaleType === "interval" || scaleType === "time";
scale2.setExtent(extent[0], extent[1]);
scale2.calcNiceExtent({
splitNumber,
fixMin: extentInfo.fixMin,
fixMax: extentInfo.fixMax,
minInterval: isIntervalOrTime ? model.get("minInterval") : null,
maxInterval: isIntervalOrTime ? model.get("maxInterval") : null
});
if (interval != null) {
scale2.setInterval && scale2.setInterval(interval);
}
}
function createScaleByModel(model, axisType) {
axisType = axisType || model.get("type");
if (axisType) {
switch (axisType) {
case "category":
return new Ordinal_default({
ordinalMeta: model.getOrdinalMeta ? model.getOrdinalMeta() : model.getCategories(),
extent: [Infinity, -Infinity]
});
case "time":
return new Time_default({
locale: model.ecModel.getLocaleModel(),
useUTC: model.ecModel.get("useUTC")
});
default:
return new (Scale_default.getClass(axisType) || Interval_default)();
}
}
}
function ifAxisCrossZero(axis) {
var dataExtent = axis.scale.getExtent();
var min2 = dataExtent[0];
var max2 = dataExtent[1];
return !(min2 > 0 && max2 > 0 || min2 < 0 && max2 < 0);
}
function makeLabelFormatter(axis) {
var labelFormatter = axis.getLabelModel().get("formatter");
var categoryTickStart = axis.type === "category" ? axis.scale.getExtent()[0] : null;
if (axis.scale.type === "time") {
return /* @__PURE__ */ function(tpl) {
return function(tick, idx) {
return axis.scale.getFormattedLabel(tick, idx, tpl);
};
}(labelFormatter);
} else if (isString(labelFormatter)) {
return /* @__PURE__ */ function(tpl) {
return function(tick) {
var label = axis.scale.getLabel(tick);
var text = tpl.replace("{value}", label != null ? label : "");
return text;
};
}(labelFormatter);
} else if (isFunction(labelFormatter)) {
return /* @__PURE__ */ function(cb) {
return function(tick, idx) {
if (categoryTickStart != null) {
idx = tick.value - categoryTickStart;
}
return cb(getAxisRawValue(axis, tick), idx, tick.level != null ? {
level: tick.level
} : null);
};
}(labelFormatter);
} else {
return function(tick) {
return axis.scale.getLabel(tick);
};
}
}
function getAxisRawValue(axis, tick) {
return axis.type === "category" ? axis.scale.getLabel(tick) : tick.value;
}
function estimateLabelUnionRect(axis) {
var axisModel = axis.model;
var scale2 = axis.scale;
if (!axisModel.get(["axisLabel", "show"]) || scale2.isBlank()) {
return;
}
var realNumberScaleTicks;
var tickCount;
var categoryScaleExtent = scale2.getExtent();
if (scale2 instanceof Ordinal_default) {
tickCount = scale2.count();
} else {
realNumberScaleTicks = scale2.getTicks();
tickCount = realNumberScaleTicks.length;
}
var axisLabelModel = axis.getLabelModel();
var labelFormatter = makeLabelFormatter(axis);
var rect;
var step = 1;
if (tickCount > 40) {
step = Math.ceil(tickCount / 40);
}
for (var i = 0; i < tickCount; i += step) {
var tick = realNumberScaleTicks ? realNumberScaleTicks[i] : {
value: categoryScaleExtent[0] + i
};
var label = labelFormatter(tick, i);
var unrotatedSingleRect = axisLabelModel.getTextRect(label);
var singleRect = rotateTextRect(unrotatedSingleRect, axisLabelModel.get("rotate") || 0);
rect ? rect.union(singleRect) : rect = singleRect;
}
return rect;
}
function rotateTextRect(textRect, rotate) {
var rotateRadians = rotate * Math.PI / 180;
var beforeWidth = textRect.width;
var beforeHeight = textRect.height;
var afterWidth = beforeWidth * Math.abs(Math.cos(rotateRadians)) + Math.abs(beforeHeight * Math.sin(rotateRadians));
var afterHeight = beforeWidth * Math.abs(Math.sin(rotateRadians)) + Math.abs(beforeHeight * Math.cos(rotateRadians));
var rotatedRect = new BoundingRect_default(textRect.x, textRect.y, afterWidth, afterHeight);
return rotatedRect;
}
function getOptionCategoryInterval(model) {
var interval = model.get("interval");
return interval == null ? "auto" : interval;
}
function shouldShowAllLabels(axis) {
return axis.type === "category" && getOptionCategoryInterval(axis.getLabelModel()) === 0;
}
function getDataDimensionsOnAxis(data, axisDim) {
var dataDimMap = {};
each(data.mapDimensionsAll(axisDim), function(dataDim) {
dataDimMap[getStackedDimension(data, dataDim)] = true;
});
return keys(dataDimMap);
}
function unionAxisExtentFromData(dataExtent, data, axisDim) {
if (data) {
each(getDataDimensionsOnAxis(data, axisDim), function(dim) {
var seriesExtent = data.getApproximateExtent(dim);
seriesExtent[0] < dataExtent[0] && (dataExtent[0] = seriesExtent[0]);
seriesExtent[1] > dataExtent[1] && (dataExtent[1] = seriesExtent[1]);
});
}
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/axisTickLabelBuilder.js
var inner = makeInner();
function tickValuesToNumbers(axis, values) {
var nums = map(values, function(val) {
return axis.scale.parse(val);
});
if (axis.type === "time" && nums.length > 0) {
nums.sort();
nums.unshift(nums[0]);
nums.push(nums[nums.length - 1]);
}
return nums;
}
function createAxisLabels(axis) {
var custom = axis.getLabelModel().get("customValues");
if (custom) {
var labelFormatter_1 = makeLabelFormatter(axis);
return {
labels: tickValuesToNumbers(axis, custom).map(function(numval) {
var tick = {
value: numval
};
return {
formattedLabel: labelFormatter_1(tick),
rawLabel: axis.scale.getLabel(tick),
tickValue: numval
};
})
};
}
return axis.type === "category" ? makeCategoryLabels(axis) : makeRealNumberLabels(axis);
}
function createAxisTicks(axis, tickModel) {
var custom = axis.getTickModel().get("customValues");
if (custom) {
return {
ticks: tickValuesToNumbers(axis, custom)
};
}
return axis.type === "category" ? makeCategoryTicks(axis, tickModel) : {
ticks: map(axis.scale.getTicks(), function(tick) {
return tick.value;
})
};
}
function makeCategoryLabels(axis) {
var labelModel = axis.getLabelModel();
var result = makeCategoryLabelsActually(axis, labelModel);
return !labelModel.get("show") || axis.scale.isBlank() ? {
labels: [],
labelCategoryInterval: result.labelCategoryInterval
} : result;
}
function makeCategoryLabelsActually(axis, labelModel) {
var labelsCache = getListCache(axis, "labels");
var optionLabelInterval = getOptionCategoryInterval(labelModel);
var result = listCacheGet(labelsCache, optionLabelInterval);
if (result) {
return result;
}
var labels;
var numericLabelInterval;
if (isFunction(optionLabelInterval)) {
labels = makeLabelsByCustomizedCategoryInterval(axis, optionLabelInterval);
} else {
numericLabelInterval = optionLabelInterval === "auto" ? makeAutoCategoryInterval(axis) : optionLabelInterval;
labels = makeLabelsByNumericCategoryInterval(axis, numericLabelInterval);
}
return listCacheSet(labelsCache, optionLabelInterval, {
labels,
labelCategoryInterval: numericLabelInterval
});
}
function makeCategoryTicks(axis, tickModel) {
var ticksCache = getListCache(axis, "ticks");
var optionTickInterval = getOptionCategoryInterval(tickModel);
var result = listCacheGet(ticksCache, optionTickInterval);
if (result) {
return result;
}
var ticks;
var tickCategoryInterval;
if (!tickModel.get("show") || axis.scale.isBlank()) {
ticks = [];
}
if (isFunction(optionTickInterval)) {
ticks = makeLabelsByCustomizedCategoryInterval(axis, optionTickInterval, true);
} else if (optionTickInterval === "auto") {
var labelsResult = makeCategoryLabelsActually(axis, axis.getLabelModel());
tickCategoryInterval = labelsResult.labelCategoryInterval;
ticks = map(labelsResult.labels, function(labelItem) {
return labelItem.tickValue;
});
} else {
tickCategoryInterval = optionTickInterval;
ticks = makeLabelsByNumericCategoryInterval(axis, tickCategoryInterval, true);
}
return listCacheSet(ticksCache, optionTickInterval, {
ticks,
tickCategoryInterval
});
}
function makeRealNumberLabels(axis) {
var ticks = axis.scale.getTicks();
var labelFormatter = makeLabelFormatter(axis);
return {
labels: map(ticks, function(tick, idx) {
return {
level: tick.level,
formattedLabel: labelFormatter(tick, idx),
rawLabel: axis.scale.getLabel(tick),
tickValue: tick.value
};
})
};
}
function getListCache(axis, prop) {
return inner(axis)[prop] || (inner(axis)[prop] = []);
}
function listCacheGet(cache, key) {
for (var i = 0; i < cache.length; i++) {
if (cache[i].key === key) {
return cache[i].value;
}
}
}
function listCacheSet(cache, key, value) {
cache.push({
key,
value
});
return value;
}
function makeAutoCategoryInterval(axis) {
var result = inner(axis).autoInterval;
return result != null ? result : inner(axis).autoInterval = axis.calculateCategoryInterval();
}
function calculateCategoryInterval(axis) {
var params = fetchAutoCategoryIntervalCalculationParams(axis);
var labelFormatter = makeLabelFormatter(axis);
var rotation = (params.axisRotate - params.labelRotate) / 180 * Math.PI;
var ordinalScale = axis.scale;
var ordinalExtent = ordinalScale.getExtent();
var tickCount = ordinalScale.count();
if (ordinalExtent[1] - ordinalExtent[0] < 1) {
return 0;
}
var step = 1;
if (tickCount > 40) {
step = Math.max(1, Math.floor(tickCount / 40));
}
var tickValue = ordinalExtent[0];
var unitSpan = axis.dataToCoord(tickValue + 1) - axis.dataToCoord(tickValue);
var unitW = Math.abs(unitSpan * Math.cos(rotation));
var unitH = Math.abs(unitSpan * Math.sin(rotation));
var maxW = 0;
var maxH = 0;
for (; tickValue <= ordinalExtent[1]; tickValue += step) {
var width = 0;
var height = 0;
var rect = getBoundingRect(labelFormatter({
value: tickValue
}), params.font, "center", "top");
width = rect.width * 1.3;
height = rect.height * 1.3;
maxW = Math.max(maxW, width, 7);
maxH = Math.max(maxH, height, 7);
}
var dw = maxW / unitW;
var dh = maxH / unitH;
isNaN(dw) && (dw = Infinity);
isNaN(dh) && (dh = Infinity);
var interval = Math.max(0, Math.floor(Math.min(dw, dh)));
var cache = inner(axis.model);
var axisExtent = axis.getExtent();
var lastAutoInterval = cache.lastAutoInterval;
var lastTickCount = cache.lastTickCount;
if (lastAutoInterval != null && lastTickCount != null && Math.abs(lastAutoInterval - interval) <= 1 && Math.abs(lastTickCount - tickCount) <= 1 && lastAutoInterval > interval && cache.axisExtent0 === axisExtent[0] && cache.axisExtent1 === axisExtent[1]) {
interval = lastAutoInterval;
} else {
cache.lastTickCount = tickCount;
cache.lastAutoInterval = interval;
cache.axisExtent0 = axisExtent[0];
cache.axisExtent1 = axisExtent[1];
}
return interval;
}
function fetchAutoCategoryIntervalCalculationParams(axis) {
var labelModel = axis.getLabelModel();
return {
axisRotate: axis.getRotate ? axis.getRotate() : axis.isHorizontal && !axis.isHorizontal() ? 90 : 0,
labelRotate: labelModel.get("rotate") || 0,
font: labelModel.getFont()
};
}
function makeLabelsByNumericCategoryInterval(axis, categoryInterval, onlyTick) {
var labelFormatter = makeLabelFormatter(axis);
var ordinalScale = axis.scale;
var ordinalExtent = ordinalScale.getExtent();
var labelModel = axis.getLabelModel();
var result = [];
var step = Math.max((categoryInterval || 0) + 1, 1);
var startTick = ordinalExtent[0];
var tickCount = ordinalScale.count();
if (startTick !== 0 && step > 1 && tickCount / step > 2) {
startTick = Math.round(Math.ceil(startTick / step) * step);
}
var showAllLabel = shouldShowAllLabels(axis);
var includeMinLabel = labelModel.get("showMinLabel") || showAllLabel;
var includeMaxLabel = labelModel.get("showMaxLabel") || showAllLabel;
if (includeMinLabel && startTick !== ordinalExtent[0]) {
addItem(ordinalExtent[0]);
}
var tickValue = startTick;
for (; tickValue <= ordinalExtent[1]; tickValue += step) {
addItem(tickValue);
}
if (includeMaxLabel && tickValue - step !== ordinalExtent[1]) {
addItem(ordinalExtent[1]);
}
function addItem(tickValue2) {
var tickObj = {
value: tickValue2
};
result.push(onlyTick ? tickValue2 : {
formattedLabel: labelFormatter(tickObj),
rawLabel: ordinalScale.getLabel(tickObj),
tickValue: tickValue2
});
}
return result;
}
function makeLabelsByCustomizedCategoryInterval(axis, categoryInterval, onlyTick) {
var ordinalScale = axis.scale;
var labelFormatter = makeLabelFormatter(axis);
var result = [];
each(ordinalScale.getTicks(), function(tick) {
var rawLabel = ordinalScale.getLabel(tick);
var tickValue = tick.value;
if (categoryInterval(tick.value, rawLabel)) {
result.push(onlyTick ? tickValue : {
formattedLabel: labelFormatter(tick),
rawLabel,
tickValue
});
}
});
return result;
}
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/Axis.js
var NORMALIZED_EXTENT = [0, 1];
var Axis = (
/** @class */
function() {
function Axis2(dim, scale2, extent) {
this.onBand = false;
this.inverse = false;
this.dim = dim;
this.scale = scale2;
this._extent = extent || [0, 0];
}
Axis2.prototype.contain = function(coord) {
var extent = this._extent;
var min2 = Math.min(extent[0], extent[1]);
var max2 = Math.max(extent[0], extent[1]);
return coord >= min2 && coord <= max2;
};
Axis2.prototype.containData = function(data) {
return this.scale.contain(data);
};
Axis2.prototype.getExtent = function() {
return this._extent.slice();
};
Axis2.prototype.getPixelPrecision = function(dataExtent) {
return getPixelPrecision(dataExtent || this.scale.getExtent(), this._extent);
};
Axis2.prototype.setExtent = function(start, end) {
var extent = this._extent;
extent[0] = start;
extent[1] = end;
};
Axis2.prototype.dataToCoord = function(data, clamp2) {
var extent = this._extent;
var scale2 = this.scale;
data = scale2.normalize(data);
if (this.onBand && scale2.type === "ordinal") {
extent = extent.slice();
fixExtentWithBands(extent, scale2.count());
}
return linearMap(data, NORMALIZED_EXTENT, extent, clamp2);
};
Axis2.prototype.coordToData = function(coord, clamp2) {
var extent = this._extent;
var scale2 = this.scale;
if (this.onBand && scale2.type === "ordinal") {
extent = extent.slice();
fixExtentWithBands(extent, scale2.count());
}
var t = linearMap(coord, extent, NORMALIZED_EXTENT, clamp2);
return this.scale.scale(t);
};
Axis2.prototype.pointToData = function(point, clamp2) {
return;
};
Axis2.prototype.getTicksCoords = function(opt) {
opt = opt || {};
var tickModel = opt.tickModel || this.getTickModel();
var result = createAxisTicks(this, tickModel);
var ticks = result.ticks;
var ticksCoords = map(ticks, function(tickVal) {
return {
coord: this.dataToCoord(this.scale.type === "ordinal" ? this.scale.getRawOrdinalNumber(tickVal) : tickVal),
tickValue: tickVal
};
}, this);
var alignWithLabel = tickModel.get("alignWithLabel");
fixOnBandTicksCoords(this, ticksCoords, alignWithLabel, opt.clamp);
return ticksCoords;
};
Axis2.prototype.getMinorTicksCoords = function() {
if (this.scale.type === "ordinal") {
return [];
}
var minorTickModel = this.model.getModel("minorTick");
var splitNumber = minorTickModel.get("splitNumber");
if (!(splitNumber > 0 && splitNumber < 100)) {
splitNumber = 5;
}
var minorTicks = this.scale.getMinorTicks(splitNumber);
var minorTicksCoords = map(minorTicks, function(minorTicksGroup) {
return map(minorTicksGroup, function(minorTick) {
return {
coord: this.dataToCoord(minorTick),
tickValue: minorTick
};
}, this);
}, this);
return minorTicksCoords;
};
Axis2.prototype.getViewLabels = function() {
return createAxisLabels(this).labels;
};
Axis2.prototype.getLabelModel = function() {
return this.model.getModel("axisLabel");
};
Axis2.prototype.getTickModel = function() {
return this.model.getModel("axisTick");
};
Axis2.prototype.getBandWidth = function() {
var axisExtent = this._extent;
var dataExtent = this.scale.getExtent();
var len = dataExtent[1] - dataExtent[0] + (this.onBand ? 1 : 0);
len === 0 && (len = 1);
var size = Math.abs(axisExtent[1] - axisExtent[0]);
return Math.abs(size) / len;
};
Axis2.prototype.calculateCategoryInterval = function() {
return calculateCategoryInterval(this);
};
return Axis2;
}()
);
function fixExtentWithBands(extent, nTick) {
var size = extent[1] - extent[0];
var len = nTick;
var margin = size / len / 2;
extent[0] += margin;
extent[1] -= margin;
}
function fixOnBandTicksCoords(axis, ticksCoords, alignWithLabel, clamp2) {
var ticksLen = ticksCoords.length;
if (!axis.onBand || alignWithLabel || !ticksLen) {
return;
}
var axisExtent = axis.getExtent();
var last;
var diffSize;
if (ticksLen === 1) {
ticksCoords[0].coord = axisExtent[0];
last = ticksCoords[1] = {
coord: axisExtent[1]
};
} else {
var crossLen = ticksCoords[ticksLen - 1].tickValue - ticksCoords[0].tickValue;
var shift_1 = (ticksCoords[ticksLen - 1].coord - ticksCoords[0].coord) / crossLen;
each(ticksCoords, function(ticksItem) {
ticksItem.coord -= shift_1 / 2;
});
var dataExtent = axis.scale.getExtent();
diffSize = 1 + dataExtent[1] - ticksCoords[ticksLen - 1].tickValue;
last = {
coord: ticksCoords[ticksLen - 1].coord + shift_1 * diffSize
};
ticksCoords.push(last);
}
var inverse = axisExtent[0] > axisExtent[1];
if (littleThan(ticksCoords[0].coord, axisExtent[0])) {
clamp2 ? ticksCoords[0].coord = axisExtent[0] : ticksCoords.shift();
}
if (clamp2 && littleThan(axisExtent[0], ticksCoords[0].coord)) {
ticksCoords.unshift({
coord: axisExtent[0]
});
}
if (littleThan(axisExtent[1], last.coord)) {
clamp2 ? last.coord = axisExtent[1] : ticksCoords.pop();
}
if (clamp2 && littleThan(last.coord, axisExtent[1])) {
ticksCoords.push({
coord: axisExtent[1]
});
}
function littleThan(a, b) {
a = round(a);
b = round(b);
return inverse ? a > b : a < b;
}
}
var Axis_default = Axis;
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/coord/axisModelCommonMixin.js
var AxisModelCommonMixin = (
/** @class */
function() {
function AxisModelCommonMixin2() {
}
AxisModelCommonMixin2.prototype.getNeedCrossZero = function() {
var option = this.option;
return !option.scale;
};
AxisModelCommonMixin2.prototype.getCoordSysModel = function() {
return;
};
return AxisModelCommonMixin2;
}()
);
// node_modules/.pnpm/echarts@5.5.1/node_modules/echarts/lib/label/labelLayoutHelper.js
function prepareLayoutList(input) {
var list = [];
for (var i = 0; i < input.length; i++) {
var rawItem = input[i];
if (rawItem.defaultAttr.ignore) {
continue;
}
var label = rawItem.label;
var transform = label.getComputedTransform();
var localRect = label.getBoundingRect();
var isAxisAligned = !transform || transform[1] < 1e-5 && transform[2] < 1e-5;
var minMargin = label.style.margin || 0;
var globalRect = localRect.clone();
globalRect.applyTransform(transform);
globalRect.x -= minMargin / 2;
globalRect.y -= minMargin / 2;
globalRect.width += minMargin;
globalRect.height += minMargin;
var obb = isAxisAligned ? new OrientedBoundingRect_default(localRect, transform) : null;
list.push({
label,
labelLine: rawItem.labelLine,
rect: globalRect,
localRect,
obb,
priority: rawItem.priority,
defaultAttr: rawItem.defaultAttr,
layoutOption: rawItem.computedLayoutOption,
axisAligned: isAxisAligned,
transform
});
}
return list;
}
function shiftLayout(list, xyDim, sizeDim, minBound, maxBound, balanceShift) {
var len = list.length;
if (len < 2) {
return;
}
list.sort(function(a, b) {
return a.rect[xyDim] - b.rect[xyDim];
});
var lastPos = 0;
var delta;
var adjusted = false;
var shifts = [];
var totalShifts = 0;
for (var i = 0; i < len; i++) {
var item = list[i];
var rect = item.rect;
delta = rect[xyDim] - lastPos;
if (delta < 0) {
rect[xyDim] -= delta;
item.label[xyDim] -= delta;
adjusted = true;
}
var shift = Math.max(-delta, 0);
shifts.push(shift);
totalShifts += shift;
lastPos = rect[xyDim] + rect[sizeDim];
}
if (totalShifts > 0 && balanceShift) {
shiftList(-totalShifts / len, 0, len);
}
var first = list[0];
var last = list[len - 1];
var minGap;
var maxGap;
updateMinMaxGap();
minGap < 0 && squeezeGaps(-minGap, 0.8);
maxGap < 0 && squeezeGaps(maxGap, 0.8);
updateMinMaxGap();
takeBoundsGap(minGap, maxGap, 1);
takeBoundsGap(maxGap, minGap, -1);
updateMinMaxGap();
if (minGap < 0) {
squeezeWhenBailout(-minGap);
}
if (maxGap < 0) {
squeezeWhenBailout(maxGap);
}
function updateMinMaxGap() {
minGap = first.rect[xyDim] - minBound;
maxGap = maxBound - last.rect[xyDim] - last.rect[sizeDim];
}
function takeBoundsGap(gapThisBound, gapOtherBound, moveDir) {
if (gapThisBound < 0) {
var moveFromMaxGap = Math.min(gapOtherBound, -gapThisBound);
if (moveFromMaxGap > 0) {
shiftList(moveFromMaxGap * moveDir, 0, len);
var remained = moveFromMaxGap + gapThisBound;
if (remained < 0) {
squeezeGaps(-remained * moveDir, 1);
}
} else {
squeezeGaps(-gapThisBound * moveDir, 1);
}
}
}
function shiftList(delta2, start, end) {
if (delta2 !== 0) {
adjusted = true;
}
for (var i2 = start; i2 < end; i2++) {
var item2 = list[i2];
var rect2 = item2.rect;
rect2[xyDim] += delta2;
item2.label[xyDim] += delta2;
}
}
function squeezeGaps(delta2, maxSqeezePercent) {
var gaps = [];
var totalGaps = 0;
for (var i2 = 1; i2 < len; i2++) {
var prevItemRect = list[i2 - 1].rect;
var gap = Math.max(list[i2].rect[xyDim] - prevItemRect[xyDim] - prevItemRect[sizeDim], 0);
gaps.push(gap);
totalGaps += gap;
}
if (!totalGaps) {
return;
}
var squeezePercent = Math.min(Math.abs(delta2) / totalGaps, maxSqeezePercent);
if (delta2 > 0) {
for (var i2 = 0; i2 < len - 1; i2++) {
var movement = gaps[i2] * squeezePercent;
shiftList(movement, 0, i2 + 1);
}
} else {
for (var i2 = len - 1; i2 > 0; i2--) {
var movement = gaps[i2 - 1] * squeezePercent;
shiftList(-movement, i2, len);
}
}
}
function squeezeWhenBailout(delta2) {
var dir = delta2 < 0 ? -1 : 1;
delta2 = Math.abs(delta2);
var moveForEachLabel = Math.ceil(delta2 / (len - 1));
for (var i2 = 0; i2 < len - 1; i2++) {
if (dir > 0) {
shiftList(moveForEachLabel, 0, i2 + 1);
} else {
shiftList(-moveForEachLabel, len - i2 - 1, len);
}
delta2 -= moveForEachLabel;
if (delta2 <= 0) {
return;
}
}
}
return adjusted;
}
function shiftLayoutOnX(list, leftBound, rightBound, balanceShift) {
return shiftLayout(list, "x", "width", leftBound, rightBound, balanceShift);
}
function shiftLayoutOnY(list, topBound, bottomBound, balanceShift) {
return shiftLayout(list, "y", "height", topBound, bottomBound, balanceShift);
}
function hideOverlap(labelList) {
var displayedLabels = [];
labelList.sort(function(a, b) {
return b.priority - a.priority;
});
var globalRect = new BoundingRect_default(0, 0, 0, 0);
function hideEl(el) {
if (!el.ignore) {
var emphasisState = el.ensureState("emphasis");
if (emphasisState.ignore == null) {
emphasisState.ignore = false;
}
}
el.ignore = true;
}
for (var i = 0; i < labelList.length; i++) {
var labelItem = labelList[i];
var isAxisAligned = labelItem.axisAligned;
var localRect = labelItem.localRect;
var transform = labelItem.transform;
var label = labelItem.label;
var labelLine = labelItem.labelLine;
globalRect.copy(labelItem.rect);
globalRect.width -= 0.1;
globalRect.height -= 0.1;
globalRect.x += 0.05;
globalRect.y += 0.05;
var obb = labelItem.obb;
var overlapped = false;
for (var j = 0; j < displayedLabels.length; j++) {
var existsTextCfg = displayedLabels[j];
if (!globalRect.intersect(existsTextCfg.rect)) {
continue;
}
if (isAxisAligned && existsTextCfg.axisAligned) {
overlapped = true;
break;
}
if (!existsTextCfg.obb) {
existsTextCfg.obb = new OrientedBoundingRect_default(existsTextCfg.localRect, existsTextCfg.transform);
}
if (!obb) {
obb = new OrientedBoundingRect_default(localRect, transform);
}
if (obb.intersect(existsTextCfg.obb)) {
overlapped = true;
break;
}
}
if (overlapped) {
hideEl(label);
labelLine && hideEl(labelLine);
} else {
label.attr("ignore", labelItem.defaultAttr.ignore);
labelLine && labelLine.attr("ignore", labelItem.defaultAttr.labelGuideIgnore);
displayedLabels.push(labelItem);
}
}
}
export {
OrdinalMeta_default,
isValueNice,
isIntervalOrLogScale,
increaseInterval,
Ordinal_default,
Interval_default,
createFloat32Array,
getLayoutOnAxis,
layout,
createProgressiveLayout,
Time_default,
ensureScaleRawExtentInfo,
getScaleExtent,
niceScaleExtent,
createScaleByModel,
ifAxisCrossZero,
getAxisRawValue,
estimateLabelUnionRect,
shouldShowAllLabels,
getDataDimensionsOnAxis,
unionAxisExtentFromData,
AxisModelCommonMixin,
contain,
GeoJSONRegion,
GeoSVGRegion,
parseGeoJSON,
Axis_default,
prepareLayoutList,
shiftLayoutOnX,
shiftLayoutOnY,
hideOverlap
};
//# sourceMappingURL=chunk-TCVRGDT4.js.map