vccs 0.0.1 → 0.2.0

package/dist/shape/Cross.d.ts

@@ -0,0 +1,10 @@
+import { SVGAttributes } from 'vue';
+export interface CrossProps {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    top?: number;
+    left?: number;
+}
+export declare function Cross(props: CrossProps & SVGAttributes): import("vue/jsx-runtime").JSX.Element;

package/dist/shape/Curve.d.ts

@@ -0,0 +1,42 @@
+import { PropType } from 'vue';
+import { CurveFactory } from 'victory-vendor/d3-shape';
+import { LayoutType, VuePropsToType, WithSVGProps } from '../types';
+export type CurveType = 'basis' | 'basisClosed' | 'basisOpen' | 'bumpX' | 'bumpY' | 'bump' | 'linear' | 'linearClosed' | 'natural' | 'monotoneX' | 'monotoneY' | 'monotone' | 'step' | 'stepBefore' | 'stepAfter' | CurveFactory;
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+    readonly payload?: any;
+}
+type GetPathProps = Pick<CurveProps, 'type' | 'points' | 'baseLine' | 'layout' | 'connectNulls'>;
+/**
+ * Calculate the path of curve. Returns null if points is an empty array.
+ * @return path or null
+ */
+export declare function getPath({ type, points, baseLine, layout, connectNulls, }: GetPathProps): string | null;
+export declare const CurveVueProps: {
+    type: {
+        type: PropType<CurveType | CurveFactory>;
+    };
+    layout: {
+        type: PropType<LayoutType>;
+    };
+    baseLine: {
+        type: PropType<number | ReadonlyArray<Point>>;
+    };
+    points: {
+        type: PropType<ReadonlyArray<Point>>;
+    };
+    connectNulls: {
+        type: BooleanConstructor;
+    };
+    path: {
+        type: StringConstructor;
+    };
+    class: {
+        type: (StringConstructor | ArrayConstructor)[];
+    };
+};
+export type CurvePropsWithOutSVG = VuePropsToType<typeof CurveVueProps>;
+export type CurveProps = WithSVGProps<typeof CurveVueProps>;
+export declare const Curve: import('vue').DefineComponent<CurveProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CurveProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/shape/Dot.d.ts

@@ -0,0 +1,18 @@
+import { WithSVGProps } from '../types';
+declare const DotVueProps: {
+    cx: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    cy: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    r: {
+        type: (NumberConstructor | StringConstructor)[];
+    };
+    clipDot: {
+        type: BooleanConstructor;
+    };
+};
+export type DotProps = WithSVGProps<typeof DotVueProps>;
+export declare const Dot: import('vue').DefineComponent<DotProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<DotProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/shape/Rectangle.d.ts

@@ -0,0 +1,33 @@
+import { PropType } from 'vue';
+import { VuePropsToType, WithSVGProps } from '../types';
+import { RectRadius } from '../types/bar';
+declare const RectangleVueProps: {
+    className: {
+        type: PropType<string>;
+        default: any;
+    };
+    x: {
+        type: PropType<number>;
+        default: number;
+    };
+    y: {
+        type: PropType<number>;
+        default: number;
+    };
+    width: {
+        type: PropType<number>;
+        default: number;
+    };
+    height: {
+        type: PropType<number>;
+        default: number;
+    };
+    radius: {
+        type: PropType<number | RectRadius>;
+        default: any;
+    };
+};
+export type RectangleProps = VuePropsToType<typeof RectangleVueProps>;
+export type RectanglePropsWithSVG = WithSVGProps<typeof RectangleVueProps>;
+export declare const Rectangle: import('vue').DefineComponent<RectanglePropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RectanglePropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/shape/Sector.d.ts

@@ -0,0 +1,48 @@
+import { PropType } from 'vue';
+import { VuePropsToType, WithSVGProps } from '../types';
+declare const SectorVueProps: {
+    cx: {
+        type: PropType<number>;
+        default: number;
+    };
+    cy: {
+        type: PropType<number>;
+        default: number;
+    };
+    innerRadius: {
+        type: PropType<number>;
+        default: number;
+    };
+    outerRadius: {
+        type: PropType<number>;
+        default: number;
+    };
+    startAngle: {
+        type: PropType<number>;
+        default: number;
+    };
+    endAngle: {
+        type: PropType<number>;
+        default: number;
+    };
+    cornerRadius: {
+        type: PropType<number | string>;
+        default: number;
+    };
+    forceCornerRadius: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    cornerIsExternal: {
+        type: PropType<boolean>;
+        default: boolean;
+    };
+    className: {
+        type: PropType<string>;
+        default: any;
+    };
+};
+export type SectorProps = VuePropsToType<typeof SectorVueProps>;
+export type SectorPropsWithSVG = WithSVGProps<typeof SectorVueProps>;
+export declare const Sector: import('vue').DefineComponent<SectorPropsWithSVG, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<SectorPropsWithSVG> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/shape/Symbols.d.ts

@@ -0,0 +1,15 @@
+export type SymbolType = 'circle' | 'cross' | 'diamond' | 'square' | 'star' | 'triangle' | 'wye';
+type SizeType = 'area' | 'diameter';
+export interface SymbolsProps {
+    className?: string;
+    type?: SymbolType;
+    cx?: number;
+    cy?: number;
+    size?: number;
+    sizeType?: SizeType;
+    fill?: string;
+    stroke?: string;
+    [key: string]: any;
+}
+export declare function Symbols(props: SymbolsProps): import("vue/jsx-runtime").JSX.Element;
+export {};

package/dist/shape/Trapezoid.d.ts

@@ -0,0 +1,31 @@
+import { PropType } from 'vue';
+import { WithSVGProps } from '../types';
+declare const TrapezoidVueProps: {
+    className: {
+        type: PropType<string>;
+        default: any;
+    };
+    x: {
+        type: PropType<number>;
+        default: number;
+    };
+    y: {
+        type: PropType<number>;
+        default: number;
+    };
+    upperWidth: {
+        type: PropType<number>;
+        default: number;
+    };
+    lowerWidth: {
+        type: PropType<number>;
+        default: number;
+    };
+    height: {
+        type: PropType<number>;
+        default: number;
+    };
+};
+export type TrapezoidComponentProps = WithSVGProps<typeof TrapezoidVueProps>;
+export declare const Trapezoid: import('vue').DefineComponent<TrapezoidComponentProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<TrapezoidComponentProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export {};

package/dist/shape/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './Cross';
+export { Curve, CurveVueProps, getPath } from './Curve';
+export type { CurveType, CurvePropsWithOutSVG, CurveProps } from './Curve';
+export * from './Dot';
+export * from './Rectangle';
+export * from './Symbols';
+export * from './Sector';
+export * from './Trapezoid';

package/dist/shape/types.d.ts

@@ -0,0 +1,20 @@
+import { AnimationEasing } from '../types/bar';
+export interface Point {
+    readonly x: number;
+    readonly y: number;
+}
+export type MinPointSize = number | ((value: number, index: number) => number);
+export type NormalizedStackId = string;
+export interface TrapezoidProps {
+    className?: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    upperWidth?: number;
+    lowerWidth?: number;
+    height?: number;
+    isUpdateAnimationActive?: boolean;
+    animationBegin?: number;
+    animationDuration?: number;
+    animationEasing?: AnimationEasing;
+}

package/dist/state/ReportBar.d.ts

@@ -0,0 +1 @@
+export declare function ReportBar(): null;

package/dist/state/ReportChartProps.d.ts

@@ -0,0 +1,88 @@
+import { PropType } from 'vue';
+import { StackOffsetType, SyncMethod } from '../types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    accessibilityLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    barCategoryGap: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    barGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    barSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    class: {
+        type: StringConstructor;
+        default: any;
+    };
+    maxBarSize: {
+        type: NumberConstructor;
+        default: any;
+    };
+    stackOffset: {
+        type: PropType<StackOffsetType>;
+        default: string;
+    };
+    syncId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    syncMethod: {
+        type: PropType<SyncMethod>;
+        default: string;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    accessibilityLayer: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    barCategoryGap: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: string;
+    };
+    barGap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    barSize: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    class: {
+        type: StringConstructor;
+        default: any;
+    };
+    maxBarSize: {
+        type: NumberConstructor;
+        default: any;
+    };
+    stackOffset: {
+        type: PropType<StackOffsetType>;
+        default: string;
+    };
+    syncId: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: any;
+    };
+    syncMethod: {
+        type: PropType<SyncMethod>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    accessibilityLayer: boolean;
+    barCategoryGap: string | number;
+    barGap: number;
+    barSize: string | number;
+    class: string;
+    maxBarSize: number;
+    stackOffset: StackOffsetType;
+    syncId: string | number;
+    syncMethod: SyncMethod;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/state/ReportMainChartProps.d.ts

@@ -0,0 +1,37 @@
+import { LayoutType } from '../types';
+import { PropType } from 'vue';
+export declare const ReportMainChartProps: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    layout: {
+        type: PropType<LayoutType>;
+        required: true;
+    };
+    margin: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    width: {
+        type: NumberConstructor;
+        required: true;
+    };
+    height: {
+        type: NumberConstructor;
+        required: true;
+    };
+    layout: {
+        type: PropType<LayoutType>;
+        required: true;
+    };
+    margin: {
+        type: ObjectConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/state/ReportPolarOptions.d.ts

@@ -0,0 +1,59 @@
+import { PropType } from 'vue';
+export declare const ReportPolarOptions: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    cx: {
+        type: PropType<number | string>;
+        default: string;
+    };
+    cy: {
+        type: PropType<number | string>;
+        default: string;
+    };
+    startAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    endAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    innerRadius: {
+        type: PropType<number | string>;
+        default: number;
+    };
+    outerRadius: {
+        type: PropType<number | string>;
+        default: string;
+    };
+}>, () => any, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    cx: {
+        type: PropType<number | string>;
+        default: string;
+    };
+    cy: {
+        type: PropType<number | string>;
+        default: string;
+    };
+    startAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    endAngle: {
+        type: NumberConstructor;
+        default: number;
+    };
+    innerRadius: {
+        type: PropType<number | string>;
+        default: number;
+    };
+    outerRadius: {
+        type: PropType<number | string>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    cx: string | number;
+    cy: string | number;
+    startAngle: number;
+    endAngle: number;
+    innerRadius: string | number;
+    outerRadius: string | number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/state/SetGraphicalItem.d.ts

@@ -0,0 +1,9 @@
+import { CartesianGraphicalItemSettings, PolarGraphicalItemSettings } from './graphicalItemsSlice';
+import { StackId } from '../types/tick';
+import { MaybeRef } from 'vue';
+type SetCartesianGraphicalItemProps = Partial<Omit<CartesianGraphicalItemSettings, 'stackId'> & {
+    stackId: StackId | undefined;
+}>;
+export declare function SetCartesianGraphicalItem(_props: MaybeRef<SetCartesianGraphicalItemProps>): void;
+export declare function SetPolarGraphicalItem(_props: MaybeRef<Partial<PolarGraphicalItemSettings>>): void;
+export {};

package/dist/state/SetLegendPayload.d.ts

@@ -0,0 +1,3 @@
+import { LegendPayload } from '../components/DefaultLegendContent';
+import { MaybeRef } from 'vue';
+export declare function SetLegendPayload(_legendPayload: MaybeRef<ReadonlyArray<LegendPayload>>): null;

package/dist/state/SetTooltipEntrySettings.d.ts

@@ -0,0 +1,8 @@
+import { TooltipPayloadConfiguration } from './tooltipSlice';
+import { Ref } from 'vue';
+type SetTooltipEntrySettingsProps<T> = {
+    args: Ref<T>;
+    fn: (input: T) => TooltipPayloadConfiguration;
+};
+export declare function SetTooltipEntrySettings<T>({ fn, args }: SetTooltipEntrySettingsProps<T>): void;
+export {};

package/dist/state/brushSlice.d.ts

@@ -0,0 +1,18 @@
+import { Padding } from '../types';
+import { PayloadAction } from '@reduxjs/toolkit';
+/**
+ * From all Brush properties, only height has a default value and will be always defined.
+ * Other properties are nullable and will be computed from offsets and margins if they are not set.
+ */
+export type BrushSettings = {
+    x: number | undefined;
+    y: number | undefined;
+    width: number | undefined;
+    height: number;
+    padding: Padding;
+};
+export declare const brushSlice: import('@reduxjs/toolkit').Slice<BrushSettings, {
+    setBrushSettings(_state: BrushSettings, action: PayloadAction<BrushSettings | null>): BrushSettings;
+}, "brush", "brush", import('@reduxjs/toolkit').SliceSelectors<BrushSettings>>;
+export declare const setBrushSettings: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<BrushSettings, "brush/setBrushSettings">;
+export declare const brushReducer: import('@reduxjs/toolkit').Reducer<BrushSettings>;

package/dist/state/cartesianAxisSlice.d.ts

@@ -0,0 +1,88 @@
+import { AxisRange } from './selectors/axisSelectors';
+import { SVGAttributes } from 'vue';
+import { RechartsScale, ScaleType } from '../types/scale';
+import { AxisDomain, AxisDomainType, AxisInterval } from '../types/axis';
+import { DataKey } from '../types';
+import { AxisTick, TickFormatter } from '../types/tick';
+export type AxisId = string | number;
+export type XAxisPadding = {
+    left?: number;
+    right?: number;
+} | 'gap' | 'no-gap';
+export type YAxisPadding = {
+    top?: number;
+    bottom?: number;
+} | 'gap' | 'no-gap';
+export type XAxisOrientation = 'top' | 'bottom';
+export type YAxisOrientation = 'left' | 'right';
+/**
+ * Properties shared in X, Y, and Z axes
+ */
+export type BaseCartesianAxis = {
+    id?: AxisId;
+    scale: ScaleType | RechartsScale | undefined;
+    type: AxisDomainType;
+    /**
+     * The axis functionality is severely restricted without a dataKey
+     * - but there is still something left, and the prop is optional
+     * so this can also be undefined even in real charts.
+     * There are no defaults.
+     */
+    dataKey: DataKey<any> | undefined;
+    unit: string | undefined;
+    name: string | undefined;
+    allowDuplicatedCategory: boolean;
+    allowDataOverflow: boolean;
+    reversed: boolean;
+    includeHidden: boolean;
+    domain: AxisDomain | undefined;
+};
+export type TicksSettings = {
+    allowDecimals: boolean;
+    tickCount: number;
+    /**
+     * Ticks can be any type when the axis is the type of category
+     * Ticks must be numbers when the axis is the type of number
+     */
+    ticks: ReadonlyArray<AxisTick> | undefined;
+    tick: SVGAttributes | boolean;
+};
+/**
+ * These are the external props, visible for users as they set them using our public API.
+ * There is all sorts of internal computed things based on these, but they will come through selectors.
+ *
+ * Properties shared between X and Y axes
+ */
+export type CartesianAxisSettings = BaseCartesianAxis & TicksSettings & {
+    interval: AxisInterval;
+    mirror: boolean;
+    minTickGap: number;
+    angle: number;
+    hide: boolean;
+    tickFormatter: TickFormatter | undefined;
+};
+export type XAxisSettings = CartesianAxisSettings & {
+    padding: XAxisPadding;
+    height: number;
+    orientation: XAxisOrientation;
+};
+export type YAxisSettings = CartesianAxisSettings & {
+    padding: YAxisPadding;
+    width: number;
+    orientation: YAxisOrientation;
+};
+/**
+ * Z axis is special because it's never displayed. It controls the size of Scatter dots,
+ * but it never displays ticks anywhere.
+ */
+export type ZAxisSettings = BaseCartesianAxis & {
+    range: AxisRange;
+};
+type AxisMapState = {
+    xAxis: Record<AxisId, XAxisSettings>;
+    yAxis: Record<AxisId, YAxisSettings>;
+    zAxis: Record<AxisId, ZAxisSettings>;
+};
+export declare const addXAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<XAxisSettings, "cartesianAxis/addXAxis">, removeXAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<XAxisSettings, "cartesianAxis/removeXAxis">, addYAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<YAxisSettings, "cartesianAxis/addYAxis">, removeYAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<YAxisSettings, "cartesianAxis/removeYAxis">, addZAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ZAxisSettings, "cartesianAxis/addZAxis">, removeZAxis: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ZAxisSettings, "cartesianAxis/removeZAxis">;
+export declare const cartesianAxisReducer: import('@reduxjs/toolkit').Reducer<AxisMapState>;
+export {};

package/dist/state/chartDataSlice.d.ts

@@ -0,0 +1,44 @@
+/**
+ * This is the data that's coming through main chart `data` prop
+ * Recharts is very flexible in what it accepts so the type is very flexible too.
+ * This will typically be an object, and various components will provide various `dataKey`
+ * that dictates how to pull data from that object.
+ *
+ * TL;DR: before dataKey
+ */
+export type ChartData = unknown[];
+export interface BrushStartEndIndex {
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * So this is the same unknown type as ChartData but this is after the dataKey has been applied.
+ * We still don't know what the type is - that depends on what exactly it was before the dataKey application,
+ * and the dataKey can return whatever anyway - but let's keep it separate as a form of documentation.
+ *
+ * TL;DR: ChartData after dataKey.
+ */
+export type AppliedChartData = ReadonlyArray<{
+    value: unknown;
+}>;
+export type ChartDataState = {
+    chartData: ChartData | undefined;
+    /**
+     * store a copy of chart data after it has been processed by each chart's specific
+     * compute functions. TODO: add other charts besides Sankey
+     */
+    computedData: unknown | undefined;
+    /**
+     * Using Brush, users can choose where they want to zoom in.
+     * This is zero-based index of the starting data point.
+     */
+    dataStartIndex: number;
+    /**
+     * Using Brush, users can choose where they want to zoom in.
+     * This is zero-based index of the last data point.
+     */
+    dataEndIndex: number;
+};
+export declare const initialChartDataState: ChartDataState;
+export declare const setChartData: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ChartData, "chartData/setChartData">, setDataStartEndIndexes: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"chartData/setDataStartEndIndexes">, setComputedData: import('@reduxjs/toolkit').ActionCreatorWithNonInferrablePayload<"chartData/setComputedData">;
+export declare const chartDataReducer: import('@reduxjs/toolkit').Reducer<ChartDataState>;

package/dist/state/externalEventsMiddleware.d.ts

@@ -0,0 +1,17 @@
+import { Middleware } from '@reduxjs/toolkit';
+import { CategoricalChartFunc } from '../types';
+type ExternalEventActionPayload = {
+    event: MouseEvent | PointerEvent | TouchEvent;
+    handler: null | CategoricalChartFunc;
+};
+export declare const externalEventAction: import('@reduxjs/toolkit').ActionCreatorWithOptionalPayload<ExternalEventActionPayload, string>;
+/**
+ * Calls external event handlers (onMouseMove, onClick, etc.) synchronously within the dispatch
+ * call stack, while the native event's `currentTarget` is still valid.
+ *
+ * Using createListenerMiddleware would defer the call to a microtask, at which point the browser
+ * has already cleared `e.currentTarget` per the DOM spec, breaking coordinate-based handlers like
+ * DraggablePie that rely on `getRelativeCoordinate(e)`.
+ */
+export declare const externalEventsMiddleware: Middleware;
+export {};