vccs 0.1.0 → 0.3.0

package/dist/es/cartesian/area/RenderArea.mjs

@@ -1,151 +1,185 @@
-import { isNan as e, isNullish as t, isNumber as n } from "../../utils/validate.mjs";
-import { interpolate as r } from "../../utils/data-utils.mjs";
-import { Curve as i } from "../../shape/Curve.mjs";
-import { isClipDot as a } from "../../utils/chart.mjs";
-import { useOffset as o } from "../../context/chartLayoutContext.mjs";
-import { useAreaContext as s } from "./hooks/useArea.mjs";
-import { Layer as c } from "../../container/Layer.mjs";
-import { Dot as l } from "../../shape/Dot.mjs";
-import { LabelList as u } from "../../components/label/LabelList.mjs";
-import { Fragment as d, createVNode as f, defineComponent as p, mergeProps as m, ref as h, watch as g } from "vue";
-import { animate as _ } from "motion-v";
+import { isNan, isNullish, isNumber } from "../../utils/validate.mjs";
+import { interpolate } from "../../utils/data-utils.mjs";
+import { Curve } from "../../shape/Curve.mjs";
+import { isClipDot } from "../../utils/chart.mjs";
+import { useOffset } from "../../context/chartLayoutContext.mjs";
+import { useAreaContext } from "./hooks/useArea.mjs";
+import { Layer } from "../../container/Layer.mjs";
+import { Dot } from "../../shape/Dot.mjs";
+import { LabelList } from "../../components/label/LabelList.mjs";
+import { Fragment, createVNode, defineComponent, mergeProps, ref, watch } from "vue";
+import { animate } from "motion-v";
 //#region src/cartesian/area/RenderArea.tsx
-var v = /* @__PURE__ */ p({
+var Dots = /* @__PURE__ */ defineComponent({
 	name: "Dots",
 	props: { points: {
 		type: Array,
 		default: () => []
 	} },
-	setup(e) {
-		let { clipPathId: t, props: n, attrs: r, dotSlot: i } = s();
+	setup(_props) {
+		const { clipPathId, props, attrs, dotSlot } = useAreaContext();
 		return () => {
-			let { points: o } = e;
-			if (!b(o, n.dot)) return null;
-			let s = a(n.dot), u = {
-				fill: n.fill,
-				"fill-opacity": n.fillOpacity,
-				"stroke-width": n.strokeWidth,
-				stroke: n.stroke
+			const { points } = _props;
+			if (!shouldRenderDots(points, props.dot)) return null;
+			const clipDot = isClipDot(props.dot);
+			const dotsProps = {
+				"fill": props.fill,
+				"fill-opacity": props.fillOpacity,
+				"stroke-width": props.strokeWidth,
+				"stroke": props.stroke
 			};
-			return f(c, {
-				class: "v-charts-area-dots",
-				"clip-path": n.needClip ? `url(#clipPath-${s ? "" : "dots-"}${t.value})` : void 0
-			}, { default: () => [o?.map((e) => {
-				let t = {
-					...u,
-					...r,
+			return createVNode(Layer, {
+				"class": "v-charts-area-dots",
+				"clip-path": props.needClip ? `url(#clipPath-${clipDot ? "" : "dots-"}${clipPathId.value})` : void 0
+			}, { default: () => [points?.map((point) => {
+				const dotProps = {
+					...dotsProps,
+					...attrs,
 					r: 3,
-					cx: e.x,
-					cy: e.y,
+					cx: point.x,
+					cy: point.y,
 					class: "v-charts-area-dot",
-					clipDot: s
+					clipDot
 				};
-				return i ? i(t) : f(l, t, null);
+				if (dotSlot) return dotSlot(dotProps);
+				return createVNode(Dot, dotProps, null);
 			})] });
 		};
 	}
-}), y = /* @__PURE__ */ p({
+});
+var StaticArea = /* @__PURE__ */ defineComponent({
 	name: "StaticArea",
 	setup() {
-		let { points: a, clipPathId: l, layout: p, attrs: y, areaData: b, props: x, isAnimating: S, isClipRectAnimating: C } = s(), w = o(), T = h(a.value || []), E = h(b.value?.baseLine || []), D = T.value || [], O = b.value?.baseLine || [], k = !1;
-		return g(a, (i, a, o) => {
-			if (C.value) {
-				T.value = i, E.value = b.value?.baseLine || [];
+		const { points, clipPathId, layout, attrs, areaData, props, isAnimating, isClipRectAnimating } = useAreaContext();
+		const offset = useOffset();
+		const currentPoints = ref(points.value || []);
+		const currentBaseLine = ref(areaData.value?.baseLine || []);
+		let prevPoints = currentPoints.value || [];
+		let prevBaseLine = areaData.value?.baseLine || [];
+		let animationStopped = false;
+		watch(points, (newPoints, _, onCleanup) => {
+			if (isClipRectAnimating.value) {
+				currentPoints.value = newPoints;
+				currentBaseLine.value = areaData.value?.baseLine || [];
 				return;
 			}
-			if (i && i.length > 0) {
-				k = !1, S.value = !0;
-				let a = _(0, 1, {
-					...x.transition,
-					onUpdate(a) {
-						if (!k && D.length) {
-							let o = D.length / i.length, s = a === 1 ? i : i.map((e, t) => {
-								let n = Math.floor(t * o);
-								if (D[n]) {
-									let t = D[n];
+			if (newPoints && newPoints.length > 0) {
+				animationStopped = false;
+				isAnimating.value = true;
+				const animation = animate(0, 1, {
+					...props.transition,
+					onUpdate(t) {
+						if (animationStopped) return;
+						if (prevPoints.length) {
+							const prevPointsDiffFactor = prevPoints.length / newPoints.length;
+							const stepPoints = t === 1 ? newPoints : newPoints.map((entry, index) => {
+								const prevPointIndex = Math.floor(index * prevPointsDiffFactor);
+								if (prevPoints[prevPointIndex]) {
+									const prev = prevPoints[prevPointIndex];
 									return {
-										...e,
-										x: r(t.x, e.x, a),
-										y: r(t.y, e.y, a)
+										...entry,
+										x: interpolate(prev.x, entry.x, t),
+										y: interpolate(prev.y, entry.y, t)
 									};
 								}
-								return e;
-							}), c;
-							c = n(b.value?.baseLine) ? r(O, b.value?.baseLine, a) : t(b.value?.baseLine) || e(b.value?.baseLine) ? r(O, 0, a) : b?.value.baseLine.map((e, t) => {
-								let n = Math.floor(t * o);
-								if (Array.isArray(O) && O[n]) {
-									let t = O[n];
+								return entry;
+							});
+							let stepBaseLine;
+							if (isNumber(areaData.value?.baseLine)) stepBaseLine = interpolate(prevBaseLine, areaData.value?.baseLine, t);
+							else if (isNullish(areaData.value?.baseLine) || isNan(areaData.value?.baseLine)) stepBaseLine = interpolate(prevBaseLine, 0, t);
+							else stepBaseLine = areaData?.value.baseLine.map((entry, index) => {
+								const prevPointIndex = Math.floor(index * prevPointsDiffFactor);
+								if (Array.isArray(prevBaseLine) && prevBaseLine[prevPointIndex]) {
+									const prev = prevBaseLine[prevPointIndex];
 									return {
-										...e,
-										x: r(t.x, e.x, a),
-										y: r(t.y, e.y, a)
+										...entry,
+										x: interpolate(prev.x, entry.x, t),
+										y: interpolate(prev.y, entry.y, t)
 									};
 								}
-								return e;
-							}), T.value = s, E.value = c;
+								return entry;
+							});
+							currentPoints.value = stepPoints;
+							currentBaseLine.value = stepBaseLine;
 						}
 					},
 					onPlay() {
-						x.onAnimationStart?.();
+						props.onAnimationStart?.();
 					},
 					onComplete() {
-						S.value = !1, x.onAnimationEnd?.();
+						isAnimating.value = false;
+						props.onAnimationEnd?.();
 					}
 				});
-				o(() => {
-					k = !0, a.stop(), D = T.value, O = E.value;
+				onCleanup(() => {
+					animationStopped = true;
+					animation.stop();
+					prevPoints = currentPoints.value;
+					prevBaseLine = currentBaseLine.value;
 				});
-			} else S.value = !1, T.value = i || [], E.value = b.value?.baseLine || [], D = T.value, O = E.value;
-		}, { immediate: !0 }), () => {
-			let e = {
-				...y,
-				fill: x.fill,
-				"fill-opacity": x.fillOpacity,
-				height: w.value.height,
-				width: w.value.width,
-				"stroke-width": x.strokeWidth
-			}, t = b.value?.isRange, n = !S.value && x.label, r = typeof x.label == "object" ? x.label : {};
-			return f(d, null, [
-				T.value && T.value.length > 1 && f(c, { "clip-path": x.needClip ? `url(#clipPath-${l.value})` : void 0 }, { default: () => [
-					f(i, m(e, {
-						points: T.value,
-						connectNulls: x.connectNulls,
-						type: x.type,
-						layout: p.value,
-						baseLine: E.value,
-						stroke: "none",
-						class: "v-charts-area-area"
+			} else {
+				isAnimating.value = false;
+				currentPoints.value = newPoints || [];
+				currentBaseLine.value = areaData.value?.baseLine || [];
+				prevPoints = currentPoints.value;
+				prevBaseLine = currentBaseLine.value;
+			}
+		}, { immediate: true });
+		return () => {
+			const curveAttrs = {
+				...attrs,
+				"fill": props.fill,
+				"fill-opacity": props.fillOpacity,
+				"height": offset.value.height,
+				"width": offset.value.width,
+				"stroke-width": props.strokeWidth
+			};
+			const isRange = areaData.value?.isRange;
+			const showLabels = !isAnimating.value && props.label;
+			const labelProps = typeof props.label === "object" ? props.label : {};
+			return createVNode(Fragment, null, [
+				currentPoints.value && currentPoints.value.length > 1 && createVNode(Layer, { "clip-path": props.needClip ? `url(#clipPath-${clipPathId.value})` : void 0 }, { default: () => [
+					createVNode(Curve, mergeProps(curveAttrs, {
+						"points": currentPoints.value,
+						"connectNulls": props.connectNulls,
+						"type": props.type,
+						"layout": layout.value,
+						"baseLine": currentBaseLine.value,
+						"stroke": "none",
+						"class": "v-charts-area-area"
 					}), null),
-					y.stroke !== "none" && f(i, m(e, {
-						layout: p.value,
-						type: x.type,
-						connectNulls: x.connectNulls,
-						fill: "none",
-						points: T.value,
-						stroke: x.stroke,
-						class: "v-charts-area-curve"
+					attrs.stroke !== "none" && createVNode(Curve, mergeProps(curveAttrs, {
+						"layout": layout.value,
+						"type": props.type,
+						"connectNulls": props.connectNulls,
+						"fill": "none",
+						"points": currentPoints.value,
+						"stroke": props.stroke,
+						"class": "v-charts-area-curve"
 					}), null),
-					y.stroke !== "none" && t && f(i, m(e, {
-						class: "v-charts-area-curve",
-						layout: p.value,
-						type: x.type,
-						connectNulls: x.connectNulls,
-						fill: "none",
-						points: E.value,
-						stroke: x.stroke
+					attrs.stroke !== "none" && isRange && createVNode(Curve, mergeProps(curveAttrs, {
+						"class": "v-charts-area-curve",
+						"layout": layout.value,
+						"type": props.type,
+						"connectNulls": props.connectNulls,
+						"fill": "none",
+						"points": currentBaseLine.value,
+						"stroke": props.stroke
 					}), null)
 				] }),
-				f(v, { points: T.value }, null),
-				n && f(u, m(r, {
-					data: b.value?.points ?? [],
-					dataKey: x.dataKey
+				createVNode(Dots, { "points": currentPoints.value }, null),
+				showLabels && createVNode(LabelList, mergeProps(labelProps, {
+					"data": areaData.value?.points ?? [],
+					"dataKey": props.dataKey
 				}), null)
 			]);
 		};
 	}
 });
-function b(e, t) {
-	return e == null || !e.length ? !1 : t ? !0 : e.length === 1;
+function shouldRenderDots(points, dot) {
+	if (points == null || !points.length) return false;
+	if (dot) return true;
+	return points.length === 1;
 }
 //#endregion
-export { y as StaticArea };
+export { StaticArea };

package/dist/es/cartesian/area/hooks/useArea.mjs

@@ -1,57 +1,81 @@
-import { uniqueId as e } from "../../../utils/data-utils.mjs";
-import { useIsPanorama as t } from "../../../context/PanoramaContextProvider.mjs";
-import { isClipDot as n } from "../../../utils/chart.mjs";
-import { useAppSelector as r } from "../../../state/hooks.mjs";
-import { useChartLayout as i } from "../../../context/chartLayoutContext.mjs";
-import { useChartName as a } from "../../../state/selectors/selectors.mjs";
-import { selectArea as o } from "../../../state/selectors/areaSelectors.mjs";
-import { filterProps as s } from "../../../utils/VueUtils.mjs";
-import { computed as c, inject as l, provide as u, ref as d, watch as f } from "vue";
+import { uniqueId } from "../../../utils/data-utils.mjs";
+import { useIsPanorama } from "../../../context/PanoramaContextProvider.mjs";
+import { isClipDot } from "../../../utils/chart.mjs";
+import { useAppSelector } from "../../../state/hooks.mjs";
+import { useChartLayout } from "../../../context/chartLayoutContext.mjs";
+import { useChartName } from "../../../state/selectors/selectors.mjs";
+import { selectArea } from "../../../state/selectors/areaSelectors.mjs";
+import { useIsAnimating } from "../../../hooks/useIsAnimating.mjs";
+import { filterProps } from "../../../utils/VueUtils.mjs";
+import { computed, inject, provide, ref, watch } from "vue";
 //#region src/cartesian/area/hooks/useArea.ts
-var p = Symbol("AreaContext");
-function m(e) {
-	u(p, e);
+var AreaContextKey = Symbol("AreaContext");
+function provideAreaContext(context) {
+	provide(AreaContextKey, context);
 }
-function h() {
-	let e = l(p);
-	if (!e) throw Error("useAreaContext must be used within Area component");
-	return e;
+function useAreaContext() {
+	const context = inject(AreaContextKey);
+	if (!context) throw new Error("useAreaContext must be used within Area component");
+	return context;
 }
-function g(l, u = {}, p) {
-	let h = i(), g = a(), _ = e("v-charts-area-"), v = c(() => l.id || _), y = t(), b = d(l.isAnimationActive), x = c(() => (h.value === "horizontal" || h.value === "vertical") && (g.value === "AreaChart" || g.value === "ComposedChart") && !l.hide), S = c(() => ({
-		baseValue: l.baseValue,
-		stackId: l.stackId,
-		connectNulls: l.connectNulls,
-		data: l.data,
-		dataKey: l.dataKey
-	})), C = r((e) => o(e, l.xAxisId, l.yAxisId, y, S.value)), w = d(!0);
-	f(() => l.hide, (e) => {
-		e || (w.value = !0);
+function useArea(props, attrs = {}, dotSlot) {
+	const layout = useChartLayout();
+	const chartName = useChartName();
+	const localId = uniqueId("v-charts-area-");
+	const clipPathId = computed(() => props.id || localId);
+	const isPanorama = useIsPanorama();
+	/**
+	* is Area animating
+	*/
+	const isAnimating = useIsAnimating(() => props.isAnimationActive);
+	/**
+	* render only when layout is horizontal or vertical and chartName is AreaChart or ComposedChart
+	*/
+	const shouldRender = computed(() => (layout.value === "horizontal" || layout.value === "vertical") && (chartName.value === "AreaChart" || chartName.value === "ComposedChart") && !props.hide);
+	const areaSettings = computed(() => ({
+		baseValue: props.baseValue,
+		stackId: props.stackId,
+		connectNulls: props.connectNulls,
+		data: props.data,
+		dataKey: props.dataKey
+	}));
+	const areaData = useAppSelector((state) => selectArea(state, props.xAxisId, props.yAxisId, isPanorama, areaSettings.value));
+	const isClipRectAnimating = ref(true);
+	watch(() => props.hide, (v) => {
+		if (!v) isClipRectAnimating.value = true;
 	});
-	let T = c(() => l.isAnimationActive && C.value?.points?.length && w.value), E = l.dot, D = n(E), { r: O = 3, strokeWidth: k = 2 } = s(E, !1) ?? {
+	const shouldShowAnimation = computed(() => {
+		return props.isAnimationActive && areaData.value?.points?.length && isClipRectAnimating.value;
+	});
+	const dot = props.dot;
+	const clipDot = isClipDot(dot);
+	const { r = 3, strokeWidth = 2 } = filterProps(dot, false) ?? {
 		r: 3,
 		strokeWidth: 2
-	}, A = O * 2 + k, j = {
-		clipPathId: v,
-		layout: h,
-		points: c(() => C.value?.points),
-		props: l,
-		attrs: u,
-		dot: E,
-		clipDot: D,
-		dotSize: A,
-		dotSlot: p,
-		areaData: C,
-		isAnimating: b,
-		isClipRectAnimating: w
 	};
-	return m(j), {
-		shouldRender: x,
-		areaData: C,
-		points: j.points,
-		clipPathId: v,
-		shouldShowAnimation: T
+	const dotSize = r * 2 + strokeWidth;
+	const areaContext = {
+		clipPathId,
+		layout,
+		points: computed(() => areaData.value?.points),
+		props,
+		attrs,
+		dot,
+		clipDot,
+		dotSize,
+		dotSlot,
+		areaData,
+		isAnimating,
+		isClipRectAnimating
+	};
+	provideAreaContext(areaContext);
+	return {
+		shouldRender,
+		areaData,
+		points: areaContext.points,
+		clipPathId,
+		shouldShowAnimation
 	};
 }
 //#endregion
-export { g as useArea, h as useAreaContext };
+export { useArea, useAreaContext };

package/dist/es/cartesian/area/type.mjs

@@ -1,10 +1,11 @@
-import { CurveVueProps as e } from "../../shape/Curve.mjs";
+import { classProp } from "../../types/common.mjs";
+import { CurveVueProps } from "../../shape/Curve.mjs";
 //#region src/cartesian/area/type.ts
-var t = {
-	...e,
+var AreaVueProps = {
+	...CurveVueProps,
 	activeDot: {
 		type: Boolean,
-		default: !0
+		default: true
 	},
 	baseValue: {
 		type: [Number, String],
@@ -12,7 +13,7 @@ var t = {
 	},
 	connectNulls: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	data: {
 		type: Array,
@@ -24,11 +25,11 @@ var t = {
 			Number,
 			Function
 		],
-		required: !0
+		required: true
 	},
 	dot: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	fill: {
 		type: String,
@@ -45,11 +46,11 @@ var t = {
 	},
 	hide: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	isAnimationActive: {
 		type: Boolean,
-		default: !0
+		default: true
 	},
 	label: {
 		type: [Boolean, Object],
@@ -76,7 +77,7 @@ var t = {
 	},
 	needClip: {
 		type: Boolean,
-		default: !1
+		default: false
 	},
 	stackId: {
 		type: [String, Number],
@@ -127,10 +128,7 @@ var t = {
 		default: 0
 	},
 	name: { type: [String, Number] },
-	class: {
-		type: String,
-		default: void 0
-	}
+	class: classProp
 };
 //#endregion
-export { t as AreaVueProps };
+export { AreaVueProps };

package/dist/es/cartesian/area/utils.mjs

@@ -1,59 +1,79 @@
-import { isNumber as e } from "../../utils/validate.mjs";
-import { getCateCoordinateOfLine as t, getValueByDataKey as n } from "../../utils/chart.mjs";
+import { isNumber } from "../../utils/validate.mjs";
+import { getCateCoordinateOfLine, getValueByDataKey } from "../../utils/chart.mjs";
 //#region src/cartesian/area/utils.ts
-function r(t, n, r, i, a) {
-	let o = r ?? n;
-	if (e(o)) return o;
-	let s = t === "horizontal" ? a : i, c = s.scale.domain();
-	if (s.type === "number") {
-		let e = Math.max(c[0], c[1]), t = Math.min(c[0], c[1]);
-		return o === "dataMin" ? t : o === "dataMax" || e < 0 ? e : Math.max(Math.min(c[0], c[1]), 0);
+function getBaseValue(layout, chartBaseValue, itemBaseValue, xAxis, yAxis) {
+	const baseValue = itemBaseValue ?? chartBaseValue;
+	if (isNumber(baseValue)) return baseValue;
+	const numericAxis = layout === "horizontal" ? yAxis : xAxis;
+	const domain = numericAxis.scale.domain();
+	if (numericAxis.type === "number") {
+		const domainMax = Math.max(domain[0], domain[1]);
+		const domainMin = Math.min(domain[0], domain[1]);
+		if (baseValue === "dataMin") return domainMin;
+		if (baseValue === "dataMax") return domainMax;
+		return domainMax < 0 ? domainMax : Math.max(Math.min(domain[0], domain[1]), 0);
 	}
-	return o === "dataMin" ? c[0] : o === "dataMax" ? c[1] : c[0];
+	if (baseValue === "dataMin") return domain[0];
+	if (baseValue === "dataMax") return domain[1];
+	return domain[0];
 }
-function i({ areaSettings: { connectNulls: e, baseValue: i, dataKey: a }, stackedData: o, layout: s, chartBaseValue: c, xAxis: l, yAxis: u, displayedData: d, dataStartIndex: f, xAxisTicks: p, yAxisTicks: m, bandSize: h }) {
-	let g = o && o.length, _ = r(s, c, i, l, u), v = s === "horizontal", y = !1, b = d.map((r, i) => {
-		let s;
-		g ? s = o[f + i] : (s = n(r, a), Array.isArray(s) ? y = !0 : s = [_, s]);
-		let c = s[1] == null || g && !e && n(r, a) == null;
-		return v ? {
-			x: t({
-				axis: l,
-				ticks: p,
-				bandSize: h,
-				entry: r,
-				index: i
+function computeArea({ areaSettings: { connectNulls, baseValue: itemBaseValue, dataKey }, stackedData, layout, chartBaseValue, xAxis, yAxis, displayedData, dataStartIndex, xAxisTicks, yAxisTicks, bandSize }) {
+	const hasStack = stackedData && stackedData.length;
+	const baseValue = getBaseValue(layout, chartBaseValue, itemBaseValue, xAxis, yAxis);
+	const isHorizontalLayout = layout === "horizontal";
+	let isRange = false;
+	const points = displayedData.map((entry, index) => {
+		let value;
+		if (hasStack) value = stackedData[dataStartIndex + index];
+		else {
+			value = getValueByDataKey(entry, dataKey);
+			if (!Array.isArray(value)) value = [baseValue, value];
+			else isRange = true;
+		}
+		const isBreakPoint = value[1] == null || hasStack && !connectNulls && getValueByDataKey(entry, dataKey) == null;
+		if (isHorizontalLayout) return {
+			x: getCateCoordinateOfLine({
+				axis: xAxis,
+				ticks: xAxisTicks,
+				bandSize,
+				entry,
+				index
 			}),
-			y: c ? null : u.scale(s[1]),
-			value: s,
-			payload: r
-		} : {
-			x: c ? null : l.scale(s[1]),
-			y: t({
-				axis: u,
-				ticks: m,
-				bandSize: h,
-				entry: r,
-				index: i
+			y: isBreakPoint ? null : yAxis.scale(value[1]),
+			value,
+			payload: entry
+		};
+		return {
+			x: isBreakPoint ? null : xAxis.scale(value[1]),
+			y: getCateCoordinateOfLine({
+				axis: yAxis,
+				ticks: yAxisTicks,
+				bandSize,
+				entry,
+				index
 			}),
-			value: s,
-			payload: r
+			value,
+			payload: entry
+		};
+	});
+	let baseLine;
+	if (hasStack || isRange) baseLine = points.map((entry) => {
+		const x = Array.isArray(entry.value) ? entry.value[0] : null;
+		if (isHorizontalLayout) return {
+			x: entry.x,
+			y: x != null && entry.y != null ? yAxis.scale(x) : null
 		};
-	}), x;
-	return x = g || y ? b.map((e) => {
-		let t = Array.isArray(e.value) ? e.value[0] : null;
-		return v ? {
-			x: e.x,
-			y: t != null && e.y != null ? u.scale(t) : null
-		} : {
-			x: t == null ? null : l.scale(t),
-			y: e.y
+		return {
+			x: x != null ? xAxis.scale(x) : null,
+			y: entry.y
 		};
-	}) : v ? u.scale(_) : l.scale(_), {
-		points: b,
-		baseLine: x,
-		isRange: y
+	});
+	else baseLine = isHorizontalLayout ? yAxis.scale(baseValue) : xAxis.scale(baseValue);
+	return {
+		points,
+		baseLine,
+		isRange
 	};
 }
 //#endregion
-export { i as computeArea };
+export { computeArea };