vccs 0.0.1 → 0.2.0

package/dist/cartesian/brush/hooks/useBrushHandlers.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+import { BrushState, BrushTravellerId } from '../type';
+import { BrushStartEndIndex } from '../../../state/chartDataSlice';
+export interface UseBrushHandlersProps {
+    x: number;
+    width: number;
+    travellerWidth: number;
+    gap: number;
+    startIndex: number;
+    endIndex: number;
+    leaveTimeOut: number;
+    onChange?: (index: BrushStartEndIndex) => void;
+    onDragEnd?: (index: BrushStartEndIndex) => void;
+    data?: any[];
+}
+export declare function useBrushHandlers(brushState: Ref<BrushState>, props: UseBrushHandlersProps, onChange: (index: BrushStartEndIndex) => void, chartData: () => any[]): {
+    handleLeaveWrapper: () => void;
+    handleTouchMove: (e: TouchEvent) => void;
+    handleEnterSlideOrTraveller: () => void;
+    handleLeaveSlideOrTraveller: () => void;
+    handleSlideDragStart: (e: MouseEvent | TouchEvent) => void;
+    handleTravellerDragStart: (id: BrushTravellerId, e: MouseEvent | TouchEvent) => void;
+    handleTravellerMoveKeyboard: (direction: 1 | -1, id: BrushTravellerId) => void;
+    handleDragEnd: () => void;
+};

package/dist/cartesian/brush/hooks/useBrushSetting.d.ts

@@ -0,0 +1,6 @@
+import { BrushProps } from '../type';
+/**
+ * setting brush settings
+ * @param props
+ */
+export declare function useBrushSetting(props: BrushProps): void;

package/dist/cartesian/brush/hooks/useBrushState.d.ts

@@ -0,0 +1,29 @@
+import { BrushState } from '../type';
+import { ChartData } from '../../../state/chartDataSlice';
+export declare function useBrushState(getX: () => number | undefined, getWidth: () => number | undefined, getTravellerWidth: () => number, chartData: () => ChartData | undefined, startIndex: () => number, endIndex: () => number): {
+    brushState: import('vue').Ref<{
+        isTravellerMoving: boolean;
+        isTravellerFocused: boolean;
+        isSlideMoving: boolean;
+        startX?: number;
+        endX?: number;
+        slideMoveStartX?: number;
+        movingTravellerId?: import('../type').BrushTravellerId;
+        isTextActive: boolean;
+        brushMoveStartX?: number;
+        scale?: any;
+        scaleValues?: number[];
+    }, BrushState | {
+        isTravellerMoving: boolean;
+        isTravellerFocused: boolean;
+        isSlideMoving: boolean;
+        startX?: number;
+        endX?: number;
+        slideMoveStartX?: number;
+        movingTravellerId?: import('../type').BrushTravellerId;
+        isTextActive: boolean;
+        brushMoveStartX?: number;
+        scale?: any;
+        scaleValues?: number[];
+    }>;
+};

package/dist/cartesian/brush/index.d.ts

@@ -0,0 +1,2 @@
+export { Brush } from './Brush';
+export type { BrushProps } from './type';

package/dist/cartesian/brush/type.d.ts

@@ -0,0 +1,103 @@
+import { BrushStartEndIndex } from '../../state/chartDataSlice';
+import { DataKey, Padding, VuePropsToType, WithSVGProps } from '../../types/common';
+import { PropType } from 'vue';
+export type { BrushStartEndIndex };
+export declare const BrushVueProps: {
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    travellerWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+    padding: {
+        type: PropType<Padding>;
+        default: () => {
+            top: number;
+            right: number;
+            bottom: number;
+            left: number;
+        };
+    };
+    leaveTimeOut: {
+        type: NumberConstructor;
+        default: number;
+    };
+    alwaysShowText: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    x: {
+        type: NumberConstructor;
+    };
+    y: {
+        type: NumberConstructor;
+    };
+    dy: {
+        type: NumberConstructor;
+    };
+    width: {
+        type: NumberConstructor;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+    };
+    class: {
+        type: StringConstructor;
+    };
+    data: {
+        type: PropType<any[]>;
+    };
+    dataKey: PropType<DataKey<any>>;
+    startIndex: {
+        type: NumberConstructor;
+    };
+    endIndex: {
+        type: NumberConstructor;
+    };
+    tickFormatter: {
+        type: PropType<(value: any, index: number) => string>;
+    };
+    onChange: {
+        type: PropType<(state: BrushStartEndIndex) => void>;
+    };
+    onDragEnd: {
+        type: PropType<(state: BrushStartEndIndex) => void>;
+    };
+};
+export type BrushProps = VuePropsToType<typeof BrushVueProps>;
+export type BrushPropsWithSVG = WithSVGProps<typeof BrushVueProps>;
+export type BrushTravellerId = 'startX' | 'endX';
+export interface BrushState {
+    isTravellerMoving: boolean;
+    isTravellerFocused: boolean;
+    isSlideMoving: boolean;
+    startX?: number;
+    endX?: number;
+    slideMoveStartX?: number;
+    movingTravellerId?: BrushTravellerId;
+    isTextActive: boolean;
+    brushMoveStartX?: number;
+    scale?: any;
+    scaleValues?: number[];
+}
+export interface TravellerProps {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    stroke?: string;
+}

package/dist/cartesian/brush/utils.d.ts

@@ -0,0 +1,15 @@
+import { BrushStartEndIndex } from './type';
+export declare function getIndexInRange(valueRange: number[], x: number): number;
+export declare function getIndex({ startX, endX, scaleValues, gap, data, }: {
+    startX: number;
+    endX: number;
+    scaleValues: number[];
+    gap: number;
+    data: any[];
+}): BrushStartEndIndex;
+export declare function getTextOfTick({ index, data, tickFormatter, dataKey, }: {
+    index: number;
+    data: any[];
+    tickFormatter: (value: any, index: number) => number | string;
+    dataKey: any;
+}): number | string;

package/dist/cartesian/cartesian-axis/CartesianAxis.d.ts

@@ -0,0 +1,209 @@
+import { CartesianViewBox } from '../type';
+import { AxisInterval } from '../../types/axis';
+import { RechartsScale } from '../../types/scale';
+import { CartesianTickItem } from '../../types/tick';
+import { PropType } from 'vue';
+/** The orientation of the axis in correspondence to the chart */
+export type Orientation = 'top' | 'bottom' | 'left' | 'right';
+/** A unit to be appended to a value */
+export type Unit = string | number;
+/** The formatter function of tick */
+export type TickFormatter = (value: any, index: number) => string;
+export interface CartesianAxisProps {
+    class?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    unit?: Unit;
+    orientation?: Orientation;
+    viewBox?: CartesianViewBox;
+    mirror?: boolean;
+    tickMargin?: number;
+    hide?: boolean;
+    label?: any;
+    minTickGap?: number;
+    ticks?: ReadonlyArray<CartesianTickItem>;
+    tickSize?: number;
+    tickFormatter?: TickFormatter;
+    interval?: AxisInterval;
+    angle?: number;
+    scale: RechartsScale;
+    axisLine?: string;
+}
+export declare const CartesianAxis: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: {
+        type: NumberConstructor;
+        default: number;
+    };
+    y: {
+        type: NumberConstructor;
+        default: number;
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    unit: (NumberConstructor | StringConstructor)[];
+    orientation: {
+        type: StringConstructor;
+        default: string;
+    };
+    viewBox: {
+        type: ObjectConstructor;
+        default: () => {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    tick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    axisLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    tickLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    mirror: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickMargin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    hide: BooleanConstructor;
+    label: any;
+    minTickGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    ticks: {
+        type: PropType<ReadonlyArray<CartesianTickItem>>;
+        default: () => any[];
+    };
+    tickSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tickFormatter: FunctionConstructor;
+    interval: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    angle: NumberConstructor;
+    scale: {
+        type: PropType<RechartsScale>;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: {
+        type: NumberConstructor;
+        default: number;
+    };
+    y: {
+        type: NumberConstructor;
+        default: number;
+    };
+    width: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    unit: (NumberConstructor | StringConstructor)[];
+    orientation: {
+        type: StringConstructor;
+        default: string;
+    };
+    viewBox: {
+        type: ObjectConstructor;
+        default: () => {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+    };
+    tick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    axisLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    tickLine: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: () => boolean;
+    };
+    mirror: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tickMargin: {
+        type: NumberConstructor;
+        default: number;
+    };
+    hide: BooleanConstructor;
+    label: any;
+    minTickGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    ticks: {
+        type: PropType<ReadonlyArray<CartesianTickItem>>;
+        default: () => any[];
+    };
+    tickSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tickFormatter: FunctionConstructor;
+    interval: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    angle: NumberConstructor;
+    scale: {
+        type: PropType<RechartsScale>;
+    };
+    stroke: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    interval: string | number;
+    tick: boolean;
+    width: number;
+    height: number;
+    x: number;
+    y: number;
+    orientation: string;
+    stroke: string;
+    viewBox: Record<string, any>;
+    label: any;
+    ticks: readonly CartesianTickItem[];
+    hide: boolean;
+    mirror: boolean;
+    minTickGap: number;
+    axisLine: boolean | Record<string, any>;
+    tickLine: boolean | Record<string, any>;
+    tickSize: number;
+    tickMargin: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/cartesian-axis/const.d.ts

@@ -0,0 +1,24 @@
+import { CartesianAxisProps } from './CartesianAxis';
+export declare const CartesianAxisDefaultProps: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    viewBox: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    orientation: string;
+    ticks: CartesianAxisProps["ticks"];
+    stroke: string;
+    tickLine: boolean;
+    axisLine: boolean;
+    tick: boolean;
+    mirror: boolean;
+    minTickGap: number;
+    tickSize: number;
+    tickMargin: number;
+    interval: string;
+};

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

@@ -0,0 +1 @@
+export * from './CartesianAxis';

package/dist/cartesian/cartesian-axis/use-axis-line.d.ts

@@ -0,0 +1,7 @@
+import { CartesianAxisProps } from './CartesianAxis';
+/**
+ *  render axis line
+ */
+export declare function useAxisLine(props: CartesianAxisProps): {
+    renderAxisLine: () => import("vue/jsx-runtime").JSX.Element;
+};

package/dist/cartesian/cartesian-grid/Background.d.ts

@@ -0,0 +1,18 @@
+declare const Background: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    fill: StringConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    ry: NumberConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    fill: StringConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    ry: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default Background;

package/dist/cartesian/cartesian-grid/CartesianGrid.d.ts

@@ -0,0 +1,75 @@
+export declare const CartesianGrid: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    xAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    syncWithTicks: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    horizontal: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    vertical: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    horizontalPoints: ArrayConstructor;
+    verticalPoints: ArrayConstructor;
+    horizontalValues: ArrayConstructor;
+    verticalValues: ArrayConstructor;
+    fill: StringConstructor;
+    fillOpacity: NumberConstructor;
+    ry: NumberConstructor;
+    verticalCoordinatesGenerator: FunctionConstructor;
+    horizontalCoordinatesGenerator: FunctionConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    xAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    syncWithTicks: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    horizontal: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    vertical: {
+        type: (ObjectConstructor | BooleanConstructor)[];
+        default: boolean;
+    };
+    horizontalPoints: ArrayConstructor;
+    verticalPoints: ArrayConstructor;
+    horizontalValues: ArrayConstructor;
+    verticalValues: ArrayConstructor;
+    fill: StringConstructor;
+    fillOpacity: NumberConstructor;
+    ry: NumberConstructor;
+    verticalCoordinatesGenerator: FunctionConstructor;
+    horizontalCoordinatesGenerator: FunctionConstructor;
+}>> & Readonly<{}>, {
+    horizontal: boolean | Record<string, any>;
+    vertical: boolean | Record<string, any>;
+    yAxisId: string | number;
+    xAxisId: string | number;
+    syncWithTicks: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/cartesian/cartesian-grid/HorizontalGridLines.d.ts

@@ -0,0 +1,37 @@
+declare const HorizontalGridLines: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    width: NumberConstructor;
+    horizontal: (ObjectConstructor | BooleanConstructor)[];
+    horizontalPoints: ArrayConstructor;
+    xAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    offset: ObjectConstructor;
+    xAxis: ObjectConstructor;
+    yAxis: ObjectConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    width: NumberConstructor;
+    horizontal: (ObjectConstructor | BooleanConstructor)[];
+    horizontalPoints: ArrayConstructor;
+    xAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    yAxisId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: number;
+    };
+    offset: ObjectConstructor;
+    xAxis: ObjectConstructor;
+    yAxis: ObjectConstructor;
+}>> & Readonly<{}>, {
+    yAxisId: string | number;
+    xAxisId: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default HorizontalGridLines;

package/dist/cartesian/cartesian-grid/HorizontalStripes.d.ts

@@ -0,0 +1,20 @@
+declare const HorizontalStripes: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    horizontalFill: ArrayConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    horizontalPoints: ArrayConstructor;
+    horizontal: (ObjectConstructor | BooleanConstructor)[];
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    horizontalFill: ArrayConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    horizontalPoints: ArrayConstructor;
+    horizontal: (ObjectConstructor | BooleanConstructor)[];
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default HorizontalStripes;

package/dist/cartesian/cartesian-grid/VerticalGridLines.d.ts

@@ -0,0 +1,26 @@
+declare const VerticalGridLines: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    verticalPoints: ArrayConstructor;
+    xAxisId: (NumberConstructor | StringConstructor)[];
+    yAxisId: (NumberConstructor | StringConstructor)[];
+    offset: ObjectConstructor;
+    xAxis: ObjectConstructor;
+    yAxis: ObjectConstructor;
+    vertical: (ObjectConstructor | BooleanConstructor)[];
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    verticalPoints: ArrayConstructor;
+    xAxisId: (NumberConstructor | StringConstructor)[];
+    yAxisId: (NumberConstructor | StringConstructor)[];
+    offset: ObjectConstructor;
+    xAxis: ObjectConstructor;
+    yAxis: ObjectConstructor;
+    vertical: (ObjectConstructor | BooleanConstructor)[];
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default VerticalGridLines;

package/dist/cartesian/cartesian-grid/VerticalStripes.d.ts

@@ -0,0 +1,20 @@
+declare const VerticalStripes: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    verticalFill: ArrayConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    verticalPoints: ArrayConstructor;
+    vertical: (ObjectConstructor | BooleanConstructor)[];
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    verticalFill: ArrayConstructor;
+    fillOpacity: NumberConstructor;
+    x: NumberConstructor;
+    y: NumberConstructor;
+    width: NumberConstructor;
+    height: NumberConstructor;
+    verticalPoints: ArrayConstructor;
+    vertical: (ObjectConstructor | BooleanConstructor)[];
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default VerticalStripes;

package/dist/cartesian/cartesian-grid/const.d.ts

@@ -0,0 +1,6 @@
+import { CartesianGridProps } from './type';
+export declare const CartesianAxisDefaultProps: Partial<CartesianGridProps>;
+export type FilteredSvgElementType = 'svg' | 'polyline' | 'polygon';
+/** map of svg element types to unique svg attributes that belong to that element */
+export declare const FilteredElementKeyMap: Record<FilteredSvgElementType, string[]>;
+export declare const SVGElementPropKeys: string[];

package/dist/cartesian/cartesian-grid/index.d.ts

@@ -0,0 +1 @@
+export * from './CartesianGrid';