vccs 0.0.1 → 0.2.0

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,250 @@
+import { PropType, SlotsType } from 'vue';
+import { TooltipIndex, TooltipPayload, TooltipPayloadEntry } from '../state/tooltipSlice';
+import { AxisId } from '../state/cartesianAxisSlice';
+import { ChartCoordinate, Coordinate } from '../types';
+import { TooltipTrigger } from '../types/tooltip';
+export type ContentType = any | ((props: TooltipContentProps) => any);
+export type TooltipContentProps = {
+    label?: string | number;
+    payload: TooltipPayload;
+    coordinate?: ChartCoordinate;
+    active: boolean;
+    accessibilityLayer: boolean;
+    [key: string]: any;
+};
+type AllowInDimension = {
+    x: boolean;
+    y: boolean;
+};
+type UniqueFunc<T> = (entry: T) => unknown;
+export type UniqueOption<T> = boolean | UniqueFunc<T>;
+export declare function getUniqPayload<T>(payload: ReadonlyArray<T>, option: UniqueOption<T>, defaultUniqBy: UniqueFunc<T>): ReadonlyArray<T>;
+export declare const Tooltip: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    /**
+     * If true, then Tooltip is always displayed, once an activeIndex is set by mouse over, or programmatically.
+     * If false, then Tooltip is never displayed.
+     * If active is undefined, Recharts will control when the Tooltip displays.
+     */
+    readonly active: {
+        readonly type: BooleanConstructor;
+        readonly default: any;
+    };
+    /**
+     * If true, then Tooltip will show information about hidden series (defaults to false).
+     */
+    readonly includeHidden: BooleanConstructor;
+    readonly allowEscapeViewBox: {
+        readonly type: PropType<AllowInDimension>;
+        readonly default: () => {
+            x: boolean;
+            y: boolean;
+        };
+    };
+    readonly content: PropType<ContentType>;
+    readonly cursor: {
+        readonly type: PropType<boolean | object>;
+        readonly default: true;
+    };
+    readonly filterNull: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly defaultIndex: PropType<number | TooltipIndex>;
+    readonly isAnimationActive: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 10;
+    };
+    readonly payloadUniqBy: PropType<UniqueOption<TooltipPayloadEntry>>;
+    /**
+     * If portal is defined, then Tooltip will use this element as a target for rendering using Teleport
+     */
+    readonly portal: {
+        readonly type: PropType<HTMLElement | null>;
+        readonly default: any;
+    };
+    readonly position: PropType<Partial<Coordinate>>;
+    readonly reverseDirection: {
+        readonly type: PropType<AllowInDimension>;
+        readonly default: () => {
+            x: boolean;
+            y: boolean;
+        };
+    };
+    /**
+     * If true, tooltip will appear on top of all bars on an axis tick.
+     * If false, tooltip will appear on individual bars.
+     */
+    readonly shared: {
+        readonly type: PropType<boolean | undefined>;
+        readonly default: any;
+    };
+    /**
+     * If `hover` then the Tooltip shows on mouse enter and hides on mouse leave.
+     * If `click` then the Tooltip shows after clicking and stays active.
+     */
+    readonly trigger: {
+        readonly type: PropType<TooltipTrigger>;
+        readonly default: "hover";
+    };
+    readonly style: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    /**
+     * Tooltip axis ID
+     */
+    readonly axisId: {
+        readonly type: PropType<AxisId>;
+        readonly default: 0;
+    };
+    readonly contentStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly itemStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly labelStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly itemSorter: {
+        readonly type: StringConstructor;
+        readonly default: "name";
+    };
+    readonly separator: {
+        readonly type: StringConstructor;
+        readonly default: " : ";
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    /**
+     * If true, then Tooltip is always displayed, once an activeIndex is set by mouse over, or programmatically.
+     * If false, then Tooltip is never displayed.
+     * If active is undefined, Recharts will control when the Tooltip displays.
+     */
+    readonly active: {
+        readonly type: BooleanConstructor;
+        readonly default: any;
+    };
+    /**
+     * If true, then Tooltip will show information about hidden series (defaults to false).
+     */
+    readonly includeHidden: BooleanConstructor;
+    readonly allowEscapeViewBox: {
+        readonly type: PropType<AllowInDimension>;
+        readonly default: () => {
+            x: boolean;
+            y: boolean;
+        };
+    };
+    readonly content: PropType<ContentType>;
+    readonly cursor: {
+        readonly type: PropType<boolean | object>;
+        readonly default: true;
+    };
+    readonly filterNull: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly defaultIndex: PropType<number | TooltipIndex>;
+    readonly isAnimationActive: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly offset: {
+        readonly type: NumberConstructor;
+        readonly default: 10;
+    };
+    readonly payloadUniqBy: PropType<UniqueOption<TooltipPayloadEntry>>;
+    /**
+     * If portal is defined, then Tooltip will use this element as a target for rendering using Teleport
+     */
+    readonly portal: {
+        readonly type: PropType<HTMLElement | null>;
+        readonly default: any;
+    };
+    readonly position: PropType<Partial<Coordinate>>;
+    readonly reverseDirection: {
+        readonly type: PropType<AllowInDimension>;
+        readonly default: () => {
+            x: boolean;
+            y: boolean;
+        };
+    };
+    /**
+     * If true, tooltip will appear on top of all bars on an axis tick.
+     * If false, tooltip will appear on individual bars.
+     */
+    readonly shared: {
+        readonly type: PropType<boolean | undefined>;
+        readonly default: any;
+    };
+    /**
+     * If `hover` then the Tooltip shows on mouse enter and hides on mouse leave.
+     * If `click` then the Tooltip shows after clicking and stays active.
+     */
+    readonly trigger: {
+        readonly type: PropType<TooltipTrigger>;
+        readonly default: "hover";
+    };
+    readonly style: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    /**
+     * Tooltip axis ID
+     */
+    readonly axisId: {
+        readonly type: PropType<AxisId>;
+        readonly default: 0;
+    };
+    readonly contentStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly itemStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly labelStyle: {
+        readonly type: ObjectConstructor;
+        readonly default: () => {};
+    };
+    readonly itemSorter: {
+        readonly type: StringConstructor;
+        readonly default: "name";
+    };
+    readonly separator: {
+        readonly type: StringConstructor;
+        readonly default: " : ";
+    };
+}>> & Readonly<{}>, {
+    readonly style: Record<string, any>;
+    readonly cursor: boolean | object;
+    readonly offset: number;
+    readonly isAnimationActive: boolean;
+    readonly includeHidden: boolean;
+    readonly active: boolean;
+    readonly shared: boolean;
+    readonly trigger: TooltipTrigger;
+    readonly axisId: AxisId;
+    readonly separator: string;
+    readonly contentStyle: Record<string, any>;
+    readonly itemStyle: Record<string, any>;
+    readonly itemSorter: string;
+    readonly portal: HTMLElement;
+    readonly allowEscapeViewBox: AllowInDimension;
+    readonly reverseDirection: AllowInDimension;
+    readonly labelStyle: Record<string, any>;
+    readonly filterNull: boolean;
+}, SlotsType<{
+    content?: (props: TooltipContentProps) => any;
+    cursor?: (props: Record<string, any>) => any;
+    default?: () => any;
+}>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Tooltip;

package/dist/components/index.d.ts

@@ -0,0 +1,4 @@
+export * from './Cell';
+export * from './label';
+export * from './legend';
+export * from './Tooltip';

package/dist/components/label/Label.d.ts

@@ -0,0 +1,81 @@
+import { SlotsType } from 'vue';
+import { LabelSlots } from './types';
+export declare const Label: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+    viewBox: {
+        type: import('vue').PropType<import('./types').ViewBox>;
+    };
+    parentViewBox: {
+        type: import('vue').PropType<import('./types').ViewBox>;
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    formatter: {
+        type: import('vue').PropType<import('./types').LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: import('vue').PropType<import('./types').LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+    index: {
+        type: NumberConstructor;
+    };
+}>, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+    viewBox: {
+        type: import('vue').PropType<import('./types').ViewBox>;
+    };
+    parentViewBox: {
+        type: import('vue').PropType<import('./types').ViewBox>;
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    formatter: {
+        type: import('vue').PropType<import('./types').LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: import('vue').PropType<import('./types').LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+    index: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{}>, {
+    class: string;
+    offset: number;
+    textBreakAll: boolean;
+}, SlotsType<LabelSlots>, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/label/LabelList.d.ts

@@ -0,0 +1,63 @@
+export declare const LabelList: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+    };
+    data: {
+        type: import('vue').PropType<ReadonlyArray<import('./types').Data>>;
+    };
+    valueAccessor: {
+        type: import('vue').PropType<(entry: import('./types').Data, index: number) => string | number>;
+        default: (entry: import('./types').Data) => string | number;
+    };
+    clockWise: {
+        type: BooleanConstructor;
+    };
+    dataKey: {
+        type: import('vue').PropType<import('../../types').DataKey<Record<string, any>>>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    position: {
+        type: import('vue').PropType<import('./types').LabelPosition>;
+    };
+    offset: {
+        type: NumberConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    id: {
+        type: StringConstructor;
+    };
+    data: {
+        type: import('vue').PropType<ReadonlyArray<import('./types').Data>>;
+    };
+    valueAccessor: {
+        type: import('vue').PropType<(entry: import('./types').Data, index: number) => string | number>;
+        default: (entry: import('./types').Data) => string | number;
+    };
+    clockWise: {
+        type: BooleanConstructor;
+    };
+    dataKey: {
+        type: import('vue').PropType<import('../../types').DataKey<Record<string, any>>>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    position: {
+        type: import('vue').PropType<import('./types').LabelPosition>;
+    };
+    offset: {
+        type: NumberConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+}>> & Readonly<{}>, {
+    clockWise: boolean;
+    textBreakAll: boolean;
+    valueAccessor: (entry: import('./types').Data, index: number) => string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/label/index.d.ts

@@ -0,0 +1,2 @@
+export * from './Label';
+export * from './LabelList';

package/dist/components/label/types.d.ts

@@ -0,0 +1,88 @@
+import { ViewBox } from '../../cartesian/type';
+import { DataKey, VuePropsToType } from '../../types';
+import { PropType, VNode } from 'vue';
+export type { ViewBox };
+export interface Data {
+    value?: number | string | Array<number | string>;
+    payload?: any;
+    parentViewBox?: ViewBox;
+    fill?: string;
+}
+export type LabelPosition = 'top' | 'left' | 'right' | 'bottom' | 'inside' | 'outside' | 'insideLeft' | 'insideRight' | 'insideTop' | 'insideBottom' | 'insideTopLeft' | 'insideBottomLeft' | 'insideTopRight' | 'insideBottomRight' | 'insideStart' | 'insideEnd' | 'end' | 'center' | 'centerTop' | 'centerBottom' | 'middle' | {
+    x?: number;
+    y?: number;
+};
+export declare const LabelListVueProps: {
+    id: {
+        type: StringConstructor;
+    };
+    data: {
+        type: PropType<ReadonlyArray<Data>>;
+    };
+    valueAccessor: {
+        type: PropType<(entry: Data, index: number) => string | number>;
+        default: (entry: Data) => string | number;
+    };
+    clockWise: {
+        type: BooleanConstructor;
+    };
+    dataKey: {
+        type: PropType<DataKey<Record<string, any>>>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    position: {
+        type: PropType<LabelPosition>;
+    };
+    offset: {
+        type: NumberConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+};
+export type LabelFormatter = (label: string | number | undefined) => string | number | undefined;
+export declare const LabelVueProps: {
+    id: {
+        type: StringConstructor;
+    };
+    class: {
+        type: StringConstructor;
+        default: string;
+    };
+    viewBox: {
+        type: PropType<ViewBox>;
+    };
+    parentViewBox: {
+        type: PropType<ViewBox>;
+    };
+    value: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    formatter: {
+        type: PropType<LabelFormatter>;
+    };
+    offset: {
+        type: NumberConstructor;
+        default: number;
+    };
+    position: {
+        type: PropType<LabelPosition>;
+    };
+    textBreakAll: {
+        type: BooleanConstructor;
+    };
+    angle: {
+        type: NumberConstructor;
+    };
+    index: {
+        type: NumberConstructor;
+    };
+};
+export type LabelProps = VuePropsToType<typeof LabelVueProps>;
+export interface LabelSlots {
+    content: (props: LabelProps & {
+        viewBox: ViewBox;
+    }) => VNode;
+}

package/dist/components/label/utils.d.ts

@@ -0,0 +1,24 @@
+import { CartesianViewBox, PolarViewBox, ViewBox } from '../../cartesian/type';
+import { LabelProps } from './types';
+import { Coordinate } from '../../types';
+export declare function parseViewBox(props: any): ViewBox | undefined;
+export declare function isPolar(viewBox: CartesianViewBox | PolarViewBox): viewBox is PolarViewBox;
+export declare const RADIAN: number;
+export declare function polarToCartesian(cx: number, cy: number, radius: number, angle: number): Coordinate;
+type PolarLabelPosition = 'insideStart' | 'insideEnd' | 'end';
+export declare function renderRadialLabel(labelProps: LabelProps, position: PolarLabelPosition, label: string | number | undefined, attrs: Record<string, any>, viewBox: PolarViewBox): import("vue/jsx-runtime").JSX.Element;
+export declare function getAttrsOfPolarLabel(props: LabelProps, viewBox?: PolarViewBox): {
+    x: number;
+    y: number;
+    textAnchor: string;
+    verticalAnchor: string;
+};
+export declare function getAttrsOfCartesianLabel(props: LabelProps, viewBox: CartesianViewBox): {
+    height?: number;
+    width?: number;
+    x: number;
+    y: number;
+    textAnchor: string;
+    verticalAnchor: string;
+};
+export {};

package/dist/components/legend/Legend.d.ts

@@ -0,0 +1,4 @@
+import { DefineSetupFnComponent, SlotsType } from 'vue';
+import { LegendPropsWithSVG, LegendSlots } from './type';
+declare const _default: DefineSetupFnComponent<LegendPropsWithSVG, {}, SlotsType<LegendSlots>>;
+export default _default;

package/dist/components/legend/LegendSymbol.d.ts

@@ -0,0 +1,27 @@
+import { PropType } from 'vue';
+import { LegendType } from '../../types/legend';
+import { LegendPayload } from '../DefaultLegendContent';
+export declare const SIZE = 32;
+export declare const LegendSymbol: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    type: PropType<LegendType>;
+    color: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    data: {
+        type: PropType<LegendPayload>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    type: PropType<LegendType>;
+    color: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    data: {
+        type: PropType<LegendPayload>;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/components/legend/hooks/useLegend.d.ts

@@ -0,0 +1,19 @@
+import { CSSProperties } from 'vue';
+import { LegendPayload } from '../../DefaultLegendContent';
+import { LegendProps } from '../type';
+export declare function useLegend(props: LegendProps): {
+    legendRef: import('vue').Ref<HTMLElement, HTMLElement>;
+    boundingBox: import('vue').ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    widthOrHeight: import('vue').ComputedRef<{
+        height?: number;
+        width?: number;
+    }>;
+    processedPayload: import('vue').ComputedRef<LegendPayload[]>;
+    outerStyle: import('vue').ComputedRef<CSSProperties>;
+    legendPortal: import('vue').ComputedRef<HTMLElement>;
+    syncSettings: () => void;
+    syncSize: () => void;
+};

package/dist/components/legend/hooks/useLegendContent.d.ts

@@ -0,0 +1,36 @@
+import { CSSProperties, Component } from 'vue';
+import { LayoutType } from '../../../types';
+import { LegendType } from '../../../types/legend';
+import { HorizontalAlignmentType, LegendPayload, VerticalAlignmentType } from '../../DefaultLegendContent';
+interface LegendContentProps {
+    layout?: LayoutType;
+    align?: HorizontalAlignmentType;
+    verticalAlign?: VerticalAlignmentType;
+    iconSize?: number;
+    iconType?: LegendType;
+    wrapperStyle?: CSSProperties;
+    contentStyle?: CSSProperties;
+    formatter?: (value: string, entry: LegendPayload) => string;
+    onClick?: (data: LegendPayload, index: number) => void;
+    onMouseEnter?: (data: LegendPayload, index: number) => void;
+    onMouseLeave?: (data: LegendPayload, index: number) => void;
+    payload?: LegendPayload[];
+    content?: Component | ((props: any) => any);
+}
+export declare function useLegendContent(props: LegendContentProps): {
+    getWrapperStyle: (layout?: LayoutType, align?: HorizontalAlignmentType, verticalAlign?: VerticalAlignmentType) => CSSProperties;
+    getContentStyle: (layout?: LayoutType) => CSSProperties;
+    getItemStyle: (layout?: LayoutType) => CSSProperties;
+    getViewBox: () => {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    getSvgStyle: () => CSSProperties;
+    formatValue: (entry: LegendPayload) => string;
+    handleClick: (entry: LegendPayload, index: number) => void;
+    handleMouseEnter: (entry: LegendPayload, index: number) => void;
+    handleMouseLeave: (entry: LegendPayload, index: number) => void;
+};
+export {};

package/dist/components/legend/index.d.ts

@@ -0,0 +1,2 @@
+export type { LegendPropsWithSVG, LegendProps, LegendContentProps } from './type.ts';
+export { default as Legend } from './Legend.tsx';

package/dist/components/legend/type.d.ts

@@ -0,0 +1,54 @@
+import { CSSProperties, PropType, VNode } from 'vue';
+import { LayoutType, Margin } from '../../types';
+import { LegendType } from '../../types/legend';
+import { HorizontalAlignmentType, LegendPayload, VerticalAlignmentType } from '../DefaultLegendContent';
+import { VuePropsToType, WithSVGProps } from '../../types/common';
+export interface LegendSlots {
+    content: (params: LegendContentProps) => VNode;
+}
+export declare const LegendVueProps: {
+    readonly layout: {
+        readonly type: PropType<LayoutType>;
+        readonly default: "horizontal";
+    };
+    readonly align: {
+        readonly type: PropType<HorizontalAlignmentType>;
+        readonly default: "center";
+    };
+    readonly verticalAlign: {
+        readonly type: PropType<VerticalAlignmentType>;
+        readonly default: "bottom";
+    };
+    readonly width: NumberConstructor;
+    readonly height: NumberConstructor;
+    readonly iconSize: {
+        readonly type: NumberConstructor;
+        readonly default: 14;
+    };
+    readonly iconType: PropType<LegendType>;
+    readonly wrapperStyle: PropType<CSSProperties>;
+    readonly contentStyle: PropType<CSSProperties>;
+    readonly itemStyle: PropType<CSSProperties>;
+    readonly formatter: PropType<(value: string, entry: LegendPayload) => string>;
+    readonly onClick: PropType<(data: LegendPayload, index: number) => void>;
+    readonly onMouseEnter: PropType<(data: LegendPayload, index: number) => void>;
+    readonly onMouseLeave: PropType<(data: LegendPayload, index: number) => void>;
+    readonly margin: PropType<Margin>;
+    readonly chartWidth: NumberConstructor;
+    readonly chartHeight: NumberConstructor;
+    readonly payloadUniqBy: PropType<boolean | ((item: LegendPayload) => any)>;
+    readonly itemSorter: {
+        readonly type: PropType<"value" | "dataKey" | ((item: LegendPayload) => number | string)>;
+        readonly default: "value";
+    };
+    readonly portal: PropType<HTMLElement | null>;
+    readonly onBBoxUpdate: PropType<(box: {
+        width: number;
+        height: number;
+    } | null) => void>;
+};
+export type LegendProps = VuePropsToType<typeof LegendVueProps>;
+export type LegendPropsWithSVG = WithSVGProps<typeof LegendVueProps>;
+export interface LegendContentProps extends LegendProps {
+    payload: LegendPayload[];
+}

package/dist/components/legend/utils.d.ts

@@ -0,0 +1,18 @@
+import { CSSProperties } from 'vue';
+import { LayoutType, Margin } from '../../types';
+import { HorizontalAlignmentType, VerticalAlignmentType } from '../DefaultLegendContent';
+type PositionInput = {
+    layout?: LayoutType;
+    align?: HorizontalAlignmentType;
+    verticalAlign?: VerticalAlignmentType;
+};
+export declare function getDefaultPosition(style: CSSProperties | undefined, props: PositionInput, margin: Margin, chartWidth: number, chartHeight: number, box: {
+    width: number;
+    height: number;
+}): CSSProperties;
+export declare function getWidthOrHeight(layout: LayoutType | undefined, height: number | undefined, width: number | undefined, maxWidth: number): null | {
+    height?: number;
+    width?: number;
+};
+export declare function defaultUniqBy(entry: any): any;
+export {};