vccs 0.6.0 → 1.0.0-beta.2

package/dist/es/components/utils.mjs

@@ -1,7 +1,7 @@
 import { polarToCartesian } from "../utils/polar.mjs";
+import { isPolarCoordinate } from "../types/base.mjs";
 //#region src/components/utils.ts
-function getRadialCursorPoints(activeCoordinate) {
-	const { cx, cy, radius, startAngle, endAngle } = activeCoordinate;
+function getRadialCursorPoints({ cx, cy, radius, startAngle, endAngle }) {
 	return {
 		points: [polarToCartesian(cx, cy, radius, startAngle), polarToCartesian(cx, cy, radius, endAngle)],
 		cx,
@@ -12,33 +12,32 @@ function getRadialCursorPoints(activeCoordinate) {
 	};
 }
 function getCursorPoints(layout, activeCoordinate, offset) {
-	let x1, y1, x2, y2;
 	if (layout === "horizontal") {
-		x1 = activeCoordinate.x;
-		x2 = x1;
-		y1 = offset.top;
-		y2 = offset.top + offset.height;
-	} else if (layout === "vertical") {
-		y1 = activeCoordinate.y;
-		y2 = y1;
-		x1 = offset.left;
-		x2 = offset.left + offset.width;
-	} else if (activeCoordinate.cx != null && activeCoordinate.cy != null) if (layout === "centric") {
+		const { x } = activeCoordinate;
+		return [{
+			x,
+			y: offset.top
+		}, {
+			x,
+			y: offset.top + offset.height
+		}];
+	}
+	if (layout === "vertical") {
+		const { y } = activeCoordinate;
+		return [{
+			x: offset.left,
+			y
+		}, {
+			x: offset.left + offset.width,
+			y
+		}];
+	}
+	if (!isPolarCoordinate(activeCoordinate)) return [activeCoordinate, activeCoordinate];
+	if (layout === "centric") {
 		const { cx, cy, innerRadius, outerRadius, angle } = activeCoordinate;
-		const innerPoint = polarToCartesian(cx, cy, innerRadius, angle);
-		const outerPoint = polarToCartesian(cx, cy, outerRadius, angle);
-		x1 = innerPoint.x;
-		y1 = innerPoint.y;
-		x2 = outerPoint.x;
-		y2 = outerPoint.y;
-	} else return getRadialCursorPoints(activeCoordinate);
-	return [{
-		x: x1,
-		y: y1
-	}, {
-		x: x2,
-		y: y2
-	}];
+		return [polarToCartesian(cx, cy, innerRadius, angle), polarToCartesian(cx, cy, outerRadius, angle)];
+	}
+	return getRadialCursorPoints(activeCoordinate);
 }
 //#endregion
 export { getCursorPoints };

package/dist/es/container/ClipPath.mjs

@@ -1,4 +1,4 @@
-import { useOffset } from "../context/chartLayoutContext.mjs";
+import { useChartPresentation } from "../model/presentation.mjs";
 import { createVNode, defineComponent } from "vue";
 //#region src/container/ClipPath.tsx
 var ClipPath_default = /* @__PURE__ */ defineComponent({
@@ -8,7 +8,7 @@ var ClipPath_default = /* @__PURE__ */ defineComponent({
 		required: true
 	} },
 	setup(props) {
-		const offset = useOffset();
+		const offset = useChartPresentation().offset;
 		return () => {
 			if (!offset.value) return null;
 			const { left, top, height, width } = offset.value;

package/dist/es/container/Layer.mjs

@@ -1,4 +1,4 @@
-import { filterProps } from "../utils/VueUtils.mjs";
+import { svgAttrs } from "../utils/VueUtils.mjs";
 import { createVNode, defineComponent, mergeProps } from "vue";
 //#region src/container/Layer.tsx
 var Layer = /* @__PURE__ */ defineComponent({
@@ -6,7 +6,7 @@ var Layer = /* @__PURE__ */ defineComponent({
 	inheritAttrs: false,
 	setup(_, { attrs, slots }) {
 		return () => {
-			return createVNode("g", mergeProps(attrs, filterProps(attrs, true), { "class": "v-charts-layer" }), [slots.default?.()]);
+			return createVNode("g", mergeProps(svgAttrs(attrs), { "class": "v-charts-layer" }), [slots.default?.()]);
 		};
 	}
 });

package/dist/es/container/ResponsiveContainer.vue_vue_type_script_setup_true_lang.mjs

@@ -1,12 +1,11 @@
-import { isPercent } from "../utils/validate.mjs";
+import { warnOnce } from "../utils/log.mjs";
 import { normalizeStyle as normalizeStyle$1 } from "../utils/style.mjs";
-import { useRoundedSize } from "../hooks/useRoundedSize.mjs";
-import { provideSizeContext } from "./useSizeContext.mjs";
-import { Fragment, cloneVNode, computed, createElementBlock, createVNode, defineComponent, normalizeClass, normalizeStyle, onMounted, onUnmounted, openBlock, ref, toRef, useSlots } from "vue";
-import { useThrottleFn } from "@vueuse/core";
+import { provideInitialDimension } from "./useSizeContext.mjs";
+import { computed, createElementBlock, defineComponent, normalizeClass, normalizeStyle, openBlock, ref, renderSlot, toRef } from "vue";
+import { useMounted, useResizeObserver, useThrottleFn } from "@vueuse/core";
 //#region src/container/ResponsiveContainer.vue?vue&type=script&setup=true&lang.ts
 var _hoisted_1 = ["id"];
-var ResponsiveContainer_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+var ResponsiveContainer_vue_vue_type_script_setup_true_lang_default = /*@__PURE__*/ defineComponent({
 	name: "ResponsiveContainer",
 	inheritAttrs: false,
 	__name: "ResponsiveContainer",
@@ -16,118 +15,33 @@ var ResponsiveContainer_vue_vue_type_script_setup_true_lang_default = /* @__PURE
 		height: { default: "100%" },
 		minWidth: { default: 0 },
 		minHeight: {},
-		initialDimension: { default: () => ({
-			width: -1,
-			height: -1
-		}) },
+		initialDimension: {},
 		maxHeight: {},
 		debounce: { default: 0 },
 		id: {},
 		class: {},
-		style: {},
-		onResize: {}
+		style: {}
 	},
-	setup(__props) {
+	emits: ["resize"],
+	setup(__props, { emit: __emit }) {
 		const props = __props;
-		const slots = useSlots();
+		const emit = __emit;
+		warnOnce("[vccs] ResponsiveContainer is deprecated and will be removed in 2.0. Charts are responsive by default: remove the wrapper and set width, height or aspect on the chart.");
 		const debounce = toRef(props, "debounce");
-		const { size: sizes, setSize: setContainerSize } = useRoundedSize({
-			width: props.initialDimension.width,
-			height: props.initialDimension.height
-		});
-		const calculatedWidth = computed(() => {
-			return isPercent(props.width) ? sizes.value.width : props.width;
-		});
-		const calculatedHeight = computed(() => {
-			let height = isPercent(props.height) ? sizes.value.height : props.height;
-			if (props.aspect && props.aspect > 0) {
-				if (props.width && (props.height == null || props.height === "auto")) height = calculatedWidth.value / props.aspect;
-				else if (props.height && (props.width == null || props.width === "auto")) {}
-			}
-			return height;
-		});
-		const finalCalculatedWidth = computed(() => {
-			let width = calculatedWidth.value;
-			if (props.aspect && props.aspect > 0) {
-				if (props.height && (props.width == null || props.width === "auto")) width = calculatedHeight.value * props.aspect;
-			}
-			return width;
-		});
-		provideSizeContext({
-			sizes,
-			calculatedWidth: finalCalculatedWidth,
-			calculatedHeight
-		});
+		provideInitialDimension(toRef(props, "initialDimension"));
 		const handleResize = useThrottleFn((entries) => {
-			const { width: containerWidth, height: containerHeight } = entries[0].contentRect;
-			setContainerSize(containerWidth, containerHeight);
-			props.onResize?.(containerWidth, containerHeight);
+			const { width, height } = entries[0].contentRect;
+			emit("resize", width, height);
 		}, debounce, true, false);
 		const containerRef = ref();
-		let observer = null;
-		onMounted(() => {
-			observer = new ResizeObserver(handleResize);
-			const { width: containerWidth, height: containerHeight } = containerRef.value.getBoundingClientRect() ?? {
-				width: 0,
-				height: 0
-			};
-			setContainerSize(containerWidth, containerHeight);
-			observer.observe(containerRef.value);
-		});
-		onUnmounted(() => {
-			observer?.disconnect();
-		});
-		const isReady = computed(() => {
-			const { width: containerWidth, height: containerHeight } = sizes.value;
-			return containerWidth >= 0 && containerHeight >= 0;
-		});
-		function flattenSlotChildren(vnodes) {
-			const result = [];
-			for (const vnode of vnodes) if (vnode.type === Fragment && Array.isArray(vnode.children)) result.push(...flattenSlotChildren(vnode.children));
-			else result.push(vnode);
-			return result;
-		}
-		function renderChildren() {
-			if (!isReady.value) return;
-			const calculatedWidthValue = finalCalculatedWidth.value;
-			const calculatedHeightValue = calculatedHeight.value;
-			const rawChildren = slots.default?.();
-			if (!rawChildren) return void 0;
-			return flattenSlotChildren(rawChildren).map((child, index) => {
-				return cloneVNode(child, {
-					width: calculatedWidthValue,
-					height: calculatedHeightValue,
-					key: child.key || `responsive-child-${index}`,
-					style: {
-						...normalizeStyle$1({
-							maxHeight: sizes.value.height,
-							maxWidth: sizes.value.width
-						}),
-						height: "100%",
-						width: "100%",
-						...child.props?.style
-					}
-				});
-			});
-		}
-		/**
-		* Rendering the children through `<component :is="() => renderChildren()" />` would
-		* create a new component type on every render, so Vue unmounts and remounts the whole
-		* chart subtree each time. Charts that dispatch on `mouseenter` (radial bar, radar) then
-		* loop forever: the remount recreates the element under the cursor, which fires
-		* `mouseenter` again. This renderer keeps a stable type, so the subtree is patched.
-		*/
-		const ChildrenRenderer = (rendererProps) => rendererProps.nodes;
-		ChildrenRenderer.props = { nodes: {
-			type: Array,
-			required: true
-		} };
-		ChildrenRenderer.inheritAttrs = false;
+		const mounted = useMounted();
+		useResizeObserver(() => mounted.value ? containerRef.value : void 0, handleResize);
 		const containerStyle = computed(() => ({
 			...props.style,
+			aspectRatio: props.aspect,
 			...normalizeStyle$1({
 				width: props.width,
-				height: props.height,
+				height: props.aspect ? "auto" : props.height,
 				minWidth: props.minWidth,
 				minHeight: props.minHeight,
 				maxHeight: props.maxHeight
@@ -138,9 +52,9 @@ var ResponsiveContainer_vue_vue_type_script_setup_true_lang_default = /* @__PURE
 				id: _ctx.id ? `${_ctx.id}` : void 0,
 				ref_key: "containerRef",
 				ref: containerRef,
-				class: normalizeClass(["vcharts-responsive-container", [props.class]]),
+				class: normalizeClass(["v-charts-responsive-container", [props.class]]),
 				style: normalizeStyle(containerStyle.value)
-			}, [createVNode(ChildrenRenderer, { nodes: renderChildren() ?? [] }, null, 8, ["nodes"])], 14, _hoisted_1);
+			}, [renderSlot(_ctx.$slots, "default")], 14, _hoisted_1);
 		};
 	}
 });

package/dist/es/container/Surface.mjs

@@ -1,9 +1,14 @@
+import { provideChartLayers } from "../model/runtime.mjs";
 import { classProp } from "../types/common.mjs";
-import { createVNode, defineComponent, mergeProps } from "vue";
+import { createVNode, defineComponent, mergeProps, ref } from "vue";
 //#region src/container/Surface.tsx
 /**
 * @fileOverview Surface component for SVG rendering
 */
+/**
+* The SVG root of every chart and of legend icons. With `layers`, it also renders the cursor,
+* graphical and label layers that chart parts teleport into, painted in that order.
+*/
 var Surface = /* @__PURE__ */ defineComponent({
 	name: "Surface",
 	props: {
@@ -35,27 +40,61 @@ var Surface = /* @__PURE__ */ defineComponent({
 		desc: {
 			type: String,
 			default: void 0
+		},
+		/** Id of the `<desc>` element, for `aria-describedby`. */
+		descriptionId: {
+			type: String,
+			default: void 0
+		},
+		/** Adds the chart layers; fixed for the component's lifetime. */
+		layers: {
+			type: Boolean,
+			default: false
 		}
 	},
+	inheritAttrs: false,
 	setup(props, { slots, attrs }) {
+		const cursor = ref(null);
+		const graphical = ref(null);
+		const label = ref(null);
+		if (props.layers) provideChartLayers({
+			cursor,
+			graphical,
+			label
+		});
 		return () => {
-			const { width, height, viewBox, class: className, style, title, desc, ...rest } = props;
+			const { width, height, viewBox, class: className, style, title, desc } = props;
 			const svgView = viewBox || {
 				width,
 				height,
 				x: 0,
 				y: 0
 			};
-			return createVNode("svg", mergeProps({
-				"class": ["vcharts-surface", className],
+			return createVNode("svg", mergeProps(attrs, props.layers ? { "data-slot": "surface" } : {}, {
+				"class": ["v-charts-surface", className],
 				"width": width,
 				"height": height,
 				"style": style,
 				"viewBox": `${svgView.x} ${svgView.y} ${svgView.width} ${svgView.height}`
-			}, rest, attrs), [
+			}), [
 				title && createVNode("title", null, [title]),
-				desc && createVNode("desc", null, [desc]),
-				slots.default?.()
+				desc && createVNode("desc", { "id": props.descriptionId }, [desc]),
+				slots.default?.(),
+				props.layers && [
+					createVNode("g", {
+						"ref": cursor,
+						"class": "v-charts-cursor-layer"
+					}, null),
+					createVNode("g", {
+						"ref": graphical,
+						"data-slot": "plot",
+						"class": "v-charts-graphical-layer"
+					}, null),
+					createVNode("g", {
+						"ref": label,
+						"class": "v-charts-label-layer"
+					}, null)
+				]
 			]);
 		};
 	}

package/dist/es/container/useSizeContext.mjs

@@ -1,5 +1,14 @@
-import { createContext } from "../utils/createContext.mjs";
+import { inject, provide } from "vue";
 //#region src/container/useSizeContext.ts
-var [useSizeContext, provideSizeContext] = createContext("SizeContext");
+var initialDimensionKey = Symbol("v-charts-initial-dimension");
+function provideInitialDimension(value) {
+	provide(initialDimensionKey, value);
+	return value;
+}
+function useInitialDimension(fallback) {
+	const value = inject(initialDimensionKey, fallback);
+	if (value === void 0) throw new Error("vccs: useInitialDimension requires its provider.");
+	return value;
+}
 //#endregion
-export { provideSizeContext };
+export { provideInitialDimension, useInitialDimension };

package/dist/es/context/cartesianLabelListContext.mjs

@@ -1,5 +1,14 @@
-import { createContext } from "../utils/createContext.mjs";
+import { inject, provide } from "vue";
 //#region src/context/cartesianLabelListContext.ts
-var [useCartesianLabelListData, provideCartesianLabelListData] = createContext("CartesianLabelListContext");
+var cartesianLabelListKey = Symbol("v-charts-cartesian-label-list");
+function provideCartesianLabelListData(value) {
+	provide(cartesianLabelListKey, value);
+	return value;
+}
+function useCartesianLabelListData(fallback) {
+	const value = inject(cartesianLabelListKey, fallback);
+	if (value === void 0) throw new Error("vccs: useCartesianLabelListData requires its provider.");
+	return value;
+}
 //#endregion
 export { provideCartesianLabelListData, useCartesianLabelListData };

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

@@ -1,6 +1,7 @@
-import { isNumber } from "../../utils/validate.mjs";
-import { getCateCoordinateOfLine, getValueByDataKey } from "../../utils/chart.mjs";
-//#region src/cartesian/area/utils.ts
+import { isNumber, toFiniteNumber } from "../utils/validate.mjs";
+import { getValueByDataKey } from "./data.mjs";
+import { getCateCoordinateOfLine } from "./coordinates.mjs";
+//#region src/core/area.ts
 function getBaseValue(layout, chartBaseValue, itemBaseValue, xAxis, yAxis) {
 	const baseValue = itemBaseValue ?? chartBaseValue;
 	if (isNumber(baseValue)) return baseValue;
@@ -30,7 +31,7 @@ function computeArea({ areaSettings: { connectNulls, baseValue: itemBaseValue, d
 			if (!Array.isArray(value)) value = [baseValue, value];
 			else isRange = true;
 		}
-		const isBreakPoint = value[1] == null || hasStack && !connectNulls && getValueByDataKey(entry, dataKey) == null;
+		const isBreakPoint = toFiniteNumber(value[0]) == null || toFiniteNumber(value[1]) == null || hasStack && !connectNulls && toFiniteNumber(getValueByDataKey(entry, dataKey)) == null;
 		if (isHorizontalLayout) return {
 			x: getCateCoordinateOfLine({
 				axis: xAxis,

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

@@ -0,0 +1,75 @@
+import { isNan, isNumOrStr, isWellBehavedNumber } from "../../utils/validate.mjs";
+import { getValueByDataKey } from "../data.mjs";
+import { sameAxis } from "./key.mjs";
+//#region src/core/axis/data.ts
+function itemAxisPredicate(axisType, axisId) {
+	return (item) => {
+		switch (axisType) {
+			case "xAxis": return "xAxisId" in item && sameAxis(item.xAxisId, axisId);
+			case "yAxis": return "yAxisId" in item && sameAxis(item.yAxisId, axisId);
+			case "zAxis": return "zAxisId" in item && sameAxis(item.zAxisId, axisId);
+			case "angleAxis": return "angleAxisId" in item && sameAxis(item.angleAxisId, axisId);
+			case "radiusAxis": return "radiusAxisId" in item && sameAxis(item.radiusAxisId, axisId);
+			default: return false;
+		}
+	};
+}
+function graphicalItemsSettings(graphicalItems, axisSettings, axisPredicate) {
+	return graphicalItems.filter(axisPredicate).filter((item) => {
+		if (axisSettings?.includeHidden === true) return true;
+		return !item.hide;
+	});
+}
+function filterGraphicalNotStackedItems(cartesianItems) {
+	return cartesianItems.filter((item) => item.stackId === void 0);
+}
+function graphicalItemsData(cartesianItems) {
+	return cartesianItems.map((item) => item.data).filter(Boolean).flat(1);
+}
+function appliedValues(data, axisSettings, items) {
+	if (axisSettings?.dataKey != null) return data.map((item) => ({ value: getValueByDataKey(item, axisSettings.dataKey) }));
+	if (items.length > 0) return items.map((item) => item.dataKey).flatMap((dataKey) => data.map((entry) => ({ value: getValueByDataKey(entry, dataKey) })));
+	return data.map((entry) => ({ value: entry }));
+}
+function isErrorBarRelevantForAxisType(axisType, errorBar) {
+	switch (axisType) {
+		case "xAxis": return errorBar.direction === "x";
+		case "yAxis": return errorBar.direction === "y";
+		default: return false;
+	}
+}
+function onlyAllowNumbers(data) {
+	return data.filter((v) => isNumOrStr(v) || v instanceof Date).map(Number).filter(Number.isFinite);
+}
+function getErrorDomainByDataKey(entry, appliedValue, relevantErrorBars) {
+	if (!relevantErrorBars || typeof appliedValue !== "number" || isNan(appliedValue)) return [];
+	if (!relevantErrorBars.length) return [];
+	return onlyAllowNumbers(relevantErrorBars.flatMap((eb) => {
+		const errorValue = getValueByDataKey(entry, eb.dataKey);
+		let lowBound, highBound;
+		if (Array.isArray(errorValue)) [lowBound, highBound] = errorValue;
+		else lowBound = highBound = errorValue;
+		if (!isWellBehavedNumber(lowBound) || !isWellBehavedNumber(highBound)) return;
+		return [appliedValue - lowBound, appliedValue + highBound];
+	}));
+}
+function numericalValuesWithErrors(data, axisSettings, items, axisType) {
+	if (items.length > 0) return data.flatMap((entry) => items.map((item) => {
+		const relevantErrorBars = item.errorBars?.filter((errorBar) => isErrorBarRelevantForAxisType(axisType, errorBar));
+		const value = getValueByDataKey(entry, axisSettings.dataKey || item.dataKey);
+		return {
+			value,
+			errorDomain: getErrorDomainByDataKey(entry, value, relevantErrorBars)
+		};
+	}));
+	if (axisSettings?.dataKey != null) return data.map((item) => ({
+		value: getValueByDataKey(item, axisSettings.dataKey),
+		errorDomain: []
+	}));
+	return data.map((entry) => ({
+		value: entry,
+		errorDomain: []
+	}));
+}
+//#endregion
+export { appliedValues, filterGraphicalNotStackedItems, graphicalItemsData, graphicalItemsSettings, itemAxisPredicate, numericalValuesWithErrors, onlyAllowNumbers };

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

@@ -0,0 +1,63 @@
+import { flushTiny, isCategoricalAxis, isNumOrStr, isNumber } from "../../utils/validate.mjs";
+import { hasDuplicate } from "../../utils/data.mjs";
+import { numericalDomainSpecifiedWithoutRequiringData, parseNumericalUserDomain } from "./userDomain.mjs";
+import { onlyAllowNumbers } from "./data.mjs";
+import { range } from "es-toolkit/compat";
+//#region src/core/axis/domain.ts
+var defaultNumericDomain = [0, "auto"];
+function onlyAllowNumbersAndStringsAndDates(item) {
+	const { value } = item;
+	if (isNumOrStr(value) || value instanceof Date) return value;
+}
+function computeNumericalDomain(dataWithErrorDomains) {
+	const allDataSquished = dataWithErrorDomains.flatMap((d) => [d.value, d.errorDomain]).flat(1);
+	const onlyNumbers = onlyAllowNumbers(allDataSquished);
+	if (onlyNumbers.length === 0) return;
+	return [Math.min(...onlyNumbers), Math.max(...onlyNumbers)];
+}
+function computeDomainOfTypeCategory(allDataSquished, axisSettings, isCategorical) {
+	const categoricalDomain = allDataSquished.map(onlyAllowNumbersAndStringsAndDates).filter((v) => v != null);
+	if (isCategorical && (axisSettings.dataKey == null || axisSettings.allowDuplicatedCategory && hasDuplicate(categoricalDomain))) return range(0, allDataSquished.length);
+	if (axisSettings.allowDuplicatedCategory) return categoricalDomain;
+	return Array.from(new Set(categoricalDomain));
+}
+function getDomainDefinition(axisSettings) {
+	if (axisSettings == null || !("domain" in axisSettings)) return defaultNumericDomain;
+	if (axisSettings.domain != null) return axisSettings.domain;
+	if (axisSettings.ticks != null) {
+		if (axisSettings.type === "number") {
+			const allValues = onlyAllowNumbers(axisSettings.ticks);
+			return [Math.min(...allValues), Math.max(...allValues)];
+		}
+		if (axisSettings.type === "category") return axisSettings.ticks.map(String);
+	}
+	return axisSettings?.domain ?? defaultNumericDomain;
+}
+function mergeDomains(...domains) {
+	const allDomains = domains.filter(Boolean);
+	if (allDomains.length === 0) return;
+	const allNumbers = allDomains.flat().filter(isNumber);
+	if (allNumbers.length === 0) return;
+	return [Math.min(...allNumbers), Math.max(...allNumbers)];
+}
+function numericalDomain(axisSettings, domainDefinition, domainOfStackGroups, allDataWithErrorDomains, referenceElementsDomain) {
+	const domainFromUserPreference = numericalDomainSpecifiedWithoutRequiringData(domainDefinition, axisSettings.allowDataOverflow);
+	if (domainFromUserPreference != null) return domainFromUserPreference;
+	const domain = parseNumericalUserDomain(domainDefinition, mergeDomains(domainOfStackGroups, referenceElementsDomain, computeNumericalDomain(allDataWithErrorDomains)), axisSettings.allowDataOverflow);
+	return domain && [flushTiny(domain[0]), flushTiny(domain[1])];
+}
+var expandDomain = [0, 1];
+function axisDomain(axisSettings, layout, displayedData, allAppliedValues, stackOffsetType, axisType, numericalDomain) {
+	if ((axisSettings == null || displayedData == null || displayedData.length === 0) && numericalDomain === void 0) return;
+	const { dataKey, type } = axisSettings;
+	const isCategorical = isCategoricalAxis(layout, axisType);
+	if (isCategorical && dataKey == null) {
+		const domainLen = Array.isArray(axisSettings.domain) ? axisSettings.domain.length : 0;
+		return range(0, Math.max(displayedData?.length ?? 0, domainLen));
+	}
+	if (type === "category") return computeDomainOfTypeCategory(allAppliedValues, axisSettings, isCategorical);
+	if (stackOffsetType === "expand") return expandDomain;
+	return numericalDomain;
+}
+//#endregion
+export { axisDomain, defaultNumericDomain, getDomainDefinition, mergeDomains, numericalDomain };

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

@@ -0,0 +1,13 @@
+//#region src/core/axis/key.ts
+/**
+* The one identity rule for axis ids: `y-axis-id="1"` (a string attribute) and
+* `:y-axis-id="1"` (a number) name the same axis.
+*/
+function axisKey(id) {
+	return String(id);
+}
+function sameAxis(a, b) {
+	return a !== void 0 && b !== void 0 && axisKey(a) === axisKey(b);
+}
+//#endregion
+export { axisKey, sameAxis };

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

@@ -0,0 +1,16 @@
+import { getPercentValue } from "../../utils/data.mjs";
+//#region src/core/axis/polar.ts
+function polarViewBox(layout, options, innerRadius, outerRadius, size) {
+	if (layout !== "centric" && layout !== "radial" || !options || innerRadius == null || outerRadius == null) return;
+	return {
+		cx: getPercentValue(options.cx, size.width, size.width / 2),
+		cy: getPercentValue(options.cy, size.height, size.height / 2),
+		innerRadius,
+		outerRadius,
+		startAngle: options.startAngle,
+		endAngle: options.endAngle,
+		clockWise: false
+	};
+}
+//#endregion
+export { polarViewBox };

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

@@ -0,0 +1,100 @@
+//#region src/core/axis/polarSettings.ts
+var defaultPolarAngleAxisProps = {
+	allowDuplicatedCategory: true,
+	angleAxisId: 0,
+	axisLine: true,
+	cx: 0,
+	cy: 0,
+	orientation: "outer",
+	reversed: false,
+	scale: "auto",
+	tick: true,
+	tickLine: true,
+	tickSize: 8,
+	type: "category"
+};
+var implicitAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: false,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: defaultPolarAngleAxisProps.reversed,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
+	tickCount: void 0,
+	ticks: void 0,
+	type: defaultPolarAngleAxisProps.type,
+	unit: void 0
+};
+var defaultPolarRadiusAxisProps = {
+	allowDataOverflow: false,
+	allowDuplicatedCategory: true,
+	angle: 0,
+	axisLine: true,
+	cx: 0,
+	cy: 0,
+	orientation: "right",
+	radiusAxisId: 0,
+	scale: "auto",
+	stroke: "var(--v-charts-grid, #ccc)",
+	tick: true,
+	tickCount: 5,
+	type: "number"
+};
+var implicitRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
+	ticks: void 0,
+	type: defaultPolarRadiusAxisProps.type,
+	unit: void 0
+};
+var implicitRadialBarAngleAxis = {
+	allowDataOverflow: false,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarAngleAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarAngleAxisProps.scale,
+	tick: defaultPolarAngleAxisProps.tick,
+	tickCount: void 0,
+	ticks: void 0,
+	type: "number",
+	unit: void 0
+};
+var implicitRadialBarRadiusAxis = {
+	allowDataOverflow: defaultPolarRadiusAxisProps.allowDataOverflow,
+	allowDecimals: false,
+	allowDuplicatedCategory: defaultPolarRadiusAxisProps.allowDuplicatedCategory,
+	dataKey: void 0,
+	domain: void 0,
+	id: void 0,
+	includeHidden: false,
+	name: void 0,
+	reversed: false,
+	scale: defaultPolarRadiusAxisProps.scale,
+	tick: defaultPolarRadiusAxisProps.tick,
+	tickCount: defaultPolarRadiusAxisProps.tickCount,
+	ticks: void 0,
+	type: "category",
+	unit: void 0
+};
+//#endregion
+export { implicitAngleAxis, implicitRadialBarAngleAxis, implicitRadialBarRadiusAxis, implicitRadiusAxis };