vccs 0.0.1 → 0.1.0

package/dist/cartesian/type.d.ts

@@ -0,0 +1,21 @@
+export type Unit = string | number;
+export type Orientation = 'top' | 'bottom' | 'left' | 'right';
+export interface PolarViewBox {
+    cx?: number;
+    cy?: number;
+    innerRadius?: number;
+    outerRadius?: number;
+    startAngle?: number;
+    endAngle?: number;
+    clockWise?: boolean;
+}
+export type PolarViewBoxRequired = Required<PolarViewBox>;
+export interface CartesianViewBox {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+export type ViewBox = CartesianViewBox | PolarViewBox;
+export type CartesianViewBoxRequired = Required<CartesianViewBox>;
+export type Sign = 0 | 1 | -1;

package/dist/cartesian/useNeedsClip.d.ts

@@ -0,0 +1,6 @@
+import { AxisId } from '../types/axis';
+export declare function useNeedsClip(xAxisId: AxisId, yAxisId: AxisId): {
+    needClip: import('vue').ComputedRef<boolean>;
+    needClipX: import('vue').ComputedRef<boolean>;
+    needClipY: import('vue').ComputedRef<boolean>;
+};

package/dist/cartesian/utils/get-ticks.d.ts

@@ -0,0 +1,16 @@
+import { CartesianViewBoxRequired } from '../type';
+import { CartesianAxisSettings, XAxisOrientation, YAxisOrientation } from '../../types/axis';
+import { CartesianTickItem } from '../../types/tick';
+export type Sign = 0 | 1 | -1;
+export type GetTicksInput = {
+    angle: number;
+    interval: CartesianAxisSettings['interval'];
+    minTickGap: number;
+    orientation: XAxisOrientation | YAxisOrientation;
+    tick: CartesianAxisSettings['tick'];
+    tickFormatter: CartesianAxisSettings['tickFormatter'];
+    ticks: ReadonlyArray<CartesianTickItem>;
+    unit: CartesianAxisSettings['unit'];
+    viewBox: CartesianViewBoxRequired;
+};
+export declare function getTicks(props: GetTicksInput, fontSize?: string, letterSpacing?: string): ReadonlyArray<CartesianTickItem>;

package/dist/cartesian/z-axis/ZAxis.d.ts

@@ -0,0 +1,81 @@
+import { PropType } from 'vue';
+import { AxisRange } from '../../state/selectors/axisSelectors';
+import { DataKey } from '../../types';
+import { AxisDomain } from '../../types/axis';
+import { ScaleType } from '../../types/scale';
+export declare const ZAxis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    zAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    type: {
+        type: PropType<"number" | "category">;
+        default: import('../../types/axis').AxisDomainType;
+    };
+    range: {
+        type: PropType<[number, number]>;
+        default: () => AxisRange;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    scale: {
+        type: PropType<ScaleType>;
+        default: ScaleType | import('../../types/scale').RechartsScale;
+    };
+    name: {
+        type: StringConstructor;
+        default: any;
+    };
+    unit: {
+        type: StringConstructor;
+        default: any;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    zAxisId: {
+        type: PropType<string | number>;
+        default: number;
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+        default: any;
+    };
+    type: {
+        type: PropType<"number" | "category">;
+        default: import('../../types/axis').AxisDomainType;
+    };
+    range: {
+        type: PropType<[number, number]>;
+        default: () => AxisRange;
+    };
+    domain: {
+        type: PropType<AxisDomain>;
+        default: any;
+    };
+    scale: {
+        type: PropType<ScaleType>;
+        default: ScaleType | import('../../types/scale').RechartsScale;
+    };
+    name: {
+        type: StringConstructor;
+        default: any;
+    };
+    unit: {
+        type: StringConstructor;
+        default: any;
+    };
+}>> & Readonly<{}>, {
+    unit: string;
+    scale: ScaleType;
+    type: "number" | "category";
+    dataKey: DataKey<any>;
+    name: string;
+    range: [number, number];
+    zAxisId: string | number;
+    domain: AxisDomain;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/z-axis/index.d.ts

@@ -0,0 +1 @@
+export { ZAxis } from './ZAxis';

package/dist/chart/AreaChart.d.ts

@@ -0,0 +1 @@
+export declare const AreaChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/BarChart.d.ts

@@ -0,0 +1 @@
+export declare const BarChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/ComposedChart.d.ts

@@ -0,0 +1 @@
+export declare const ComposedChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/LegendPortalContext.d.ts

@@ -0,0 +1,3 @@
+import { Ref } from 'vue';
+declare const useLegendPortal: <T extends Ref<HTMLElement, HTMLElement> = Ref<HTMLElement, HTMLElement>>(fallback?: T) => T extends null ? Ref<HTMLElement, HTMLElement> : Ref<HTMLElement, HTMLElement>, provideLegendPortalRaw: (contextValue: Ref<HTMLElement, HTMLElement>) => Ref<HTMLElement, HTMLElement>;
+export { useLegendPortal, provideLegendPortalRaw };

package/dist/chart/LineChart.d.ts

@@ -0,0 +1 @@
+export declare const LineChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/PieChart.d.ts

@@ -0,0 +1 @@
+export declare const PieChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/RadarChart.d.ts

@@ -0,0 +1 @@
+export declare const RadarChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/RadialBarChart.d.ts

@@ -0,0 +1 @@
+export declare const RadialBarChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/RechartsWrapper.d.ts

@@ -0,0 +1,99 @@
+import { CSSProperties, PropType } from 'vue';
+import { CategoricalChartFunc } from '../types';
+export declare const RechartsWrapper: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    onClick: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onContextMenu: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onDoubleClick: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseDown: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseEnter: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseLeave: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseMove: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseUp: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchEnd: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchMove: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchStart: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    class: {
+        type: StringConstructor;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    onClick: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onContextMenu: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onDoubleClick: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseDown: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseEnter: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseLeave: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseMove: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onMouseUp: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchEnd: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchMove: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    onTouchStart: {
+        type: PropType<CategoricalChartFunc>;
+    };
+    style: {
+        type: PropType<CSSProperties>;
+    };
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/ScatterChart.d.ts

@@ -0,0 +1 @@
+export declare const ScatterChart: import('vue').DefineComponent<import('./generateCategoricalChart').CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('./generateCategoricalChart').CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/Surface.d.ts

@@ -0,0 +1,40 @@
+import { CSSProperties } from 'vue';
+interface SurfaceProps {
+    width: number;
+    height: number;
+    viewBox?: {
+        x?: number;
+        y?: number;
+        width?: number;
+        height?: number;
+    };
+    class?: string;
+    style?: CSSProperties;
+    title?: string;
+    desc?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        cursorLayerRef: SVGGElement;
+        graphicalLayerRef: SVGGElement;
+        labelLayerRef: SVGGElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<SurfaceProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SurfaceProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    cursorLayerRef: SVGGElement;
+    graphicalLayerRef: SVGGElement;
+    labelLayerRef: SVGGElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/chart/TooltipPortalContext.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare const usePortal: <T extends Ref<HTMLElement, HTMLElement> = Ref<HTMLElement, HTMLElement>>(fallback?: T) => T extends null ? Ref<HTMLElement, HTMLElement> : Ref<HTMLElement, HTMLElement>, providePortalRaw: (contextValue: Ref<HTMLElement, HTMLElement>) => Ref<HTMLElement, HTMLElement>;

package/dist/chart/const.d.ts

@@ -0,0 +1,6 @@
+import { Margin } from '../types';
+export declare const defaultMargin: Margin;
+export declare const FULL_WIDTH_AND_HEIGHT: {
+    width: string;
+    height: string;
+};

package/dist/chart/generateCategoricalChart.d.ts

@@ -0,0 +1,118 @@
+import { DataKey, LayoutType, Margin, StackOffsetType, SyncMethod, VuePropsToType, WithSVGProps } from '../types';
+import { PropType } from 'vue';
+import { TooltipEventType } from '../types/tooltip';
+import { ChartData } from '../state/chartDataSlice';
+export declare const CategoricalProps: {
+    accessibilityLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    barCategoryGap: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    barGap: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    barSize: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    class: {
+        type: StringConstructor;
+    };
+    compact: {
+        type: BooleanConstructor;
+    };
+    cx: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    cy: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    data: {
+        type: PropType<ChartData>;
+        default: () => any[];
+    };
+    dataKey: {
+        type: PropType<DataKey<any>>;
+    };
+    desc: {
+        type: StringConstructor;
+    };
+    endAngle: {
+        type: NumberConstructor;
+    };
+    height: {
+        type: NumberConstructor;
+    };
+    id: {
+        type: StringConstructor;
+    };
+    innerRadius: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    layout: {
+        type: PropType<LayoutType>;
+        default: "horizontal";
+    };
+    margin: {
+        type: PropType<Margin>;
+        default: () => Margin;
+    };
+    maxBarSize: {
+        type: NumberConstructor;
+    };
+    outerRadius: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    reverseStackOrder: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    role: {
+        type: StringConstructor;
+    };
+    stackOffset: {
+        type: PropType<StackOffsetType>;
+        default: string;
+    };
+    startAngle: {
+        type: NumberConstructor;
+    };
+    style: {
+        type: ObjectConstructor;
+    };
+    syncId: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    syncMethod: {
+        type: PropType<SyncMethod>;
+        default: string;
+    };
+    tabIndex: {
+        type: NumberConstructor;
+    };
+    throttleDelay: {
+        type: NumberConstructor;
+    };
+    title: {
+        type: StringConstructor;
+    };
+    width: {
+        type: NumberConstructor;
+    };
+    to: {
+        type: PropType<string | HTMLElement | null>;
+    };
+};
+export type CategoricalChartPropsWithOutSvg = VuePropsToType<typeof CategoricalProps>;
+export type CategoricalChartProps = WithSVGProps<CategoricalChartPropsWithOutSvg>;
+export interface CategoricalChartOptions {
+    chartName: string;
+    defaultProps?: Partial<CategoricalChartPropsWithOutSvg>;
+    defaultTooltipEventType?: TooltipEventType;
+    validateTooltipEventTypes?: readonly TooltipEventType[];
+    tooltipPayloadSearcher?: any;
+}
+export declare function generateCategoricalChart({ chartName, defaultProps, defaultTooltipEventType, validateTooltipEventTypes, tooltipPayloadSearcher, }: CategoricalChartOptions): import('vue').DefineComponent<CategoricalChartProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CategoricalChartProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/chart/index.d.ts

@@ -0,0 +1,8 @@
+export * from './AreaChart';
+export * from './BarChart';
+export * from './ComposedChart';
+export * from './LineChart';
+export * from './PieChart';
+export * from './RadarChart';
+export * from './ScatterChart';
+export * from './RadialBarChart';

package/dist/chart/provideClipPathId.d.ts

@@ -0,0 +1,12 @@
+import { CategoricalChartProps } from '../types';
+declare const useClipPathId: <T extends string = string>(fallback?: T) => T extends null ? string : string;
+/**
+ * Provide the clipPathId to child components.
+ * @param props - The props object from the chart component
+ */
+export declare function provideClipPathId(props: CategoricalChartProps): string;
+/**
+ * Inject the clipPathId provided by an ancestor chart component.
+ * @returns {string} The injected clipPathId
+ */
+export { useClipPathId };

package/dist/components/Cell.d.ts

@@ -0,0 +1,18 @@
+import { SVGAttributes } from 'vue';
+/**
+ * Cell is a marker component used to define per-item colors and styles.
+ * It renders nothing — parent components (Bar, Pie, etc.) read Cell
+ * children from the default slot and apply their props by index.
+ *
+ * Usage:
+ * ```vue
+ * <Bar data-key="value">
+ *   <Cell v-for="(entry, index) in data" :key="index" :fill="COLORS[index]" />
+ * </Bar>
+ * ```
+ */
+export declare const Cell: import('vue').DefineComponent<{}, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export type CellProps = SVGAttributes & {
+    fill?: string;
+    stroke?: string;
+};

package/dist/components/DefaultLegendContent.d.ts

@@ -0,0 +1,18 @@
+import { DataKey } from '../types';
+import { LegendType } from '../types/legend';
+export type HorizontalAlignmentType = 'left' | 'center' | 'right';
+export type VerticalAlignmentType = 'top' | 'middle' | 'bottom';
+export interface LegendPayload {
+    /**
+     * This is the text that will be displayed in the legend in the DOM.
+     */
+    value: string;
+    type?: LegendType;
+    color?: string;
+    payload?: {
+        strokeDasharray?: number | string;
+        value?: any;
+    };
+    inactive?: boolean;
+    dataKey?: DataKey<any>;
+}

package/dist/components/Text.d.ts

@@ -0,0 +1,149 @@
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    y: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    dx: {
+        type: NumberConstructor;
+        default: any;
+    };
+    dy: {
+        type: NumberConstructor;
+        default: any;
+    };
+    lineHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    capHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    scaleToFit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    textAnchor: {
+        type: StringConstructor;
+        default: string;
+    };
+    verticalAnchor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    angle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    breakAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxLines: {
+        type: NumberConstructor;
+        default: any;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    y: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    dx: {
+        type: NumberConstructor;
+        default: any;
+    };
+    dy: {
+        type: NumberConstructor;
+        default: any;
+    };
+    lineHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    capHeight: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    scaleToFit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    textAnchor: {
+        type: StringConstructor;
+        default: string;
+    };
+    verticalAnchor: {
+        type: StringConstructor;
+        default: string;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    angle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    style: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    breakAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxLines: {
+        type: NumberConstructor;
+        default: any;
+    };
+    width: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    fill: string;
+    width: string | number;
+    x: string | number;
+    y: string | number;
+    value: string | number;
+    style: Record<string, any>;
+    dx: number;
+    dy: number;
+    angle: number;
+    lineHeight: string | number;
+    textAnchor: string;
+    capHeight: string | number;
+    scaleToFit: boolean;
+    verticalAnchor: string;
+    breakAll: boolean;
+    maxLines: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, SVGTextElement>;
+export default _default;