vccs 0.0.1 → 0.1.0

package/dist/es/cartesian/cartesian-axis/CartesianAxis.mjs

@@ -0,0 +1,246 @@
+import { isNumber as e } from "../../utils/validate.mjs";
+import { filterProps as t } from "../../utils/VueUtils.mjs";
+import { Layer as n } from "../../container/Layer.mjs";
+import r from "../../components/Text.mjs";
+import { Label as i } from "../../components/label/Label.mjs";
+import { getTicks as a } from "../utils/get-ticks.mjs";
+import { createVNode as o, defineComponent as s, mergeProps as c, reactive as l } from "vue";
+import { get as u } from "es-toolkit/compat";
+//#region src/cartesian/cartesian-axis/CartesianAxis.tsx
+var d = /* @__PURE__ */ s({
+	name: "CartesianAxis",
+	props: {
+		x: {
+			type: Number,
+			default: 0
+		},
+		y: {
+			type: Number,
+			default: 0
+		},
+		width: {
+			type: Number,
+			default: 0
+		},
+		height: {
+			type: Number,
+			default: 0
+		},
+		unit: [String, Number],
+		orientation: {
+			type: String,
+			default: "bottom"
+		},
+		viewBox: {
+			type: Object,
+			default: () => ({
+				x: 0,
+				y: 0,
+				width: 0,
+				height: 0
+			})
+		},
+		tick: {
+			type: Boolean,
+			default: !0
+		},
+		axisLine: {
+			type: [Boolean, Object],
+			default: () => !0
+		},
+		tickLine: {
+			type: [Boolean, Object],
+			default: () => !0
+		},
+		mirror: {
+			type: Boolean,
+			default: !1
+		},
+		tickMargin: {
+			type: Number,
+			default: 2
+		},
+		hide: Boolean,
+		label: null,
+		minTickGap: {
+			type: Number,
+			default: 5
+		},
+		ticks: {
+			type: Array,
+			default: () => []
+		},
+		tickSize: {
+			type: Number,
+			default: 6
+		},
+		tickFormatter: Function,
+		interval: {
+			type: [String, Number],
+			default: "preserveEnd"
+		},
+		angle: Number,
+		scale: { type: [Function] },
+		stroke: {
+			type: String,
+			default: "#666"
+		}
+	},
+	inheritAttrs: !1,
+	setup(s, { attrs: d, slots: f }) {
+		let p = l({
+			fontSize: "",
+			letterSpacing: ""
+		}), m = (t) => {
+			let { x: n, y: r, width: i, height: a, orientation: o, tickSize: c, mirror: l, tickMargin: u } = s, d, f, p, m, h, g, _ = l ? -1 : 1, v = t.tickSize || c, y = e(t.tickCoord) ? t.tickCoord : t.coordinate;
+			switch (o) {
+				case "top":
+					d = f = t.coordinate, m = r + +!l * a, p = m - _ * v, g = p - _ * u, h = y;
+					break;
+				case "left":
+					p = m = t.coordinate, f = n + +!l * i, d = f - _ * v, h = d - _ * u, g = y;
+					break;
+				case "right":
+					p = m = t.coordinate, f = n + +l * i, d = f + _ * v, h = d + _ * u, g = y;
+					break;
+				default:
+					d = f = t.coordinate, m = r + +l * a, p = m + _ * v, g = p + _ * u, h = y;
+					break;
+			}
+			return {
+				line: {
+					x1: d,
+					y1: p,
+					x2: f,
+					y2: m
+				},
+				tick: {
+					x: h,
+					y: g
+				}
+			};
+		}, h = () => {
+			let { orientation: e, mirror: t } = s, n;
+			switch (e) {
+				case "left":
+					n = t ? "start" : "end";
+					break;
+				case "right":
+					n = t ? "end" : "start";
+					break;
+				default:
+					n = "middle";
+					break;
+			}
+			return n;
+		}, g = () => {
+			let { orientation: e, mirror: t } = s;
+			switch (e) {
+				case "left":
+				case "right": return "middle";
+				case "top": return t ? "start" : "end";
+				default: return t ? "end" : "start";
+			}
+		}, _ = () => {
+			let { x: e, y: n, width: r, height: i, orientation: a, mirror: l, axisLine: d } = s, f = {
+				...t(s, !1),
+				...t(d, !1),
+				fill: "none",
+				x1: 0,
+				y1: 0,
+				x2: 0,
+				y2: 0
+			};
+			if (a === "top" || a === "bottom") {
+				let t = +(a === "top" && !l || a === "bottom" && l);
+				f = {
+					...f,
+					x1: e,
+					y1: n + t * i,
+					x2: e + r,
+					y2: n + t * i
+				};
+			} else {
+				let t = +(a === "left" && !l || a === "right" && l);
+				f = {
+					...f,
+					x1: e + t * r,
+					y1: n,
+					x2: e + t * r,
+					y2: n + i
+				};
+			}
+			return o("line", c(f, { class: ["v-charts-cartesian-axis-line", u(d, "class")] }), null);
+		};
+		function v(e, t) {
+			return o(r, c(e, {
+				class: ["v-charts-cartesian-axis-tick-value", e.class],
+				value: t
+			}), null);
+		}
+		let y = (e, r, i) => {
+			let { tickLine: s, stroke: l, tick: d, tickFormatter: p, unit: _ } = e, y = a(e, r, i), b = h(), x = g(), S = t(e, !1), C = t(d, !1), w = {
+				...S,
+				fill: "none",
+				...t(s, !1)
+			}, T = y.map((e, t) => {
+				let { line: r, tick: i } = m(e), a = {
+					textAnchor: b,
+					verticalAnchor: x,
+					...S,
+					stroke: "none",
+					fill: l,
+					...C,
+					...i,
+					index: t,
+					payload: e,
+					visibleTicksCount: y.length,
+					tickFormatter: p
+				};
+				return o(n, {
+					class: "v-charts-cartesian-axis-tick",
+					key: `tick-${e.value}-${e.coordinate}-${e.tickCoord}`
+				}, { default: () => [s && o("line", c(w, r, { class: ["v-charts-cartesian-axis-tick-line", u(s, "class")] }), null), d && (f.tick ? f.tick({
+					...a,
+					value: e.value
+				}) : v(a, `${typeof p == "function" ? p(e.value, t) : e.value}${_ || ""}`))] });
+			});
+			return T.length > 0 ? o("g", { class: "v-charts-cartesian-axis-ticks" }, [T]) : null;
+		}, b = () => {
+			let { label: e, x: t, y: n, width: r, height: a } = s;
+			if (!e) return null;
+			let l = {
+				x: t,
+				y: n,
+				width: r,
+				height: a
+			};
+			return typeof e == "string" || typeof e == "number" ? o(i, {
+				value: e,
+				viewBox: l
+			}, null) : typeof e == "object" ? o(i, c(e, { viewBox: l }), null) : null;
+		};
+		return () => {
+			let { axisLine: e, width: t, height: r, hide: i } = s;
+			return i || t != null && t <= 0 || r != null && r <= 0 ? null : o(n, {
+				class: ["v-charts-cartesian-axis", d.class],
+				ref: (e) => {
+					let t = e?.$el;
+					if (t) {
+						let e = t?.getElementsByClassName("v-charts-cartesian-axis-tick-value")[0];
+						if (e) {
+							let t = window.getComputedStyle(e).fontSize, n = window.getComputedStyle(e).letterSpacing;
+							(t !== p.fontSize || n !== p.letterSpacing) && (p.fontSize = window.getComputedStyle(e).fontSize, p.letterSpacing = window.getComputedStyle(e).letterSpacing);
+						}
+					}
+				}
+			}, { default: () => [
+				e && _(),
+				y(s, p.fontSize, p.letterSpacing),
+				b()
+			] });
+		};
+	}
+});
+//#endregion
+export { d as CartesianAxis };

package/dist/es/cartesian/cartesian-grid/Background.mjs

@@ -0,0 +1,30 @@
+import { createVNode as e, defineComponent as t } from "vue";
+//#region src/cartesian/cartesian-grid/Background.tsx
+var n = /* @__PURE__ */ t({
+	name: "Background",
+	inheritAttrs: !1,
+	props: {
+		fill: String,
+		fillOpacity: Number,
+		x: Number,
+		y: Number,
+		width: Number,
+		height: Number,
+		ry: Number
+	},
+	setup(t) {
+		return () => !t.fill || t.fill === "none" ? null : e("rect", {
+			x: t.x,
+			y: t.y,
+			ry: t.ry,
+			width: t.width,
+			height: t.height,
+			stroke: "none",
+			fill: t.fill,
+			"fill-opacity": t.fillOpacity,
+			class: "v-charts-cartesian-grid-bg"
+		}, null);
+	}
+});
+//#endregion
+export { n as default };

package/dist/es/cartesian/cartesian-grid/CartesianGrid.mjs

@@ -0,0 +1,155 @@
+import { isNumber as e } from "../../utils/validate.mjs";
+import { warn as t } from "../../utils/log.mjs";
+import { useIsPanorama as n } from "../../context/PanoramaContextProvider.mjs";
+import { getTicksOfAxis as r } from "../../utils/chart.mjs";
+import { selectAxisPropsNeededForCartesianGridTicksGenerator as i } from "../../state/selectors/axisSelectors.mjs";
+import { useAppSelector as a } from "../../state/hooks.mjs";
+import { useChartHeight as o, useChartWidth as s, useOffset as c } from "../../context/chartLayoutContext.mjs";
+import { CartesianAxisDefaultProps as l } from "./const.mjs";
+import { getTicks as u } from "../utils/get-ticks.mjs";
+import { CartesianAxis as d } from "../cartesian-axis/CartesianAxis.mjs";
+import { resolveDefaultProps as f } from "../../utils/resolveDefaultProps.mjs";
+import { getCoordinatesOfGrid as p } from "../../utils/grid.mjs";
+import m from "./Background.mjs";
+import h from "./HorizontalStripes.mjs";
+import g from "./VerticalStripes.mjs";
+import _ from "./HorizontalGridLines.mjs";
+import v from "./VerticalGridLines.mjs";
+import { createVNode as y, defineComponent as b, mergeProps as x } from "vue";
+//#region src/cartesian/cartesian-grid/CartesianGrid.tsx
+var S = ({ yAxis: e, width: t, height: n, offset: i }, a) => p(u({
+	...l,
+	...e,
+	ticks: r(e, !0),
+	viewBox: {
+		x: 0,
+		y: 0,
+		width: t,
+		height: n
+	}
+}), i.top, i.top + i.height, a), C = ({ xAxis: e, width: t, height: n, offset: i }, a) => p(u({
+	...d.defaultProps,
+	...e,
+	ticks: r(e, !0),
+	viewBox: {
+		x: 0,
+		y: 0,
+		width: t,
+		height: n
+	}
+}), i.left, i.left + i.width, a), w = {
+	horizontal: !0,
+	vertical: !0,
+	horizontalPoints: [],
+	verticalPoints: [],
+	stroke: "#ccc",
+	fill: "none",
+	verticalFill: [],
+	horizontalFill: [],
+	xAxisId: 0,
+	yAxisId: 0
+}, T = /* @__PURE__ */ b({
+	name: "CartesianGrid",
+	inheritAttrs: !1,
+	props: {
+		xAxisId: {
+			type: [String, Number],
+			default: 0
+		},
+		yAxisId: {
+			type: [String, Number],
+			default: 0
+		},
+		x: Number,
+		y: Number,
+		width: Number,
+		height: Number,
+		syncWithTicks: {
+			type: Boolean,
+			default: void 0
+		},
+		horizontal: {
+			type: [Boolean, Object],
+			default: !0
+		},
+		vertical: {
+			type: [Boolean, Object],
+			default: !0
+		},
+		horizontalPoints: Array,
+		verticalPoints: Array,
+		horizontalValues: Array,
+		verticalValues: Array,
+		fill: String,
+		fillOpacity: Number,
+		ry: Number,
+		verticalCoordinatesGenerator: Function,
+		horizontalCoordinatesGenerator: Function
+	},
+	setup(r, { attrs: l, slots: u }) {
+		let d = s(), p = o(), b = c(), T = n(), E = a((e) => i(e, "xAxis", r.xAxisId, T)), D = a((e) => i(e, "yAxis", r.yAxisId, T));
+		return () => {
+			let n = {
+				...f({
+					...r,
+					...l
+				}, w),
+				x: e(r.x) ? r.x : b.value.left,
+				y: e(r.y) ? r.y : b.value.top,
+				width: e(r.width) ? r.width : b.value.width,
+				height: e(r.height) ? r.height : b.value.height
+			}, { x: i, y: a, width: o, height: s, syncWithTicks: c, horizontalValues: T, verticalValues: O } = n, k = n.verticalCoordinatesGenerator || C, A = n.horizontalCoordinatesGenerator || S, { horizontalPoints: j, verticalPoints: M } = n;
+			if ((!j || !j.length) && typeof A == "function") {
+				let e = T && T.length, n = A({
+					yAxis: D.value ? {
+						...D.value,
+						ticks: e ? T : D.value?.ticks
+					} : void 0,
+					width: d.value,
+					height: p.value,
+					offset: b.value
+				}, e ? !0 : c);
+				t(Array.isArray(n), `horizontalCoordinatesGenerator should return Array but instead it returned [${typeof n}]`), Array.isArray(n) && (j = n);
+			}
+			if ((!M || !M.length) && typeof k == "function") {
+				let e = O && O.length, n = k({
+					xAxis: E.value ? {
+						...E.value,
+						ticks: e ? O : E.value?.ticks
+					} : void 0,
+					width: d.value,
+					height: p.value,
+					offset: b.value
+				}, e ? !0 : c);
+				t(Array.isArray(n), `verticalCoordinatesGenerator should return Array but instead it returned [${typeof n}]`), Array.isArray(n) && (M = n);
+			}
+			return !e(o) || o <= 0 || !e(s) || s <= 0 || !e(i) || i !== +i || !e(a) || a !== +a ? null : y("g", { class: "v-charts-cartesian-grid" }, [
+				y(m, {
+					fill: n.fill,
+					fillOpacity: n.fillOpacity,
+					x: n.x,
+					y: n.y,
+					width: n.width,
+					height: n.height,
+					ry: n.ry
+				}, null),
+				y(h, x(n, { horizontalPoints: j }), null),
+				y(g, x(n, { verticalPoints: M }), null),
+				y(_, x(n, {
+					offset: b.value,
+					horizontalPoints: j,
+					xAxis: E.value,
+					yAxis: D.value
+				}), { default: () => [u.horizontal ? { horizontal: u.horizontal } : void 0] }),
+				y(v, x(n, {
+					offset: b,
+					verticalPoints: M,
+					xAxis: E,
+					yAxis: D
+				}), { default: () => [u.vertical ? { vertical: u.vertical } : void 0] })
+			]);
+		};
+	}
+});
+//#endregion
+export { T as CartesianGrid };

package/dist/es/cartesian/cartesian-grid/HorizontalGridLines.mjs

@@ -0,0 +1,49 @@
+import { renderLineItem as e } from "./utils.mjs";
+import { createVNode as t, defineComponent as n } from "vue";
+//#region src/cartesian/cartesian-grid/HorizontalGridLines.tsx
+var r = /* @__PURE__ */ n({
+	name: "HorizontalGridLines",
+	inheritAttrs: !1,
+	props: {
+		x: Number,
+		width: Number,
+		horizontal: [Boolean, Object],
+		horizontalPoints: Array,
+		xAxisId: {
+			type: [String, Number],
+			default: 0
+		},
+		yAxisId: {
+			type: [String, Number],
+			default: 0
+		},
+		offset: Object,
+		xAxis: Object,
+		yAxis: Object
+	},
+	setup(n, { attrs: r, slots: i }) {
+		return () => {
+			let { x: a, width: o, horizontal: s = !0, horizontalPoints: c } = n;
+			if (!s || !c || !c.length) return null;
+			let { xAxisId: l, yAxisId: u, ...d } = {
+				...n,
+				...r
+			};
+			return t("g", { class: "v-charts-cartesian-grid-horizontal" }, [c.map((t, n) => {
+				let c = {
+					...d,
+					...r,
+					x1: a,
+					y1: t,
+					x2: a + o,
+					y2: t,
+					key: `line-${n}`,
+					index: n
+				};
+				return e(i.horizontal, s, c);
+			})]);
+		};
+	}
+});
+//#endregion
+export { r as default };

package/dist/es/cartesian/cartesian-grid/HorizontalStripes.mjs

@@ -0,0 +1,43 @@
+import { createVNode as e, defineComponent as t } from "vue";
+//#region src/cartesian/cartesian-grid/HorizontalStripes.tsx
+var n = /* @__PURE__ */ t({
+	name: "HorizontalStripes",
+	inheritAttrs: !1,
+	props: {
+		horizontalFill: Array,
+		fillOpacity: Number,
+		x: Number,
+		y: Number,
+		width: Number,
+		height: Number,
+		horizontalPoints: Array,
+		horizontal: [Boolean, Object]
+	},
+	setup(t) {
+		return () => {
+			let { horizontalFill: n, fillOpacity: r, x: i, y: a, width: o, height: s, horizontalPoints: c, horizontal: l = !0 } = t;
+			if (!l || !n || !n.length) return null;
+			let u = c?.map((e) => Math.round(e + a - a)).sort((e, t) => e - t);
+			a !== u?.[0] && u?.unshift(0);
+			let d = u?.map((t, c) => {
+				let l = u[c + 1] ? u[c + 1] - t : a + s - t;
+				if (l <= 0) return null;
+				let d = c % n.length;
+				return e("rect", {
+					key: `react-${c}`,
+					y: t,
+					x: i,
+					height: l,
+					width: o,
+					stroke: "none",
+					fill: n[d],
+					"fill-opacity": r,
+					class: "v-charts-cartesian-grid-bg"
+				}, null);
+			});
+			return e("g", { class: "v-charts-cartesian-gridstripes-horizontal" }, [d]);
+		};
+	}
+});
+//#endregion
+export { n as default };

package/dist/es/cartesian/cartesian-grid/VerticalGridLines.mjs

@@ -0,0 +1,44 @@
+import { renderLineItem as e } from "./utils.mjs";
+import { createVNode as t, defineComponent as n } from "vue";
+//#region src/cartesian/cartesian-grid/VerticalGridLines.tsx
+var r = /* @__PURE__ */ n({
+	name: "VerticalGridLines",
+	inheritAttrs: !1,
+	props: {
+		x: Number,
+		y: Number,
+		width: Number,
+		height: Number,
+		verticalPoints: Array,
+		xAxisId: [String, Number],
+		yAxisId: [String, Number],
+		offset: Object,
+		xAxis: Object,
+		yAxis: Object,
+		vertical: [Boolean, Object]
+	},
+	setup(n, { attrs: r, slots: i }) {
+		return () => {
+			let { y: a, height: o, vertical: s = !0, verticalPoints: c } = n;
+			if (!s || !c || !c.length) return null;
+			let { xAxisId: l, yAxisId: u, ...d } = {
+				...n,
+				...r
+			};
+			return t("g", { class: "v-charts-cartesian-grid-vertical" }, [c.map((t, n) => {
+				let r = {
+					...d,
+					x1: t,
+					y1: a,
+					x2: t,
+					y2: a + o,
+					key: `line-${n}`,
+					index: n
+				};
+				return e(i.vertical, s, r);
+			})]);
+		};
+	}
+});
+//#endregion
+export { r as default };

package/dist/es/cartesian/cartesian-grid/VerticalStripes.mjs

@@ -0,0 +1,43 @@
+import { createVNode as e, defineComponent as t } from "vue";
+//#region src/cartesian/cartesian-grid/VerticalStripes.tsx
+var n = /* @__PURE__ */ t({
+	name: "VerticalStripes",
+	inheritAttrs: !1,
+	props: {
+		verticalFill: Array,
+		fillOpacity: Number,
+		x: Number,
+		y: Number,
+		width: Number,
+		height: Number,
+		verticalPoints: Array,
+		vertical: [Boolean, Object]
+	},
+	setup(t) {
+		return () => {
+			let { verticalFill: n, fillOpacity: r, x: i, y: a, width: o, height: s, verticalPoints: c, vertical: l = !0 } = t;
+			if (!l || !n || !n.length) return null;
+			let u = c?.map((e) => Math.round(e + i - i)).sort((e, t) => e - t);
+			i !== u?.[0] && u?.unshift(0);
+			let d = u?.map((t, c) => {
+				let l = u[c + 1] ? u[c + 1] - t : i + o - t;
+				if (l <= 0) return null;
+				let d = c % n.length;
+				return e("rect", {
+					key: `react-${c}`,
+					x: t,
+					y: a,
+					width: l,
+					height: s,
+					stroke: "none",
+					fill: n[d],
+					"fill-opacity": r,
+					class: "v-charts-cartesian-grid-bg"
+				}, null);
+			});
+			return e("g", { class: "v-charts-cartesian-gridstripes-vertical" }, [d]);
+		};
+	}
+});
+//#endregion
+export { n as default };

package/dist/es/cartesian/cartesian-grid/const.mjs

@@ -0,0 +1,29 @@
+//#region src/cartesian/cartesian-grid/const.ts
+var e = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0,
+	viewBox: {
+		x: 0,
+		y: 0,
+		width: 0,
+		height: 0
+	},
+	orientation: "bottom",
+	ticks: [],
+	stroke: "#666",
+	tickLine: !0,
+	axisLine: !0,
+	mirror: !1,
+	minTickGap: 5,
+	tickSize: 6,
+	tickMargin: 2,
+	interval: "preserveEnd"
+}, t = ["viewBox"], n = ["points", "pathLength"], r = {
+	svg: t,
+	polygon: n,
+	polyline: n
+}, i = /* @__PURE__ */ "aria-activedescendant.aria-atomic.aria-autocomplete.aria-busy.aria-checked.aria-colcount.aria-colindex.aria-colspan.aria-controls.aria-current.aria-describedby.aria-details.aria-disabled.aria-errormessage.aria-expanded.aria-flowto.aria-haspopup.aria-hidden.aria-invalid.aria-keyshortcuts.aria-label.aria-labelledby.aria-level.aria-live.aria-modal.aria-multiline.aria-multiselectable.aria-orientation.aria-owns.aria-placeholder.aria-posinset.aria-pressed.aria-readonly.aria-relevant.aria-required.aria-roledescription.aria-rowcount.aria-rowindex.aria-rowspan.aria-selected.aria-setsize.aria-sort.aria-valuemax.aria-valuemin.aria-valuenow.aria-valuetext.class.color.height.id.lang.max.media.method.min.name.style.target.width.role.tabIndex.accentHeight.accumulate.additive.alignmentBaseline.allowReorder.alphabetic.amplitude.arabicForm.ascent.attributeName.attributeType.autoReverse.azimuth.baseFrequency.baselineShift.baseProfile.bbox.begin.bias.by.calcMode.capHeight.clip.clipPath.clipPathUnits.clipRule.colorInterpolation.colorInterpolationFilters.colorProfile.colorRendering.contentScriptType.contentStyleType.cursor.cx.cy.d.decelerate.descent.diffuseConstant.direction.display.divisor.dominantBaseline.dur.dx.dy.edgeMode.elevation.enableBackground.end.exponent.externalResourcesRequired.fill.fillOpacity.fillRule.filter.filterRes.filterUnits.floodColor.floodOpacity.focusable.fontFamily.fontSize.fontSizeAdjust.fontStretch.fontStyle.fontVariant.fontWeight.format.from.fx.fy.g1.g2.glyphName.glyphOrientationHorizontal.glyphOrientationVertical.glyphRef.gradientTransform.gradientUnits.hanging.horizAdvX.horizOriginX.href.ideographic.imageRendering.in2.in.intercept.k1.k2.k3.k4.k.kernelMatrix.kernelUnitLength.kerning.keyPoints.keySplines.keyTimes.lengthAdjust.letterSpacing.lightingColor.limitingConeAngle.local.markerEnd.markerHeight.markerMid.markerStart.markerUnits.markerWidth.mask.maskContentUnits.maskUnits.mathematical.mode.numOctaves.offset.opacity.operator.order.orient.orientation.origin.overflow.overlinePosition.overlineThickness.paintOrder.panose1.pathLength.patternContentUnits.patternTransform.patternUnits.pointerEvents.pointsAtX.pointsAtY.pointsAtZ.preserveAlpha.preserveAspectRatio.primitiveUnits.r.radius.refX.refY.renderingIntent.repeatCount.repeatDur.requiredExtensions.requiredFeatures.restart.result.rotate.rx.ry.seed.shapeRendering.slope.spacing.specularConstant.specularExponent.speed.spreadMethod.startOffset.stdDeviation.stemh.stemv.stitchTiles.stopColor.stopOpacity.strikethroughPosition.strikethroughThickness.string.stroke.stroke-dasharray.strokeDashoffset.strokeLinecap.strokeLinejoin.strokeMiterlimit.strokeOpacity.strokeWidth.surfaceScale.systemLanguage.tableValues.targetX.targetY.textAnchor.textDecoration.textLength.textRendering.to.transform.u1.u2.underlinePosition.underlineThickness.unicode.unicodeBidi.unicodeRange.unitsPerEm.vAlphabetic.values.vectorEffect.version.vertAdvY.vertOriginX.vertOriginY.vHanging.vIdeographic.viewTarget.visibility.vMathematical.widths.wordSpacing.writingMode.x1.x2.x.xChannelSelector.xHeight.xlinkActuate.xlinkArcrole.xlinkHref.xlinkRole.xlinkShow.xlinkTitle.xlinkType.xmlBase.xmlLang.xmlns.xmlnsXlink.xmlSpace.y1.y2.y.yChannelSelector.z.zoomAndPan.ref.key.angle".split(".");
+//#endregion
+export { e as CartesianAxisDefaultProps, r as FilteredElementKeyMap, i as SVGElementPropKeys };

package/dist/es/cartesian/cartesian-grid/utils.mjs

@@ -0,0 +1,17 @@
+import { filterProps as e } from "../../utils/VueUtils.mjs";
+import { createVNode as t, mergeProps as n } from "vue";
+//#region src/cartesian/cartesian-grid/utils.tsx
+function r(r, i, a) {
+	if (r) return r(a);
+	let { x1: o, y1: s, x2: c, y2: l, key: u, ...d } = { ...a }, { offset: f, ...p } = e(d, !1);
+	return t("line", n(p, {
+		x1: o,
+		y1: s,
+		x2: c,
+		y2: l,
+		fill: "none",
+		key: u
+	}), null);
+}
+//#endregion
+export { r as renderLineItem };