vccs 0.0.1 → 0.1.0

package/dist/es/utils/polar.mjs

@@ -0,0 +1,52 @@
+//#region src/utils/polar.ts
+var e = Math.PI / 180, t = (e) => e * 180 / Math.PI;
+function n(e, t) {
+	let { x: n, y: r } = e, { x: i, y: a } = t;
+	return Math.sqrt((n - i) ** 2 + (r - a) ** 2);
+}
+function r({ startAngle: e, endAngle: t }) {
+	let n = Math.floor(e / 360), r = Math.floor(t / 360), i = Math.min(n, r);
+	return {
+		startAngle: e - i * 360,
+		endAngle: t - i * 360
+	};
+}
+function i({ x: e, y: r }, { cx: i, cy: a }) {
+	let o = n({
+		x: e,
+		y: r
+	}, {
+		x: i,
+		y: a
+	});
+	if (o <= 0) return {
+		radius: o,
+		angle: 0
+	};
+	let s = (e - i) / o, c = Math.acos(s);
+	return r > a && (c = 2 * Math.PI - c), {
+		radius: o,
+		angle: t(c),
+		angleInRadian: c
+	};
+}
+function a(e, { startAngle: t, endAngle: n }) {
+	let r = Math.floor(t / 360), i = Math.floor(n / 360);
+	return e + Math.min(r, i) * 360;
+}
+function o(t, n, r, i) {
+	return {
+		x: t + Math.cos(-e * i) * r,
+		y: n + Math.sin(-e * i) * r
+	};
+}
+function s(e, t, n = {
+	top: 0,
+	right: 0,
+	bottom: 0,
+	left: 0
+}) {
+	return Math.min(Math.abs(e - (n.left || 0) - (n.right || 0)), Math.abs(t - (n.top || 0) - (n.bottom || 0))) / 2;
+}
+//#endregion
+export { e as RADIAN, r as formatAngleOfSector, i as getAngleOfPoint, s as getMaxRadius, o as polarToCartesian, a as reverseFormatAngleOfSector };

package/dist/es/utils/props.mjs

@@ -0,0 +1,14 @@
+//#region src/utils/props.ts
+function e(e, t) {
+	let n = { ...e };
+	for (let [e, r] of Object.entries(t)) if (e in n) {
+		let t = n[e];
+		typeof t == "object" && t && "type" in t && (n[e] = {
+			...t,
+			default: r
+		});
+	}
+	return n;
+}
+//#endregion
+export { e as applyDefaultProps };

package/dist/es/utils/resolveDefaultProps.mjs

@@ -0,0 +1,7 @@
+//#region src/utils/resolveDefaultProps.ts
+function e(e, t) {
+	let n = { ...e }, r = t;
+	return Object.keys(t).reduce((e, t) => (e[t] === void 0 && r[t] !== void 0 && (e[t] = r[t]), e), n);
+}
+//#endregion
+export { e as resolveDefaultProps };

package/dist/es/utils/scale/getNiceTickValues.mjs

@@ -0,0 +1,59 @@
+import { compose as e, map as t, memoize as n, range as r, reverse as i } from "./utils/utils.mjs";
+import { getDigitCount as a, rangeStep as o } from "./utils/arithmetic.mjs";
+import s from "decimal.js-light";
+//#region src/utils/scale/getNiceTickValues.ts
+function c([e, t]) {
+	let [n, r] = [e, t];
+	return e > t && ([n, r] = [t, e]), [n, r];
+}
+function l(e, t, n) {
+	if (e.lte(0)) return new s(0);
+	let r = a(e.toNumber()), i = new s(10).pow(r), o = e.div(i), c = r === 1 ? .1 : .05, l = new s(Math.ceil(o.div(c).toNumber())).add(n).mul(c).mul(i);
+	return t ? new s(l.toNumber()) : new s(Math.ceil(l.toNumber()));
+}
+function u(n, i, o) {
+	let c = new s(1), l = new s(n);
+	if (!l.isint() && o) {
+		let e = Math.abs(n);
+		e < 1 ? (c = new s(10).pow(a(n) - 1), l = new s(Math.floor(l.div(c).toNumber())).mul(c)) : e > 1 && (l = new s(Math.floor(n)));
+	} else n === 0 ? l = new s(Math.floor((i - 1) / 2)) : o || (l = new s(Math.floor(n)));
+	let u = Math.floor((i - 1) / 2);
+	return e(t((e) => l.add(new s(e - u).mul(c)).toNumber()), r)(0, i);
+}
+function d(e, t, n, r, i = 0) {
+	if (!Number.isFinite((t - e) / (n - 1))) return {
+		step: new s(0),
+		tickMin: new s(0),
+		tickMax: new s(0)
+	};
+	let a = l(new s(t).sub(e).div(n - 1), r, i), o;
+	e <= 0 && t >= 0 ? o = new s(0) : (o = new s(e).add(t).div(2), o = o.sub(new s(o).mod(a)));
+	let c = Math.ceil(o.sub(e).div(a).toNumber()), u = Math.ceil(new s(t).sub(o).div(a).toNumber()), f = c + u + 1;
+	return f > n ? d(e, t, n, r, i + 1) : (f < n && (u = t > 0 ? u + (n - f) : u, c = t > 0 ? c : c + (n - f)), {
+		step: a,
+		tickMin: o.sub(new s(c).mul(a)),
+		tickMax: o.add(new s(u).mul(a))
+	});
+}
+function f([e, t], n = 6, a = !0) {
+	if (!Number.isFinite(e) || !Number.isFinite(t)) return [];
+	let l = Math.max(n, 2), [f, p] = c([e, t]);
+	if (f === -Infinity || p === Infinity) {
+		let a = p === Infinity ? [f, ...r(0, n - 1).map(() => Infinity)] : [...r(0, n - 1).map(() => -Infinity), p];
+		return e > t ? i(a) : a;
+	}
+	if (f === p) return u(f, n, a);
+	let { step: m, tickMin: h, tickMax: g } = d(f, p, l, a, 0), _ = o(h, g.add(new s(.1).mul(m)), m);
+	return e > t ? i(_) : _;
+}
+function p([e, t], n, r = !0) {
+	if (!Number.isFinite(e) || !Number.isFinite(t)) return [];
+	let [a, u] = c([e, t]);
+	if (a === -Infinity || u === Infinity) return [e, t];
+	if (a === u) return [a];
+	let d = Math.max(n, 2), f = l(new s(u).sub(a).div(d - 1), r, 0), p = [...o(new s(a), new s(u).sub(new s(.99).mul(f)), f), u];
+	return e > t ? i(p) : p;
+}
+var m = n(f), h = n(p);
+//#endregion
+export { m as getNiceTickValues, h as getTickValuesFixedDomain };

package/dist/es/utils/scale/utils/arithmetic.mjs

@@ -0,0 +1,24 @@
+import { curry as e } from "./utils.mjs";
+import t from "decimal.js-light";
+//#region src/utils/scale/utils/arithmetic.ts
+function n(e) {
+	let n;
+	return n = e === 0 ? 1 : Math.floor(new t(e).abs().log(10).toNumber()) + 1, n;
+}
+function r(e, n, r) {
+	let i = new t(e), a = 0, o = [];
+	for (; i.lt(n) && a < 1e5;) o.push(i.toNumber()), i = i.add(r), a++;
+	return o;
+}
+e((e, t, n) => {
+	let r = +e;
+	return r + n * (+t - r);
+}), e((e, t, n) => {
+	let r = t - +e;
+	return r ||= Infinity, (n - e) / r;
+}), e((e, t, n) => {
+	let r = t - +e;
+	return r ||= Infinity, Math.max(0, Math.min(1, (n - e) / r));
+});
+//#endregion
+export { n as getDigitCount, r as rangeStep };

package/dist/es/utils/scale/utils/utils.mjs

@@ -0,0 +1,34 @@
+//#region src/utils/scale/utils/utils.ts
+var e = (e) => e, t = { "@@functional/placeholder": !0 }, n = (e) => e === t;
+function r(e) {
+	return function t(...r) {
+		return r.length === 0 || r.length === 1 && n(r[0]) ? t : e(...r);
+	};
+}
+function i(e, a) {
+	return e === 1 ? a : r((...o) => {
+		let s = o.filter((e) => e !== t).length;
+		return s >= e ? a(...o) : i(e - s, r((...e) => a(...o.map((t) => n(t) ? e.shift() : t), ...e)));
+	});
+}
+var a = (e) => i(e.length, e);
+function o(e, t) {
+	let n = [];
+	for (let r = e; r < t; ++r) n[r - e] = r;
+	return n;
+}
+var s = a((e, t) => Array.isArray(t) ? t.map(e) : Object.keys(t).map((e) => t[e]).map(e));
+function c(...t) {
+	if (!t.length) return e;
+	let n = t.reverse(), r = n[0], i = n.slice(1);
+	return (...e) => i.reduce((e, t) => t(e), r(...e));
+}
+function l(e) {
+	return Array.isArray(e) ? e.reverse() : e.split("").reverse().join("");
+}
+function u(e) {
+	let t = null, n = null;
+	return ((...r) => t && r.every((e, n) => e === t?.[n]) ? n : (t = r, n = e(...r), n));
+}
+//#endregion
+export { c as compose, a as curry, s as map, u as memoize, o as range, l as reverse };

package/dist/es/utils/style.mjs

@@ -0,0 +1,19 @@
+import { isNumber as e } from "./validate.mjs";
+//#region src/utils/style.ts
+function t(t) {
+	if (t !== void 0) return e(t) ? `${t}px` : t;
+}
+function n(e = {}) {
+	let { height: n, width: r, minHeight: i, maxHeight: a, minWidth: o, maxWidth: s, ...c } = e;
+	return {
+		height: t(n),
+		width: t(r),
+		minHeight: t(i),
+		maxHeight: t(a),
+		minWidth: t(o),
+		maxWidth: t(s),
+		...c
+	};
+}
+//#endregion
+export { n as normalizeStyle };

package/dist/es/utils/tick.mjs

@@ -0,0 +1,31 @@
+import { getAngledRectangleWidth as e } from "./cartesian.mjs";
+//#region src/utils/tick.ts
+function t(e, t) {
+	return n(e, t + 1);
+}
+function n(e, t, n) {
+	if (t < 1) return [];
+	if (t === 1 && n === void 0) return e;
+	let r = [];
+	for (let i = 0; i < e.length; i += t) if (n === void 0 || n(e[i]) === !0) r.push(e[i]);
+	else return;
+	return r;
+}
+function r(t, n, r) {
+	return e({
+		width: t.width + n.width,
+		height: t.height + n.height
+	}, r);
+}
+function i(e, t, n) {
+	let r = n === "width", { x: i, y: a, width: o, height: s } = e;
+	return t === 1 ? {
+		start: r ? i : a,
+		end: r ? i + o : a + s
+	} : {
+		start: r ? i + o : a + s,
+		end: r ? i : a
+	};
+}
+//#endregion
+export { r as getAngledTickWidth, n as getEveryNthWithCondition, t as getNumberIntervalTicks, i as getTickBoundaries };

package/dist/es/utils/tooltip/translate.mjs

@@ -0,0 +1,59 @@
+import { isNumber as e } from "../validate.mjs";
+//#region src/utils/tooltip/translate.ts
+var t = "v-charts-tooltip-wrapper", n = { visibility: "hidden" };
+function r({ coordinate: n, translateX: r, translateY: i }) {
+	return [t, {
+		[`${t}-right`]: e(r) && n && e(n.x) && r >= n.x,
+		[`${t}-left`]: e(r) && n && e(n.x) && r < n.x,
+		[`${t}-bottom`]: e(i) && n && e(n.y) && i >= n.y,
+		[`${t}-top`]: e(i) && n && e(n.y) && i < n.y
+	}];
+}
+function i({ allowEscapeViewBox: t, coordinate: n, key: r, offsetTopLeft: i, position: a, reverseDirection: o, tooltipDimension: s, viewBox: c, viewBoxDimension: l }) {
+	if (a && e(a[r])) return a[r];
+	let u = n[r] - s - (i > 0 ? i : 0), d = n[r] + i;
+	if (t[r]) return o[r] ? u : d;
+	let f = c[r];
+	return f == null ? 0 : o[r] ? u < f ? Math.max(d, f) : Math.max(u, f) : l == null ? 0 : d + s > f + l ? Math.max(u, f) : Math.max(d, f);
+}
+function a({ translateX: e, translateY: t, useTranslate3d: n }) {
+	return { transform: n ? `translate3d(${e}px, ${t}px, 0)` : `translate(${e}px, ${t}px)` };
+}
+function o({ allowEscapeViewBox: e, coordinate: t, offsetTopLeft: o, position: s, reverseDirection: c, tooltipBox: l, useTranslate3d: u, viewBox: d }) {
+	let f, p, m;
+	return l.height > 0 && l.width > 0 && t ? (p = i({
+		allowEscapeViewBox: e,
+		coordinate: t,
+		key: "x",
+		offsetTopLeft: o,
+		position: s,
+		reverseDirection: c,
+		tooltipDimension: l.width,
+		viewBox: d,
+		viewBoxDimension: d.width
+	}), m = i({
+		allowEscapeViewBox: e,
+		coordinate: t,
+		key: "y",
+		offsetTopLeft: o,
+		position: s,
+		reverseDirection: c,
+		tooltipDimension: l.height,
+		viewBox: d,
+		viewBoxDimension: d.height
+	}), f = {}) : f = n, {
+		cssProperties: f,
+		cssClasses: r({
+			translateX: p,
+			translateY: m,
+			coordinate: t
+		}),
+		transform: a({
+			translateX: p ?? 0,
+			translateY: m ?? 0,
+			useTranslate3d: u
+		})
+	};
+}
+//#endregion
+export { o as getTooltipTranslate };

package/dist/es/utils/validate.mjs

@@ -0,0 +1,31 @@
+//#region src/utils/validate.ts
+function e(e) {
+	return typeof e == "number" && e != +e;
+}
+function t(t) {
+	return (typeof t == "number" || t instanceof Number) && !e(t);
+}
+function n({ width: e, height: n }) {
+	return !(!t(e) || e <= 0 || !t(n) || n <= 0);
+}
+function r(e) {
+	return Number.isFinite(e);
+}
+function i(e) {
+	return typeof e == "string" && e.indexOf("%") === e.length - 1;
+}
+function a(e, t) {
+	return e === "horizontal" && t === "xAxis" || e === "vertical" && t === "yAxis" || e === "centric" && t === "angleAxis" || e === "radial" && t === "radiusAxis";
+}
+function o(e, t, n, r, i) {
+	if (e * t < e * r || e * t > e * i) return !1;
+	let a = n();
+	return e * (t - e * a / 2 - r) >= 0 && e * (t + e * a / 2 - i) <= 0;
+}
+var s = typeof window > "u";
+function c(e) {
+	return e == null;
+}
+var l = (e) => t(e) || typeof e == "string";
+//#endregion
+export { a as isCategoricalAxis, e as isNan, c as isNullish, l as isNumOrStr, t as isNumber, i as isPercent, s as isSsr, o as isVisible, r as isWellBehavedNumber, n as validateWidthHeight };

package/dist/events/useChartSynchronisation.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Will receive synchronisation events from other charts.
+ *
+ * Reads syncMethod from state and decides how to synchronise the tooltip based on that.
+ *
+ * @returns void
+ */
+export declare function useSynchronisedEventsFromOtherCharts(): void;

package/dist/hooks/useSetupGraphicalItem.d.ts

@@ -0,0 +1,7 @@
+import { AreaProps } from '../cartesian/area/type';
+import { CartesianGraphicalItemType, ErrorBarsSettings } from '../state/graphicalItemsSlice';
+import { ShallowRef } from 'vue';
+export declare function useSetupGraphicalItem(props: AreaProps | any, type: CartesianGraphicalItemType, options?: {
+    skipTooltip?: boolean;
+    errorBars?: ShallowRef<ReadonlyArray<ErrorBarsSettings>>;
+}): void;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cartesian';
+export * from './chart';
+export * from './container';
+export * from './components';
+export * from './polar';
+export * from './shape';

package/dist/polar/index.d.ts

@@ -0,0 +1,3 @@
+export * from './pie';
+export * from './radar';
+export * from './radial-bar';

package/dist/polar/pie/Pie.d.ts

@@ -0,0 +1,2 @@
+import { PiePropsWithSVG } from './type';
+export declare const Pie: import('vue').DefineComponent<PiePropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PiePropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;

package/dist/polar/pie/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Pie';
+export * from './type';

package/dist/polar/pie/type.d.ts

@@ -0,0 +1,88 @@
+import { PropType } from 'vue';
+import { DataKey, VuePropsToType, WithSVGProps } from '../../types';
+import { LegendType } from '../../types/legend';
+import { TooltipType } from '../../types/tooltip';
+export declare const PieVueProps: {
+    data: {
+        type: PropType<Array<Record<string, unknown>>>;
+        default: any;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        required: true;
+    };
+    nameKey: {
+        type: PropType<DataKey<any>>;
+        default: string;
+    };
+    cx: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    cy: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    innerRadius: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    outerRadius: {
+        type: PropType<number | string | ((element: any) => number)>;
+        default: string;
+    };
+    startAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    endAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    paddingAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+    legendType: {
+        type: PropType<LegendType>;
+        default: string;
+    };
+    tooltipType: {
+        type: PropType<TooltipType>;
+        default: any;
+    };
+    hide: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    activeIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isAnimationActive: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    className: {
+        type: StringConstructor;
+        default: any;
+    };
+};
+export type PieProps = VuePropsToType<typeof PieVueProps>;
+export type PiePropsWithSVG = WithSVGProps<typeof PieVueProps>;

package/dist/polar/radar/PolarAngleAxis.d.ts

@@ -0,0 +1,145 @@
+import { PropType, SlotsType } from 'vue';
+import { DataKey } from '../../types';
+import { AxisDomain } from '../../types/axis';
+import { AxisTick } from '../../types/tick';
+export declare const PolarAngleAxis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    angleAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    tick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    axisLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    axisLineType: {
+        type: PropType<"polygon" | "circle">;
+        default: string;
+    };
+    orientation: {
+        type: PropType<"inner" | "outer">;
+        default: string;
+    };
+    tickFormatter: {
+        type: PropType<(value: any, index: number) => string>;
+        default: any;
+    };
+    ticks: {
+        type: PropType<ReadonlyArray<AxisTick>>;
+        default: any;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: any;
+    };
+    type: {
+        type: PropType<"category" | "number">;
+        default: string;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    tickCount: {
+        type: NumberConstructor;
+        default: any;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    angleAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    tick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    axisLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    axisLineType: {
+        type: PropType<"polygon" | "circle">;
+        default: string;
+    };
+    orientation: {
+        type: PropType<"inner" | "outer">;
+        default: string;
+    };
+    tickFormatter: {
+        type: PropType<(value: any, index: number) => string>;
+        default: any;
+    };
+    ticks: {
+        type: PropType<ReadonlyArray<AxisTick>>;
+        default: any;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: any;
+    };
+    type: {
+        type: PropType<"category" | "number">;
+        default: string;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    tickCount: {
+        type: NumberConstructor;
+        default: any;
+    };
+}>> & Readonly<{}>, {
+    tick: boolean;
+    tickFormatter: (value: any, index: number) => string;
+    type: "number" | "category";
+    dataKey: DataKey<any>;
+    orientation: "outer" | "inner";
+    stroke: string;
+    tickCount: number;
+    ticks: readonly AxisTick[];
+    angleAxisId: string | number;
+    domain: AxisDomain;
+    axisLine: boolean;
+    tickLine: boolean;
+    tickSize: number;
+    axisLineType: "circle" | "polygon";
+}, SlotsType<{
+    tick?: (props: {
+        x: number;
+        y: number;
+        value: any;
+        index: number;
+        textAnchor: string;
+        payload: any;
+        cx: number;
+        cy: number;
+    }) => any;
+}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/polar/radar/PolarGrid.d.ts

@@ -0,0 +1,77 @@
+import { PropType } from 'vue';
+export declare const PolarGrid: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    angleAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    radiusAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    gridType: {
+        type: PropType<"polygon" | "circle">;
+        default: string;
+    };
+    radialLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    polarRadius: {
+        type: PropType<number[]>;
+        default: any;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: any;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    angleAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    radiusAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    gridType: {
+        type: PropType<"polygon" | "circle">;
+        default: string;
+    };
+    radialLines: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    polarRadius: {
+        type: PropType<number[]>;
+        default: any;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: any;
+    };
+}>> & Readonly<{}>, {
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    angleAxisId: string | number;
+    radiusAxisId: string | number;
+    gridType: "circle" | "polygon";
+    radialLines: boolean;
+    polarRadius: number[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;