vccs 0.0.1 → 0.2.0

package/dist/es/utils/chart.mjs

@@ -0,0 +1,366 @@
+import { isNan, isNullish, isNumOrStr, isNumber } from "./validate.mjs";
+import { formatAngleOfSector, getAngleOfPoint, polarToCartesian, reverseFormatAngleOfSector } from "./polar.mjs";
+import { findEntryInArray, mathSign } from "./data.mjs";
+import { toRaw } from "vue";
+import { stack, stackOffsetExpand, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderNone } from "victory-vendor/d3-shape";
+import { get, isNaN, sortBy } from "lodash-es";
+//#region src/utils/chart.ts
+/**
+* Get the ticks of an axis
+* @param  {object}  axis The configuration of an axis
+* @param {boolean} isGrid Whether or not are the ticks in grid
+* @param {boolean} isAll Return the ticks of all the points or not
+* @return {Array}  Ticks
+*/
+function getTicksOfAxis(axis, isGrid, isAll) {
+	if (!axis) return null;
+	const { duplicateDomain, type, range, scale, realScaleType, isCategorical, categoricalDomain, tickCount, ticks, niceTicks, axisType } = axis;
+	if (!scale) return null;
+	const offsetForBand = realScaleType === "scaleBand" ? scale.bandwidth() / 2 : 2;
+	let offset = (isGrid || isAll) && type === "category" && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
+	offset = axisType === "angleAxis" && range.length >= 2 ? mathSign(range[0] - range[1]) * 2 * offset : offset;
+	if (isGrid && (ticks || niceTicks)) return (ticks || niceTicks).map((entry, index) => {
+		return {
+			coordinate: scale(duplicateDomain ? duplicateDomain.indexOf(entry) : entry) + offset,
+			value: entry,
+			offset,
+			index
+		};
+	}).filter((row) => !isNaN(row.coordinate));
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	if (scale.ticks && !isAll) return scale.ticks(tickCount).map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		offset,
+		index
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
+	}));
+}
+function getValueByDataKey(obj, dataKey, defaultValue) {
+	if (isNullish(obj) || isNullish(dataKey)) return defaultValue;
+	if (isNumOrStr(dataKey)) return get(toRaw(obj), dataKey, defaultValue);
+	if (typeof dataKey === "function") return dataKey(obj);
+	return defaultValue;
+}
+var MIN_VALUE_REG = /^dataMin\s*-\s*(\d+(\.\d+)?)$/;
+var MAX_VALUE_REG = /^dataMax\s*\+\s*(\d+(\.\d+)?)$/;
+/**
+* Calculate the size between two category
+* @param  {object} axis  The options of axis
+* @param  {Array}  ticks The ticks of axis
+* @param  {boolean} isBar if items in axis are bars
+* @return {number} Size
+*/
+function getBandSizeOfAxis(axis, ticks, isBar) {
+	if (axis && axis.scale && axis.scale.bandwidth) {
+		const bandWidth = axis.scale.bandwidth();
+		if (!isBar || bandWidth > 0) return bandWidth;
+	}
+	if (axis && ticks && ticks.length >= 2) {
+		const orderedTicks = sortBy(ticks, (o) => o.coordinate);
+		let bandSize = Infinity;
+		for (let i = 1, len = orderedTicks.length; i < len; i++) {
+			const cur = orderedTicks[i];
+			const prev = orderedTicks[i - 1];
+			bandSize = Math.min((cur.coordinate || 0) - (prev.coordinate || 0), bandSize);
+		}
+		return bandSize === Infinity ? 0 : bandSize;
+	}
+	return isBar ? void 0 : 0;
+}
+/**
+* Both value and domain are tuples of two numbers
+* - but the type stays as array of numbers until we have better support in rest of the app
+* @param value input that will be truncated
+* @param domain boundaries
+* @returns tuple of two numbers
+*/
+function truncateByDomain(value, domain) {
+	if (!domain || domain.length !== 2 || !isNumber(domain[0]) || !isNumber(domain[1])) return value;
+	const minValue = Math.min(domain[0], domain[1]);
+	const maxValue = Math.max(domain[0], domain[1]);
+	const result = [value[0], value[1]];
+	if (!isNumber(value[0]) || value[0] < minValue) result[0] = minValue;
+	if (!isNumber(value[1]) || value[1] > maxValue) result[1] = maxValue;
+	if (result[0] > maxValue) result[0] = maxValue;
+	if (result[1] < minValue) result[1] = minValue;
+	return result;
+}
+function getNormalizedStackId(publicStackId) {
+	return publicStackId == null ? void 0 : String(publicStackId);
+}
+function getCateCoordinateOfLine({ axis, ticks, bandSize, entry, index, dataKey }) {
+	if (axis.type === "category") {
+		if (!axis.allowDuplicatedCategory && axis.dataKey && !isNullish(entry[axis.dataKey])) {
+			const matchedTick = findEntryInArray(ticks, "value", entry[axis.dataKey]);
+			if (matchedTick) return matchedTick.coordinate + bandSize / 2;
+		}
+		return ticks[index] ? ticks[index].coordinate + bandSize / 2 : null;
+	}
+	const value = getValueByDataKey(entry, !isNullish(dataKey) ? dataKey : axis.dataKey);
+	return !isNullish(value) ? axis.scale(value) : null;
+}
+function getChartPointer(event) {
+	const target = event.currentTarget;
+	const rect = target.getBoundingClientRect();
+	const scaleX = rect.width / target.offsetWidth;
+	const scaleY = rect.height / target.offsetHeight;
+	return {
+		chartX: Math.round((event.clientX - rect.left) / scaleX),
+		chartY: Math.round((event.clientY - rect.top) / scaleY)
+	};
+}
+function getTooltipEntry({ tooltipEntrySettings, dataKey, payload, value, name }) {
+	return {
+		...tooltipEntrySettings,
+		dataKey,
+		payload,
+		value,
+		name
+	};
+}
+function calculateTooltipPos(rangeObj, layout) {
+	if (layout === "horizontal") return rangeObj.x;
+	if (layout === "vertical") return rangeObj.y;
+	if (layout === "centric") return rangeObj.angle;
+	return rangeObj.radius;
+}
+function inRangeOfSector({ x, y }, viewBox) {
+	const { radius, angle } = getAngleOfPoint({
+		x,
+		y
+	}, viewBox);
+	const { innerRadius, outerRadius } = viewBox;
+	if (radius < innerRadius || radius > outerRadius) return null;
+	if (radius === 0) return null;
+	const { startAngle, endAngle } = formatAngleOfSector(viewBox);
+	let formatAngle = angle;
+	let inRange;
+	if (startAngle <= endAngle) {
+		while (formatAngle > endAngle) formatAngle -= 360;
+		while (formatAngle < startAngle) formatAngle += 360;
+		inRange = formatAngle >= startAngle && formatAngle <= endAngle;
+	} else {
+		while (formatAngle > startAngle) formatAngle -= 360;
+		while (formatAngle < endAngle) formatAngle += 360;
+		inRange = formatAngle >= endAngle && formatAngle <= startAngle;
+	}
+	if (inRange) return {
+		...viewBox,
+		radius,
+		angle: reverseFormatAngleOfSector(formatAngle, viewBox)
+	};
+	return null;
+}
+function inRange(x, y, layout, polarViewBox, offset) {
+	if (layout === "horizontal" || layout === "vertical") return x >= offset.left && x <= offset.left + offset.width && y >= offset.top && y <= offset.top + offset.height ? {
+		x,
+		y
+	} : null;
+	if (polarViewBox) return inRangeOfSector({
+		x,
+		y
+	}, polarViewBox);
+	return null;
+}
+function calculateActiveTickIndex(coordinate, ticks, unsortedTicks, axisType, range) {
+	let index = -1;
+	const len = ticks?.length ?? 0;
+	if (len <= 1) return 0;
+	if (axisType === "angleAxis" && range != null && Math.abs(Math.abs(range[1] - range[0]) - 360) <= 1e-6) for (let i = 0; i < len; i++) {
+		const before = i > 0 ? unsortedTicks[i - 1].coordinate : unsortedTicks[len - 1].coordinate;
+		const cur = unsortedTicks[i].coordinate;
+		const after = i >= len - 1 ? unsortedTicks[0].coordinate : unsortedTicks[i + 1].coordinate;
+		let sameDirectionCoord;
+		if (mathSign(cur - before) !== mathSign(after - cur)) {
+			const diffInterval = [];
+			if (mathSign(after - cur) === mathSign(range[1] - range[0])) {
+				sameDirectionCoord = after;
+				const curInRange = cur + range[1] - range[0];
+				diffInterval[0] = Math.min(curInRange, (curInRange + before) / 2);
+				diffInterval[1] = Math.max(curInRange, (curInRange + before) / 2);
+			} else {
+				sameDirectionCoord = before;
+				const afterInRange = after + range[1] - range[0];
+				diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2);
+				diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
+			}
+			const sameInterval = [Math.min(cur, (sameDirectionCoord + cur) / 2), Math.max(cur, (sameDirectionCoord + cur) / 2)];
+			if (coordinate > sameInterval[0] && coordinate <= sameInterval[1] || coordinate >= diffInterval[0] && coordinate <= diffInterval[1]) {
+				index = unsortedTicks[i].index;
+				break;
+			}
+		} else {
+			const minValue = Math.min(before, after);
+			const maxValue = Math.max(before, after);
+			if (coordinate > (minValue + cur) / 2 && coordinate <= (maxValue + cur) / 2) {
+				index = unsortedTicks[i].index;
+				break;
+			}
+		}
+	}
+	else for (let i = 0; i < len; i++) if (i === 0 && coordinate <= (ticks[i].coordinate + ticks[i + 1].coordinate) / 2 || i > 0 && i < len - 1 && coordinate > (ticks[i].coordinate + ticks[i - 1].coordinate) / 2 && coordinate <= (ticks[i].coordinate + ticks[i + 1].coordinate) / 2 || i === len - 1 && coordinate > (ticks[i].coordinate + ticks[i - 1].coordinate) / 2) {
+		index = ticks[i].index;
+		break;
+	}
+	return index;
+}
+function getActiveCoordinate(layout, tooltipTicks, activeIndex, rangeObj) {
+	const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+	if (entry) {
+		if (layout === "horizontal") return {
+			x: entry.coordinate,
+			y: rangeObj.y
+		};
+		if (layout === "vertical") return {
+			x: rangeObj.x,
+			y: entry.coordinate
+		};
+		if (layout === "centric") {
+			const angle = entry.coordinate;
+			const { radius } = rangeObj;
+			return {
+				...rangeObj,
+				...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+				angle,
+				radius
+			};
+		}
+		const radius = entry.coordinate;
+		const { angle } = rangeObj;
+		return {
+			...rangeObj,
+			...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+			angle,
+			radius
+		};
+	}
+	return {
+		x: 0,
+		y: 0
+	};
+}
+function makeDomainFinite(domain) {
+	return [domain[0] === Infinity ? 0 : domain[0], domain[1] === -Infinity ? 0 : domain[1]];
+}
+function getDomainOfSingle(data) {
+	const flat = data.flat(2).filter(isNumber);
+	return [Math.min(...flat), Math.max(...flat)];
+}
+function getDomainOfStackGroups(stackGroups, startIndex, endIndex) {
+	if (stackGroups == null) return;
+	return makeDomainFinite(Object.keys(stackGroups).reduce((result, stackId) => {
+		const { stackedData } = stackGroups[stackId];
+		const domain = stackedData.reduce((res, entry) => {
+			const s = getDomainOfSingle(entry.slice(startIndex, endIndex + 1));
+			return [Math.min(res[0], s[0]), Math.max(res[1], s[1])];
+		}, [Infinity, -Infinity]);
+		return [Math.min(domain[0], result[0]), Math.max(domain[1], result[1])];
+	}, [Infinity, -Infinity]));
+}
+var EPS = 1e-4;
+function checkDomainOfScale(scale) {
+	const domain = scale.domain();
+	if (!domain || domain.length <= 2) return;
+	const len = domain.length;
+	const range = scale.range();
+	const minValue = Math.min(range[0], range[1]) - EPS;
+	const maxValue = Math.max(range[0], range[1]) + EPS;
+	const first = scale(domain[0]);
+	const last = scale(domain[len - 1]);
+	if (first < minValue || first > maxValue || last < minValue || last > maxValue) scale.domain([domain[0], domain[len - 1]]);
+}
+function getTooltipNameProp(nameFromItem, dataKey) {
+	if (nameFromItem) return String(nameFromItem);
+	if (typeof dataKey === "string") return dataKey;
+}
+function isClipDot(dot) {
+	if (dot && typeof dot === "object" && "clipDot" in dot) return Boolean(dot.clipDot);
+	return true;
+}
+var offsetSign = (series) => {
+	const n = series.length;
+	if (n <= 0) return;
+	for (let j = 0, m = series[0].length; j < m; ++j) {
+		let positive = 0;
+		let negative = 0;
+		for (let i = 0; i < n; ++i) {
+			const value = isNan(series[i][j][1]) ? series[i][j][0] : series[i][j][1];
+			if (value >= 0) {
+				series[i][j][0] = positive;
+				series[i][j][1] = positive + value;
+				positive = series[i][j][1];
+			} else {
+				series[i][j][0] = negative;
+				series[i][j][1] = negative + value;
+				negative = series[i][j][1];
+			}
+		}
+	}
+};
+/**
+* Replaces all negative values with zero when stacking data.
+*
+* If all values in the series are positive then this behaves the same as 'none' stacker.
+*
+* @param {Array} series from d3-shape Stack
+* @return {Array} series with applied offset
+*/
+var offsetPositive = (series) => {
+	const n = series.length;
+	if (n <= 0) return;
+	for (let j = 0, m = series[0].length; j < m; ++j) {
+		let positive = 0;
+		for (let i = 0; i < n; ++i) {
+			const value = isNan(series[i][j][1]) ? series[i][j][0] : series[i][j][1];
+			if (value >= 0) {
+				series[i][j][0] = positive;
+				series[i][j][1] = positive + value;
+				positive = series[i][j][1];
+			} else {
+				series[i][j][0] = 0;
+				series[i][j][1] = 0;
+			}
+		}
+	}
+};
+var STACK_OFFSET_MAP = {
+	sign: offsetSign,
+	expand: stackOffsetExpand,
+	none: stackOffsetNone,
+	silhouette: stackOffsetSilhouette,
+	wiggle: stackOffsetWiggle,
+	positive: offsetPositive
+};
+function getStackedData(data, dataKeys, offsetType) {
+	const offsetAccessor = STACK_OFFSET_MAP[offsetType];
+	return stack().keys(dataKeys).value((d, key) => +getValueByDataKey(d, key, 0)).order(stackOrderNone).offset(offsetAccessor)(data);
+}
+function getBaseValueOfBar({ numericAxis }) {
+	const domain = numericAxis.scale.domain();
+	if (numericAxis.type === "number") {
+		const minValue = Math.min(domain[0], domain[1]);
+		const maxValue = Math.max(domain[0], domain[1]);
+		if (minValue <= 0 && maxValue >= 0) return 0;
+		if (maxValue < 0) return maxValue;
+		return minValue;
+	}
+	return domain[0];
+}
+function getCateCoordinateOfBar({ axis, ticks, offset, bandSize, entry, index }) {
+	if (axis.type === "category") return ticks[index] ? ticks[index].coordinate + offset : null;
+	const value = getValueByDataKey(entry, axis.dataKey, axis.scale.domain()[index]);
+	return !isNullish(value) ? axis.scale(value) - bandSize / 2 + offset : null;
+}
+//#endregion
+export { MAX_VALUE_REG, MIN_VALUE_REG, calculateActiveTickIndex, calculateTooltipPos, checkDomainOfScale, getActiveCoordinate, getBandSizeOfAxis, getBaseValueOfBar, getCateCoordinateOfBar, getCateCoordinateOfLine, getChartPointer, getDomainOfStackGroups, getNormalizedStackId, getStackedData, getTicksOfAxis, getTooltipEntry, getTooltipNameProp, getValueByDataKey, inRange, isClipDot, truncateByDomain };

package/dist/es/utils/const.mjs

@@ -0,0 +1,32 @@
+//#region src/utils/const.ts
+/**
+* We use this attribute to identify which element is the one that the user is touching.
+* The index is the position of the element in the data array.
+* This can be either a number (for array-based charts) or a string (for the charts that have a matrix-shaped data).
+*/
+var DATA_ITEM_INDEX_ATTRIBUTE_NAME = "data-recharts-item-index";
+/**
+* We use this attribute to identify which element is the one that the user is touching.
+* DataKey works here as a kind of identifier for the element. It's not a perfect identifier for ~two~ three reasons:
+*
+* 1. There can be two different elements with the same dataKey; we won't know which is it
+* 2. DataKey can be a function, and that serialized will be a `[Function: anonymous]` string
+* which means we will be able to identify that it was a function but can't tell which one.
+* This will lead to some weird bugs. A proper fix would be to either:
+* a) use a unique identifier for each element (passed from props, or generated)
+* b) figure out how to compare the dataKey or graphical item by object reference
+*
+* a) is a fuss because we don't have the unique identifier in props,
+* and b) is possible most of the time except for touchMove events which work differently from mouseEnter/mouseLeave:
+* - while mouseEnter is fired for the element that the mouse is over,
+* touchMove is fired for the element where user has started touching. As the finger moves,
+* we can identify the element that the user is touching by using the elementFromPoint method,
+* but it keeps calling the handler on the element where touchStart was fired.
+*
+* Okay and now I discovered a third reason: the dataKey can be undefined and that's still fine
+* because if dataKey is undefined then graphical elements assume the dataKey of the axes.
+* Which makes it a convenient way of using recharts to render a chart but horrible identifier.
+*/
+var DATA_ITEM_DATAKEY_ATTRIBUTE_NAME = "data-recharts-item-data-key";
+//#endregion
+export { DATA_ITEM_DATAKEY_ATTRIBUTE_NAME, DATA_ITEM_INDEX_ATTRIBUTE_NAME };

package/dist/es/utils/createContext.mjs

@@ -0,0 +1,31 @@
+import { inject, provide } from "vue";
+//#region src/utils/createContext.ts
+/**
+* @param providerComponentName - The name(s) of the component(s) providing the context.
+*
+* There are situations where context can come from multiple components. In such cases, you might need to give an array of component names to provide your context, instead of just a single string.
+*
+* @param contextName The description for injection key symbol.
+*/
+function createContext(contextName) {
+	const symbolDescription = contextName;
+	const injectionKey = Symbol(symbolDescription);
+	/**
+	* @param fallback The context value to return if the injection fails.
+	*
+	* @throws When context injection failed and no fallback is specified.
+	* This happens when the component injecting the context is not a child of the root component providing the context.
+	*/
+	const injectContext = (fallback) => {
+		const context = inject(injectionKey, fallback);
+		if (context === void 0) throw new Error(`Injection \`${injectionKey.toString()}\` not found. Component must be used within ${`\`${contextName}\``}`);
+		return context;
+	};
+	const provideContext = (contextValue) => {
+		provide(injectionKey, contextValue);
+		return contextValue;
+	};
+	return [injectContext, provideContext];
+}
+//#endregion
+export { createContext };

package/dist/es/utils/data-utils.mjs

@@ -0,0 +1,13 @@
+import { isNumber } from "./validate.mjs";
+//#region src/utils/data-utils.ts
+var idCounter = 0;
+function uniqueId(prefix) {
+	const id = ++idCounter;
+	return `${prefix || ""}${id}`;
+}
+function interpolate(start, end, t) {
+	if (isNumber(start) && isNumber(end)) return start + t * (end - start);
+	return end;
+}
+//#endregion
+export { interpolate, uniqueId };

package/dist/es/utils/data.mjs

@@ -0,0 +1,41 @@
+import { isNan, isNumber, isPercent } from "./validate.mjs";
+import { get } from "lodash-es";
+//#region src/utils/data.ts
+function mathSign(value) {
+	if (value === 0) return 0;
+	if (value > 0) return 1;
+	return -1;
+}
+function hasDuplicate(ary) {
+	if (!Array.isArray(ary)) return false;
+	const len = ary.length;
+	const cache = {};
+	for (let i = 0; i < len; i++) if (!cache[ary[i]]) cache[ary[i]] = true;
+	else return true;
+	return false;
+}
+/**
+* Get percent value of a total value
+* @param {number|string} percent A percent
+* @param {number} totalValue     Total value
+* @param {number} defaultValue   The value returned when percent is undefined or invalid
+* @param {boolean} validate      If set to be true, the result will be validated
+* @return {number} value
+*/
+function getPercentValue(percent, totalValue, defaultValue = 0, validate = false) {
+	if (!isNumber(percent) && typeof percent !== "string") return defaultValue;
+	let value;
+	if (isPercent(percent)) {
+		const index = percent.indexOf("%");
+		value = totalValue * parseFloat(percent.slice(0, index)) / 100;
+	} else value = +percent;
+	if (isNan(value)) value = defaultValue;
+	if (validate && value > totalValue) value = totalValue;
+	return value;
+}
+function findEntryInArray(ary, specifiedKey, specifiedValue) {
+	if (!ary || !ary.length) return null;
+	return ary.find((entry) => entry && (typeof specifiedKey === "function" ? specifiedKey(entry) : get(entry, specifiedKey)) === specifiedValue);
+}
+//#endregion
+export { findEntryInArray, getPercentValue, hasDuplicate, mathSign };

package/dist/es/utils/events.mjs

@@ -0,0 +1,7 @@
+import EventEmitter from "eventemitter3";
+//#region src/utils/events.ts
+var eventCenter = new EventEmitter();
+var TOOLTIP_SYNC_EVENT = "recharts.syncEvent.tooltip";
+var BRUSH_SYNC_EVENT = "recharts.syncEvent.brush";
+//#endregion
+export { BRUSH_SYNC_EVENT, TOOLTIP_SYNC_EVENT, eventCenter };

package/dist/es/utils/getLinearRegression.mjs

@@ -0,0 +1,34 @@
+//#region src/utils/getLinearRegression.ts
+/**
+* The least square linear regression
+* @param data The array of points
+* @returns The domain of x, and the parameter of linear function y = ax + b
+*/
+function getLinearRegression(data) {
+	const len = data.length;
+	let xsum = 0;
+	let ysum = 0;
+	let xysum = 0;
+	let xxsum = 0;
+	let xmin = Infinity;
+	let xmax = -Infinity;
+	for (let i = 0; i < len; i++) {
+		const xcurrent = data[i]?.cx || 0;
+		const ycurrent = data[i]?.cy || 0;
+		xsum += xcurrent;
+		ysum += ycurrent;
+		xysum += xcurrent * ycurrent;
+		xxsum += xcurrent * xcurrent;
+		xmin = Math.min(xmin, xcurrent);
+		xmax = Math.max(xmax, xcurrent);
+	}
+	const a = len * xxsum !== xsum * xsum ? (len * xysum - xsum * ysum) / (len * xxsum - xsum * xsum) : 0;
+	return {
+		xmin,
+		xmax,
+		a,
+		b: (ysum - a * xsum) / len
+	};
+}
+//#endregion
+export { getLinearRegression };

package/dist/es/utils/grid.mjs

@@ -0,0 +1,23 @@
+//#region src/utils/grid.ts
+/**
+* Calculate the Coordinates of grid
+* @param  {Array} ticks           The ticks in axis
+* @param {number} minValue        The minimum value of axis
+* @param {number} maxValue        The maximum value of axis
+* @param {boolean} syncWithTicks  Synchronize grid lines with ticks or not
+* @return {Array}                 Coordinates
+*/
+function getCoordinatesOfGrid(ticks, minValue, maxValue, syncWithTicks) {
+	if (syncWithTicks) return ticks.map((entry) => entry.coordinate);
+	let hasMin, hasMax;
+	const values = ticks.map((entry) => {
+		if (entry.coordinate === minValue) hasMin = true;
+		if (entry.coordinate === maxValue) hasMax = true;
+		return entry.coordinate;
+	});
+	if (!hasMin) values.push(minValue);
+	if (!hasMax) values.push(maxValue);
+	return values;
+}
+//#endregion
+export { getCoordinatesOfGrid };

package/dist/es/utils/isDomainSpecifiedByUser.mjs

@@ -0,0 +1,116 @@
+import { isNumber, isWellBehavedNumber } from "./validate.mjs";
+import { MAX_VALUE_REG, MIN_VALUE_REG } from "./chart.mjs";
+//#region src/utils/isDomainSpecifiedByUser.ts
+function isWellFormedNumberDomain(v) {
+	if (Array.isArray(v) && v.length === 2) {
+		const [min, max] = v;
+		if (isWellBehavedNumber(min) && isWellBehavedNumber(max)) return true;
+	}
+	return false;
+}
+function extendDomain(providedDomain, boundaryDomain, allowDataOverflow) {
+	if (allowDataOverflow) return providedDomain;
+	return [Math.min(providedDomain[0], boundaryDomain[0]), Math.max(providedDomain[1], boundaryDomain[1])];
+}
+/**
+* So Recharts allows users to provide their own domains,
+* but it also places some expectations on what the domain is.
+* We can improve on the typescript typing, but we also need a runtime test
+to observe that the user-provided domain is well-formed,
+* that is: an array with exactly two numbers.
+*
+* This function does not accept data as an argument.
+* This is to enable a performance optimization - if the domain is there,
+* and we know what it is without traversing all the data,
+* then we don't have to traverse all the data!
+*
+* If the user-provided domain is not well-formed,
+* this function will return undefined - in which case we should traverse the data to calculate the real domain.
+*
+* This function is for parsing the numerical domain only.
+*
+* @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+* @param allowDataOverflow boolean, provided by users. If true then the data domain wins
+*
+* @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+*/
+function numericalDomainSpecifiedWithoutRequiringData(userDomain, allowDataOverflow) {
+	if (!allowDataOverflow) return;
+	if (typeof userDomain === "function") return;
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax;
+		if (isWellBehavedNumber(providedMin)) finalMin = providedMin;
+		else if (typeof providedMin === "function") return;
+		if (isWellBehavedNumber(providedMax)) finalMax = providedMax;
+		else if (typeof providedMax === "function") return;
+		const candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) return candidate;
+	}
+}
+/**
+* So Recharts allows users to provide their own domains,
+* but it also places some expectations on what the domain is.
+* We can improve on the typescript typing, but we also need a runtime test
+* to observe that the user-provided domain is well-formed,
+* that is: an array with exactly two numbers.
+* If the user-provided domain is not well-formed,
+* this function will return undefined - in which case we should traverse the data to calculate the real domain.
+*
+* This function is for parsing the numerical domain only.
+*
+* You are probably thinking, why does domain need tick count?
+* Well it adjusts the domain based on where the "nice ticks" land, and nice ticks depend on the tick count.
+*
+* @param userDomain external prop, user provided, before validation. Can have various shapes: array, function, special magical strings inside too.
+* @param dataDomain calculated from data. Can be undefined, as an option for performance optimization
+* @param allowDataOverflow provided by users. If true then the data domain wins
+*
+* @return [min, max] domain if it's well-formed; undefined if the domain is invalid
+*/
+function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
+	if (!allowDataOverflow && dataDomain == null) return;
+	if (typeof userDomain === "function" && dataDomain != null) try {
+		const result = userDomain(dataDomain, allowDataOverflow);
+		if (isWellFormedNumberDomain(result)) return extendDomain(result, dataDomain, allowDataOverflow);
+	} catch {}
+	if (Array.isArray(userDomain) && userDomain.length === 2) {
+		const [providedMin, providedMax] = userDomain;
+		let finalMin, finalMax;
+		if (providedMin === "auto") {
+			if (dataDomain != null) finalMin = Math.min(...dataDomain);
+		} else if (isNumber(providedMin)) finalMin = providedMin;
+		else if (typeof providedMin === "function") try {
+			if (dataDomain != null) finalMin = providedMin(dataDomain?.[0]);
+		} catch {}
+		else if (typeof providedMin === "string" && MIN_VALUE_REG.test(providedMin)) {
+			const match = MIN_VALUE_REG.exec(providedMin);
+			if (match == null || dataDomain == null) finalMin = void 0;
+			else {
+				const value = +match[1];
+				finalMin = dataDomain[0] - value;
+			}
+		} else finalMin = dataDomain?.[0];
+		if (providedMax === "auto") {
+			if (dataDomain != null) finalMax = Math.max(...dataDomain);
+		} else if (isNumber(providedMax)) finalMax = providedMax;
+		else if (typeof providedMax === "function") try {
+			if (dataDomain != null) finalMax = providedMax(dataDomain?.[1]);
+		} catch {}
+		else if (typeof providedMax === "string" && MAX_VALUE_REG.test(providedMax)) {
+			const match = MAX_VALUE_REG.exec(providedMax);
+			if (match == null || dataDomain == null) finalMax = void 0;
+			else {
+				const value = +match[1];
+				finalMax = dataDomain[1] + value;
+			}
+		} else finalMax = dataDomain?.[1];
+		const candidate = [finalMin, finalMax];
+		if (isWellFormedNumberDomain(candidate)) {
+			if (dataDomain == null) return candidate;
+			return extendDomain(candidate, dataDomain, allowDataOverflow);
+		}
+	}
+}
+//#endregion
+export { isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain };