vccs 0.6.0 → 1.0.0-beta.2

package/dist/es/core/axis/position.mjs

@@ -0,0 +1,51 @@
+import { registeredAxes } from "../layout.mjs";
+import { sameAxis } from "./key.mjs";
+//#region src/core/axis/position.ts
+function xAxisPosition(axes, axis, offset, height, id) {
+	const peers = registeredAxes(axes).filter((a) => a.orientation === axis.orientation && a.mirror === axis.mirror).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+	let position = axis.orientation === "top" ? offset.top : height - offset.bottom;
+	const before = axis.orientation === "top" && !axis.mirror || axis.orientation === "bottom" && axis.mirror;
+	for (const peer of peers) {
+		if (sameAxis(peer.id, id)) return {
+			x: offset.left,
+			y: position - Number(before) * peer.height
+		};
+		position += (before ? -1 : 1) * peer.height;
+	}
+	return {
+		x: offset.left,
+		y: 0
+	};
+}
+function yAxisPosition(axes, axis, offset, width, id) {
+	const peers = registeredAxes(axes).filter((a) => a.orientation === axis.orientation && a.mirror === axis.mirror).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+	let position = axis.orientation === "left" ? offset.left : width - offset.right;
+	const before = axis.orientation === "left" && !axis.mirror || axis.orientation === "right" && axis.mirror;
+	for (const peer of peers) {
+		const size = typeof peer.width === "number" ? peer.width : 60;
+		if (sameAxis(peer.id, id)) return {
+			x: position - Number(before) * size,
+			y: offset.top
+		};
+		position += (before ? -1 : 1) * size;
+	}
+	return {
+		x: 0,
+		y: offset.top
+	};
+}
+function gridAxis(axis, layout, type, categoricalDomain, duplicateDomain, niceTicks, range, realScaleType, scale) {
+	return {
+		...axis,
+		axisType: type,
+		categoricalDomain,
+		duplicateDomain,
+		isCategorical: layout === "horizontal" ? type === "xAxis" : type === "yAxis",
+		niceTicks,
+		range,
+		realScaleType,
+		scale
+	};
+}
+//#endregion
+export { gridAxis, xAxisPosition, yAxisPosition };

package/dist/es/core/axis/range.mjs

@@ -0,0 +1,46 @@
+import { isWellBehavedNumber } from "../../utils/validate.mjs";
+import { getPercentValue } from "../../utils/data.mjs";
+import { onlyAllowNumbers } from "./data.mjs";
+//#region src/core/axis/range.ts
+function smallestDistance(data, axis) {
+	if (axis.type !== "number") return void 0;
+	const values = [...onlyAllowNumbers(data.map((d) => d.value))].sort((a, b) => a - b);
+	const span = values[values.length - 1] - values[0];
+	if (values.length < 2 || span === 0) return Infinity;
+	let distance = Infinity;
+	for (let i = 0; i < values.length - 1; i++) distance = Math.min(distance, values[i + 1] - values[i]);
+	return distance / span;
+}
+function calculatedPadding(distance, layout, gap, offset, padding) {
+	if (!isWellBehavedNumber(distance)) return 0;
+	const width = layout === "vertical" ? offset.height : offset.width;
+	const halfBand = distance * width / 2;
+	if (padding === "gap") return halfBand;
+	if (padding === "no-gap") {
+		const space = getPercentValue(gap, distance * width);
+		return halfBand - space - (halfBand - space) / width * space;
+	}
+	return 0;
+}
+function axisRangeWithReverse(axis, range) {
+	if (!axis || !range) return void 0;
+	return axis.reversed ? [range[1], range[0]] : range;
+}
+function xAxisRange(offset, padding, calculated) {
+	const sides = typeof padding === "string" ? {
+		left: calculated,
+		right: calculated
+	} : padding;
+	return [offset.left + (sides.left ?? 0), offset.left + offset.width - (sides.right ?? 0)];
+}
+function yAxisRange(offset, layout, padding, calculated) {
+	const sides = typeof padding === "string" ? {
+		top: calculated,
+		bottom: calculated
+	} : padding;
+	const top = offset.top + (sides.top ?? 0);
+	const bottom = offset.top + offset.height - (sides.bottom ?? 0);
+	return layout === "horizontal" ? [bottom, top] : [top, bottom];
+}
+//#endregion
+export { axisRangeWithReverse, calculatedPadding, smallestDistance, xAxisRange, yAxisRange };

package/dist/es/core/axis/references.mjs

@@ -0,0 +1,26 @@
+import { sameAxis } from "./key.mjs";
+import { onlyAllowNumbers } from "./data.mjs";
+//#region src/core/axis/references.ts
+function filterReferenceElements(elements, axisType, axisId) {
+	return elements.filter((el) => el.ifOverflow === "extendDomain").filter((el) => {
+		if (axisType === "xAxis") return sameAxis(el.xAxisId, axisId);
+		return sameAxis(el.yAxisId, axisId);
+	});
+}
+function dotsDomain(dots, axisType) {
+	const allCoords = onlyAllowNumbers((dots ?? []).map((dot) => axisType === "xAxis" ? dot.x : dot.y));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+function areasDomain(areas, axisType) {
+	const allCoords = onlyAllowNumbers((areas ?? []).flatMap((area) => [axisType === "xAxis" ? area.x1 : area.y1, axisType === "xAxis" ? area.x2 : area.y2]));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+function linesDomain(lines, axisType) {
+	const allCoords = onlyAllowNumbers((lines ?? []).map((line) => axisType === "xAxis" ? line.x : line.y));
+	if (allCoords.length === 0) return;
+	return [Math.min(...allCoords), Math.max(...allCoords)];
+}
+//#endregion
+export { areasDomain, dotsDomain, filterReferenceElements, linesDomain };

package/dist/es/core/axis/scale.mjs

@@ -0,0 +1,148 @@
+import { flushTiny, isCategoricalAxis } from "../../utils/validate.mjs";
+import { hasDuplicate, mathSign } from "../../utils/data.mjs";
+import { isWellFormedNumberDomain } from "./userDomain.mjs";
+import { getNiceTickValues, getTickValuesFixedDomain } from "../../utils/scale/getNiceTickValues.mjs";
+import { getDomainDefinition } from "./domain.mjs";
+import { sortBy, upperFirst } from "es-toolkit/compat";
+import * as d3Scales from "d3-scale";
+//#region src/core/axis/scale.ts
+function realScaleType(axisConfig, hasBar, categoryScale) {
+	if (axisConfig == null) return;
+	const { scale, type } = axisConfig;
+	if (scale === "auto") {
+		if (type === "category" && (categoryScale === "point" || categoryScale === "auto" && !hasBar)) return "point";
+		if (type === "category") return "band";
+		return "linear";
+	}
+	if (typeof scale === "string") {
+		const name = `scale${upperFirst(scale)}`;
+		return name in d3Scales ? name : "point";
+	}
+}
+function getD3ScaleFromType(realScaleType) {
+	if (realScaleType == null) return;
+	if (realScaleType in d3Scales) {
+		const factory = d3Scales[realScaleType];
+		return typeof factory === "function" ? factory() : void 0;
+	}
+	const name = `scale${upperFirst(realScaleType)}`;
+	if (name in d3Scales) {
+		const factory = d3Scales[name];
+		return typeof factory === "function" ? factory() : void 0;
+	}
+}
+function guardScale(scale) {
+	return new Proxy(scale, { apply(target, thisArg, args) {
+		const value = args[0];
+		if (typeof value === "object" && value !== null && typeof value.valueOf !== "function") return void 0;
+		return Reflect.apply(target, thisArg, args);
+	} });
+}
+function scaleFunction(axis, realScaleType, axisDomain, axisRange) {
+	if (axis == null || axisDomain == null || axisRange == null) return;
+	if (typeof axis.scale === "function") return guardScale(axis.scale.copy().domain(axisDomain).range(axisRange));
+	const d3ScaleFunction = getD3ScaleFromType(realScaleType);
+	if (d3ScaleFunction == null) return;
+	const domain = axisDomain.map((value) => typeof value === "number" ? flushTiny(value) : value);
+	const scale = d3ScaleFunction.domain(domain).range(axisRange);
+	checkDomainOfScale(scale);
+	return guardScale(scale);
+}
+function niceTicks(axisDomain, axisSettings, realScaleType) {
+	const domainDefinition = getDomainDefinition(axisSettings);
+	if (realScaleType !== "auto" && realScaleType !== "linear") return;
+	if (axisSettings != null && axisSettings.tickCount && Array.isArray(domainDefinition) && (domainDefinition[0] === "auto" || domainDefinition[1] === "auto") && isWellFormedNumberDomain(axisDomain)) return getNiceTickValues(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+	if (axisSettings != null && axisSettings.tickCount && axisSettings.type === "number" && axisDomain != null) return getTickValuesFixedDomain(axisDomain, axisSettings.tickCount, axisSettings.allowDecimals);
+}
+function axisDomainWithNiceTicks(axisSettings, domain, niceTicks, axisType) {
+	if (axisType !== "angleAxis" && axisSettings?.type === "number" && isWellFormedNumberDomain(domain) && Array.isArray(niceTicks) && niceTicks.length > 0) {
+		const minFromDomain = domain[0];
+		const minFromTicks = niceTicks[0];
+		const maxFromDomain = domain[1];
+		const maxFromTicks = niceTicks[niceTicks.length - 1];
+		return [Math.min(minFromDomain, minFromTicks), Math.max(maxFromDomain, maxFromTicks)];
+	}
+	return domain;
+}
+function sortBy$1(a, b) {
+	const aNum = Number(a);
+	const bNum = Number(b);
+	if (Number.isNaN(aNum) && Number.isNaN(bNum)) return 0;
+	if (Number.isNaN(aNum)) return -1;
+	if (Number.isNaN(bNum)) return 1;
+	return aNum - bNum;
+}
+function duplicateDomain(chartLayout, appliedValues, axis, axisType) {
+	if (axis == null) return;
+	const { allowDuplicatedCategory, type, dataKey } = axis;
+	const isCategorical = isCategoricalAxis(chartLayout, axisType);
+	const allData = appliedValues.map((av) => av.value);
+	if (dataKey && isCategorical && type === "category" && allowDuplicatedCategory && hasDuplicate(allData)) return allData;
+}
+function categoricalDomain(layout, appliedValues, axis, axisType) {
+	if (axis == null || axis.dataKey == null) return;
+	const { type, scale } = axis;
+	if (isCategoricalAxis(layout, axisType) && (type === "number" || scale !== "auto")) return appliedValues.map((d) => d.value);
+}
+function graphicalItemTicks(layout, axis, scale, axisRange, duplicateDomain, categoricalDomain, axisType) {
+	if (axis == null || scale == null || axisRange == null || axisRange[0] === axisRange[1]) return null;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	const { tickCount } = axis;
+	let offset = 0;
+	offset = axisType === "angleAxis" && axisRange?.length >= 2 ? mathSign(axisRange[0] - axisRange[1]) * 2 * offset : offset;
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	if (scale.ticks) return scale.ticks(tickCount).map((entry) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		offset
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
+	}));
+}
+function inverseTickScale(ticks) {
+	if (!ticks?.length) return void 0;
+	return function snap(pixel) {
+		let closest = ticks[0];
+		for (const tick of ticks) if (Math.abs(tick.coordinate - pixel) < Math.abs(closest.coordinate - pixel)) closest = tick;
+		return closest.value;
+	};
+}
+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;
+}
+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(Number(range[0]), Number(range[1])) - 1e-4;
+	const maxValue = Math.max(Number(range[0]), Number(range[1])) + 1e-4;
+	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]]);
+}
+//#endregion
+export { axisDomainWithNiceTicks, categoricalDomain, checkDomainOfScale, duplicateDomain, getBandSizeOfAxis, graphicalItemTicks, inverseTickScale, niceTicks, realScaleType, scaleFunction, sortBy$1 as sortBy };

package/dist/es/core/axis/settings.mjs

@@ -0,0 +1,76 @@
+import { defaultNumericDomain } from "./domain.mjs";
+//#region src/core/axis/settings.ts
+var implicitXAxis = {
+	allowDataOverflow: false,
+	allowDecimals: true,
+	allowDuplicatedCategory: true,
+	angle: 0,
+	dataKey: void 0,
+	domain: void 0,
+	height: 30,
+	hide: true,
+	id: void 0,
+	includeHidden: false,
+	interval: "preserveEnd",
+	minTickGap: 5,
+	mirror: false,
+	name: void 0,
+	orientation: "bottom",
+	padding: {
+		left: 0,
+		right: 0
+	},
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickCount: 5,
+	tickFormatter: void 0,
+	ticks: void 0,
+	type: "category",
+	unit: void 0
+};
+var implicitYAxis = {
+	allowDataOverflow: false,
+	allowDecimals: true,
+	allowDuplicatedCategory: true,
+	angle: 0,
+	dataKey: void 0,
+	domain: defaultNumericDomain,
+	hide: true,
+	id: void 0,
+	includeHidden: false,
+	interval: "preserveEnd",
+	minTickGap: 5,
+	mirror: false,
+	name: void 0,
+	orientation: "left",
+	padding: {
+		top: 0,
+		bottom: 0
+	},
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickCount: 5,
+	tickFormatter: void 0,
+	ticks: void 0,
+	type: "number",
+	unit: void 0,
+	width: 60
+};
+var implicitZAxis = {
+	domain: [0, "auto"],
+	includeHidden: false,
+	reversed: false,
+	allowDataOverflow: false,
+	allowDuplicatedCategory: false,
+	dataKey: void 0,
+	id: void 0,
+	name: "",
+	range: [64, 64],
+	scale: "auto",
+	type: "number",
+	unit: ""
+};
+//#endregion
+export { implicitXAxis, implicitYAxis, implicitZAxis };

package/dist/es/core/axis/stacks.mjs

@@ -0,0 +1,97 @@
+import { isNan, isNumber, toFiniteNumber } from "../../utils/validate.mjs";
+import { getValueByDataKey } from "../data.mjs";
+import { stack, stackOffsetExpand, stackOffsetNone, stackOffsetSilhouette, stackOffsetWiggle, stackOrderNone } from "d3-shape";
+//#region src/core/axis/stacks.ts
+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 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];
+			}
+		}
+	}
+};
+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) => toFiniteNumber(getValueByDataKey(d, key)) ?? 0).order(stackOrderNone).offset(offsetAccessor)(data);
+}
+function stackGroups(displayedData, items, stackOffsetType, reverseStackOrder = false) {
+	const initialItemsGroups = Object.create(null);
+	const itemsGroup = items.reduce((acc, item) => {
+		if (item.stackId == null) return acc;
+		if (acc[item.stackId] == null) acc[item.stackId] = [];
+		acc[item.stackId].push(item);
+		return acc;
+	}, initialItemsGroups);
+	return Object.fromEntries(Object.entries(itemsGroup).map(([stackId, groupItems]) => {
+		const graphicalItems = reverseStackOrder ? [...groupItems].reverse() : groupItems;
+		const dataKeys = graphicalItems.flatMap((item) => item.dataKey == null ? [] : [item.dataKey]);
+		return [stackId, {
+			stackedData: getStackedData(displayedData ?? [], dataKeys, stackOffsetType),
+			graphicalItems
+		}];
+	}));
+}
+function stackDomain(stackGroups, { dataStartIndex, dataEndIndex }, axisType) {
+	if (axisType === "zAxis") return;
+	const domainOfStackGroups = getDomainOfStackGroups(stackGroups, dataStartIndex, dataEndIndex);
+	if (domainOfStackGroups != null && domainOfStackGroups[0] === 0 && domainOfStackGroups[1] === 0) return;
+	return domainOfStackGroups;
+}
+//#endregion
+export { getDomainOfStackGroups, getStackedData, stackDomain, stackGroups };

package/dist/es/core/axis/ticks.mjs

@@ -0,0 +1,82 @@
+import { isCategoricalAxis, isNan } from "../../utils/validate.mjs";
+import { mathSign } from "../../utils/data.mjs";
+import { isNaN } from "es-toolkit/compat";
+//#region src/core/axis/ticks.ts
+function axisTicks(layout, axis, realScaleType, scale, niceTicks, axisRange, duplicateDomain, categoricalDomain, axisType) {
+	if (axis == null || scale == null) return;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	const { type, ticks, tickCount } = axis;
+	const offsetForBand = realScaleType === "scaleBand" ? scale.bandwidth() / 2 : 2;
+	let offset = type === "category" && scale.bandwidth ? scale.bandwidth() / offsetForBand : 0;
+	if (axisType === "angleAxis" && axisRange && axisRange.length >= 2) offset = mathSign(axisRange[0] - axisRange[1]) * 2 * offset;
+	const ticksOrNiceTicks = ticks || niceTicks;
+	if (ticksOrNiceTicks) return ticksOrNiceTicks.map((entry, index) => {
+		return {
+			index,
+			coordinate: scale(duplicateDomain ? duplicateDomain.indexOf(entry) : entry) + offset,
+			value: entry,
+			offset
+		};
+	}).filter((row) => !isNan(row.coordinate));
+	if (isCategorical && categoricalDomain) return categoricalDomain.map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		index,
+		offset
+	}));
+	if (scale.ticks) return scale.ticks(tickCount).map((entry) => ({
+		coordinate: scale(entry) + offset,
+		value: entry,
+		offset
+	}));
+	return scale.domain().map((entry, index) => ({
+		coordinate: scale(entry) + offset,
+		value: duplicateDomain ? duplicateDomain[entry] : entry,
+		index,
+		offset
+	}));
+}
+/**
+* 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) => {
+		const scaleContent = duplicateDomain ? duplicateDomain.indexOf(entry) : entry;
+		return {
+			coordinate: scale(scaleContent) + 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
+	}));
+}
+//#endregion
+export { axisTicks, getTicksOfAxis };

package/dist/es/{utils/isDomainSpecifiedByUser.mjs → core/axis/userDomain.mjs}

@@ -1,6 +1,7 @@
-import { isNumber, isWellBehavedNumber } from "./validate.mjs";
-import { MAX_VALUE_REG, MIN_VALUE_REG } from "./chart.mjs";
-//#region src/utils/isDomainSpecifiedByUser.ts
+import { isNumber, isWellBehavedNumber } from "../../utils/validate.mjs";
+//#region src/core/axis/userDomain.ts
+var MIN_VALUE_REG = /^dataMin\s*-\s*(\d+(\.\d+)?)$/;
+var MAX_VALUE_REG = /^dataMax\s*\+\s*(\d+(\.\d+)?)$/;
 function isWellFormedNumberDomain(v) {
 	if (Array.isArray(v) && v.length === 2) {
 		const [min, max] = v;
@@ -113,4 +114,4 @@ function parseNumericalUserDomain(userDomain, dataDomain, allowDataOverflow) {
 	}
 }
 //#endregion
-export { isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain };
+export { MAX_VALUE_REG, MIN_VALUE_REG, isWellFormedNumberDomain, numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain };

package/dist/es/{cartesian/bar/utils.mjs → core/bar.mjs}

@@ -1,10 +1,10 @@
-import { isNullish, isNumber } from "../../utils/validate.mjs";
-import { mathSign } from "../../utils/data.mjs";
-import { getBaseValueOfBar, getCateCoordinateOfBar, getValueByDataKey, truncateByDomain } from "../../utils/chart.mjs";
-import { toRaw } from "vue";
+import { isNullish, isNumber } from "../utils/validate.mjs";
+import { mathSign } from "../utils/data.mjs";
+import { getValueByDataKey } from "./data.mjs";
+import { getBaseValueOfBar, getCateCoordinateOfBar, truncateByDomain } from "./coordinates.mjs";
 import { isNaN } from "es-toolkit/compat";
 import { invariant } from "es-toolkit";
-//#region src/cartesian/bar/utils.ts
+//#region src/core/bar.ts
 /**
 * Safely gets minPointSize from the minPointSize prop if it is a function
 * @param minPointSize minPointSize as passed to the Bar component
@@ -22,6 +22,8 @@ function minPointSizeCallback(minPointSize, defaultValue = 0) {
 }
 var defaultMinPointSize = 0;
 function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: minPointSizeProp }, pos, bandSize, xAxis, yAxis, xAxisTicks, yAxisTicks, stackedData, displayedData, offset }) {
+	const size = pos.size;
+	if (size == null) return void 0;
 	const parentViewBox = {
 		x: offset.left,
 		y: offset.top,
@@ -33,14 +35,15 @@ function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: mi
 	const baseValue = getBaseValueOfBar({ numericAxis });
 	const stackedBarStart = numericAxis.scale(baseValue);
 	return displayedData.map((rawEntry, index) => {
-		const entry = toRaw(rawEntry);
-		let value, x, y, width, height, background;
+		const entry = rawEntry;
+		let value;
+		let x, y, width, height, background;
 		if (stackedData) value = truncateByDomain(stackedData[index], stackedDomain);
 		else {
-			value = getValueByDataKey(entry, dataKey);
-			if (!Array.isArray(value)) value = [baseValue, value];
+			const rawValue = getValueByDataKey(entry, dataKey);
+			value = Array.isArray(rawValue) ? rawValue : [baseValue, rawValue];
 		}
-		const minPointSize = minPointSizeCallback(minPointSizeProp, defaultMinPointSize)(value[1], index);
+		const minPointSize = minPointSizeCallback(minPointSizeProp ?? defaultMinPointSize, defaultMinPointSize)(value[1], index);
 		if (layout === "horizontal") {
 			const [baseValueScale, currentValueScale] = [yAxis.scale(value[0]), yAxis.scale(value[1])];
 			x = getCateCoordinateOfBar({
@@ -51,8 +54,8 @@ function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: mi
 				entry,
 				index
 			});
-			y = currentValueScale ?? baseValueScale ?? void 0;
-			width = pos.size;
+			y = currentValueScale ?? baseValueScale;
+			width = size;
 			const computedHeight = baseValueScale - currentValueScale;
 			height = isNaN(computedHeight) ? 0 : computedHeight;
 			background = {
@@ -78,7 +81,7 @@ function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: mi
 				index
 			});
 			width = currentValueScale - baseValueScale;
-			height = pos.size;
+			height = size;
 			background = {
 				x: offset.left,
 				y,
@@ -96,12 +99,12 @@ function computeBarRectangles({ layout, barSettings: { dataKey, minPointSize: mi
 			width,
 			height,
 			stackedBarStart: stackedBarStart ?? 0,
-			value: stackedData ? value : value[1],
+			value: stackedData ? [value[0], value[1]] : value[1],
 			payload: entry,
 			background,
 			tooltipPosition: {
-				x: x + width / 2,
-				y: y + height / 2
+				x: (x ?? 0) + width / 2,
+				y: (y ?? 0) + height / 2
 			},
 			parentViewBox
 		};