vccs 0.6.0 → 1.0.0-beta.2

package/dist/index.d.ts

@@ -1,9 +1,130 @@
-export * from './cartesian';
-export * from './chart';
-export * from './container';
-export * from './components';
-export * from './polar';
-export * from './shape';
-export * from './hooks/publicHooks';
-export { Global } from './utils/Global';
-export type { GlobalConfig, GlobalConfigKeys } from './utils/Global';
+import { SvgTemplateAttributes, WithAttributes } from './utils/attributes.js';
+import { default as ResponsiveContainerComponent } from './container/ResponsiveContainer.js';
+import { default as TextComponent } from './components/Text.js';
+export { Area } from './cartesian/area/Area.js';
+export { XAxis } from './cartesian/axis/XAxis.js';
+export { YAxis } from './cartesian/axis/YAxis.js';
+export { Bar } from './cartesian/bar/Bar.js';
+export { Brush } from './cartesian/brush/Brush.js';
+export { CartesianAxis } from './cartesian/cartesian-axis/CartesianAxis.js';
+export { CartesianGrid } from './cartesian/cartesian-grid/CartesianGrid.js';
+export { ErrorBar } from './cartesian/error-bar/ErrorBar.js';
+export { Funnel } from './cartesian/funnel/Funnel.js';
+export { Line } from './cartesian/line/Line.js';
+export { ReferenceArea } from './cartesian/reference-area/ReferenceArea.js';
+export { ReferenceDot } from './cartesian/reference-dot/ReferenceDot.js';
+export { ReferenceLine } from './cartesian/reference-line/ReferenceLine.js';
+export { Scatter } from './cartesian/scatter/Scatter.js';
+export { ZAxis } from './cartesian/z-axis/ZAxis.js';
+export type { CartesianPosition } from './cartesian/getCartesianPosition.js';
+export type { AreaSlots } from './cartesian/area/Area.js';
+export type { AreaDotSlotProps } from './cartesian/area/type.js';
+export type { BarSlots } from './cartesian/bar/type.js';
+export type { Orientation, Unit } from './cartesian/cartesian-axis/CartesianAxis.js';
+export type { CartesianGridLineSlotProps, CartesianGridSlots } from './cartesian/cartesian-grid/type.js';
+export type { FunnelSlots } from './cartesian/funnel/Funnel.js';
+export type { LineSlots } from './cartesian/line/type.js';
+export type { ReferenceDotShapeProps, ReferenceDotSlots } from './cartesian/reference-dot/ReferenceDot.js';
+export type { FunnelTrapezoidItem } from './types/funnel.js';
+export type { LinePointItem } from './types/line.js';
+export type { TickFormatter } from './types/tick.js';
+export { AreaChart } from './chart/AreaChart.js';
+export { BarChart } from './chart/BarChart.js';
+export { BarList } from './chart/BarList.js';
+export { CalendarHeatmap } from './chart/CalendarHeatmap.js';
+export { CohortChart } from './chart/CohortChart.js';
+export { ComposedChart } from './chart/ComposedChart.js';
+export { FunnelChart } from './chart/FunnelChart.js';
+export { Heatmap } from './chart/Heatmap.js';
+export { JourneySankey } from './chart/JourneySankey.js';
+export { LineChart } from './chart/LineChart.js';
+export { PieChart } from './chart/PieChart.js';
+export { RadarChart } from './chart/RadarChart.js';
+export { RadialBarChart } from './chart/RadialBarChart.js';
+export { Sankey } from './chart/Sankey.js';
+export { ScatterChart } from './chart/ScatterChart.js';
+export { Sparkline } from './chart/Sparkline.js';
+export { SunburstChart } from './chart/SunburstChart.js';
+export { Tracker } from './chart/Tracker.js';
+export { Treemap } from './chart/Treemap.js';
+export type { BarListRow, BarListSlotProps, BarListSlots } from './chart/BarList.js';
+export type { CalendarDay, CalendarHeatmapSlots } from './chart/CalendarHeatmap.js';
+export type { CohortCell, CohortChartSlots } from './chart/CohortChart.js';
+export type { HeatmapCell, HeatmapKey, HeatmapSlots } from './chart/Heatmap.js';
+export type { JourneyHeaderSlotProps, JourneyLabelSlotProps, JourneySankeySlots } from './chart/journeyTypes.js';
+export type { SankeyLinkSlotProps, SankeyNodeSlotProps, SankeySlots } from './chart/Sankey.js';
+export type { SparklineSlots } from './chart/Sparkline.js';
+export type { SunburstContentSlotProps, SunburstSlots } from './chart/SunburstChart.js';
+export type { SunburstData } from './chart/sunburstUtils.js';
+export type { TrackerRow, TrackerSlots } from './chart/Tracker.js';
+export type { TreemapContentSlotProps, TreemapSlots } from './chart/Treemap.js';
+/**
+ * @deprecated Charts are responsive by default: remove the wrapper and set `width`, `height`
+ * or `aspect` on the chart. Removed in 2.0 (see internals/migrations.md).
+ */
+export declare const ResponsiveContainer: typeof ResponsiveContainerComponent;
+export type { ResponsiveContainerProps } from './container/ResponsiveContainer.js';
+/** SVG text with wrapping and scaling; forwards SVG attributes such as `font-size`. */
+export declare const Text: WithAttributes<typeof TextComponent, SvgTemplateAttributes>;
+export { Cell } from './components/Cell.js';
+export { Customized } from './components/Customized.js';
+export { Label } from './components/label/Label.js';
+export { LabelList } from './components/label/LabelList.js';
+export { default as Legend } from './components/legend/Legend.js';
+export { Tooltip } from './components/tooltip/Tooltip.js';
+export type { CellProps } from './components/Cell.js';
+export type { CustomizedSlotProps, CustomizedSlots } from './components/Customized.js';
+export type { LegendContentProps } from './components/legend/type.js';
+export type { TooltipSlots } from './components/tooltip/Tooltip.js';
+export type { CrossCursorSlotProps, CursorSlotProps, CurveCursorSlotProps, RectangleCursorSlotProps, SectorCursorSlotProps, TooltipContentProps, } from './components/tooltip/types.js';
+export { Pie } from './polar/pie/Pie.js';
+export { PolarAngleAxis } from './polar/radar/PolarAngleAxis.js';
+export { PolarGrid } from './polar/radar/PolarGrid.js';
+export { PolarRadiusAxis } from './polar/radar/PolarRadiusAxis.js';
+export { Radar } from './polar/radar/Radar.js';
+export { RadialBar } from './polar/radial-bar/RadialBar.js';
+export type { PieSlots } from './polar/pie/Pie.js';
+export type { RadarShapeSlotProps, RadarSlots } from './polar/radar/Radar.js';
+export type { RadialBarShapeSlotProps, RadialBarSlots } from './polar/radial-bar/RadialBar.js';
+export { Cross } from './shape/Cross.js';
+export { Curve } from './shape/Curve.js';
+export { Dot } from './shape/Dot.js';
+export { Polygon } from './shape/Polygon.js';
+export { Rectangle } from './shape/Rectangle.js';
+export { Sector } from './shape/Sector.js';
+export { Symbols } from './shape/Symbols.js';
+export { Trapezoid } from './shape/Trapezoid.js';
+export type { CrossProps } from './shape/Cross.js';
+export type { CurveType } from './shape/Curve.js';
+export type { PolygonPoint, PolygonProps } from './shape/Polygon.js';
+export type { SymbolsProps, SymbolType } from './shape/Symbols.js';
+export type { MinPointSize, Point, TrapezoidItem } from './types/shape.js';
+export type * from './publicProps.js';
+export { useIsTooltipActive, useActiveTooltipCoordinate, useActiveTooltipLabel, usePlotArea, useXAxisDomain, useYAxisDomain, useXAxisTicks, useYAxisTicks, useXAxisScale, useYAxisScale, useXAxisInverseScale, useYAxisInverseScale, useXAxisInverseDataSnapScale, useYAxisInverseDataSnapScale, useXAxisInverseTickSnapScale, useYAxisInverseTickSnapScale, useCartesianScale, useChartWidth, useChartHeight, useMargin, } from './hooks/publicHooks.js';
+export type { InverseScaleFunction, ScaleFunction, CartesianDataPoint } from './hooks/publicHooks.js';
+export { useActiveTooltipDataPoints } from './hooks/useActiveTooltipDataPoints.js';
+export { chartThemeTokens } from './utils/theme.js';
+export type { ChartTransition } from './animation/motion.js';
+export type { ChartPointerState } from './events/componentEvents.js';
+export type { TreemapLayoutNode } from './chart/treemapUtils.js';
+export type { SankeyLayoutNode, SankeyLayoutLink } from './chart/sankeyUtils.js';
+export type { GridCell } from './chart/cellGridUtils.js';
+export type { JourneyInput, JourneyLink, JourneyNode, JourneyStep } from './chart/journeyUtils.js';
+export type { CellSlotProps } from './chart/CellGridLayer.js';
+export type { BarRectangleItem } from './types/bar.js';
+export type { AreaPointItem } from './core/area.js';
+export type { ScatterPointItem } from './types/common.js';
+export type { PieSectorDataItem } from './core/pie.js';
+export type { RadarPoint } from './types/radar.js';
+export type { RadialBarDataItem } from './types/radialBar.js';
+export type { BrushStartEndIndex } from './types/chartData.js';
+export type { LegendPayload } from './types/legend.js';
+export type { LegendBoundingBox } from './components/legend/Legend.js';
+export type { BrushIndex } from './cartesian/brush/type.js';
+export type { TooltipActiveIndex } from './types/tooltip.js';
+export type { LegendHidden } from './components/legend/type.js';
+export { defineChartComponents } from './typed.js';
+export type { RowDataKey } from './types/typed.js';
+export type { TypedComponents, TypedTooltipContentProps, TypedTooltipPayload, TypedLegendPayload, } from './typed.js';
+export type { TooltipPayloadEntry, TooltipPayload } from './types/tooltip.js';
+export type { AxisProps } from './cartesian/axis/AxisProps.js';

package/dist/model/animation.d.ts

@@ -0,0 +1,7 @@
+import { ChartTransition } from '../animation/motion.js';
+export interface ChartAnimation {
+    isAnimationActive?: boolean;
+    transition?: ChartTransition;
+}
+export declare function provideChartAnimation(props: ChartAnimation): void;
+export declare function useChartAnimation(): ChartAnimation;

package/dist/model/axis.d.ts

@@ -0,0 +1,29 @@
+import { createAxisLayout } from './axisLayout.js';
+import { AxisModel, AxisScaleSources } from './axisScale.js';
+import { createPolarAxis } from './polarAxis.js';
+import { createChartData } from './dataRange.js';
+import { PolarLayout } from './polar.js';
+import { EffectScope } from 'vue';
+import { AxisId, AxisType } from '../types/axis.js';
+import { XAxisSettings, YAxisSettings, ZAxisSettings } from '../types/axisSettings.js';
+import { LayoutType, StackOffsetType } from '../types/common.js';
+import { ChartRegistries } from './registries.js';
+interface AxisModels {
+    angleAxis: ReturnType<typeof createPolarAxis>;
+    radiusAxis: ReturnType<typeof createPolarAxis>;
+    xAxis: AxisModel<XAxisSettings> & ReturnType<typeof createAxisLayout>;
+    yAxis: AxisModel<YAxisSettings> & ReturnType<typeof createAxisLayout>;
+    zAxis: AxisModel<ZAxisSettings>;
+}
+interface AxisSources extends AxisScaleSources, Pick<ChartRegistries, 'items' | 'axes' | 'references'> {
+    size: () => import('../types/common.js').Size;
+    barCategoryGap: () => number | string;
+    polarLayout: PolarLayout;
+    dataRange: ReturnType<typeof createChartData>;
+    layout: () => LayoutType;
+    stackOffset: () => StackOffsetType;
+    reverseStackOrder: () => boolean;
+}
+export type AxisLookup = <T extends AxisType>(type: T, id: AxisId) => AxisModels[T];
+export declare function createAxes(scope: EffectScope, sources: AxisSources): AxisLookup;
+export {};

package/dist/model/axisLayout.d.ts

@@ -0,0 +1,85 @@
+import { ComputedRef } from 'vue';
+import { AxisId } from '../types/axis.js';
+import { Size } from '../types/common.js';
+import { XAxisSettings, YAxisSettings } from '../types/axisSettings.js';
+import { AxisScaleModel, AxisScaleSources } from './axisScale.js';
+import { ChartRegistries } from './registries.js';
+export declare function createAxisLayout<S extends XAxisSettings | YAxisSettings>(sources: AxisScaleSources & Pick<ChartRegistries, 'axes'> & {
+    size: () => Size;
+}, axis: AxisScaleModel<S> & {
+    settings: ComputedRef<S>;
+}, type: 'xAxis' | 'yAxis', id: AxisId): {
+    size: ComputedRef<{
+        width: number;
+        height: number;
+    }>;
+    position: ComputedRef<{
+        x: number;
+        y: number;
+    }>;
+    grid: ComputedRef<{
+        axisType: "xAxis" | "yAxis";
+        categoricalDomain: readonly unknown[] | undefined;
+        duplicateDomain: readonly unknown[] | undefined;
+        isCategorical: boolean;
+        niceTicks: readonly number[] | undefined;
+        range: import('../types/axis.js').AxisRange | undefined;
+        realScaleType: string | undefined;
+        scale: import('../types/scale.js').RechartsScale;
+        angle: number;
+        interval: import('../types/axis.js').AxisInterval;
+        tickFormatter: import('../index.js').TickFormatter | undefined;
+        unit: string | undefined;
+        allowDecimals: boolean;
+        ticks: ReadonlyArray<import('../types/tick.js').AxisTick> | undefined;
+        id?: AxisId | undefined;
+        type: "number" | "category";
+        dataKey: import('../types/base.js').ChartDataKey | undefined;
+        name: string | undefined;
+        allowDuplicatedCategory: boolean;
+        allowDataOverflow: boolean;
+        reversed: boolean;
+        includeHidden: boolean;
+        domain: import('../types/axis.js').AxisDomain | undefined;
+        mirror: boolean;
+        minTickGap: number;
+        hide: boolean;
+        tickCount: number | undefined;
+        tick: import('vue').SVGAttributes | boolean;
+        padding: import('../types/axis.js').XAxisPadding;
+        height: number;
+        orientation: import('../types/axis.js').XAxisOrientation;
+    } | {
+        axisType: "xAxis" | "yAxis";
+        categoricalDomain: readonly unknown[] | undefined;
+        duplicateDomain: readonly unknown[] | undefined;
+        isCategorical: boolean;
+        niceTicks: readonly number[] | undefined;
+        range: import('../types/axis.js').AxisRange | undefined;
+        realScaleType: string | undefined;
+        scale: import('../types/scale.js').RechartsScale;
+        angle: number;
+        interval: import('../types/axis.js').AxisInterval;
+        tickFormatter: import('../index.js').TickFormatter | undefined;
+        unit: string | undefined;
+        allowDecimals: boolean;
+        ticks: ReadonlyArray<import('../types/tick.js').AxisTick> | undefined;
+        id?: AxisId | undefined;
+        type: "number" | "category";
+        dataKey: import('../types/base.js').ChartDataKey | undefined;
+        name: string | undefined;
+        allowDuplicatedCategory: boolean;
+        allowDataOverflow: boolean;
+        reversed: boolean;
+        includeHidden: boolean;
+        domain: import('../types/axis.js').AxisDomain | undefined;
+        mirror: boolean;
+        minTickGap: number;
+        hide: boolean;
+        tickCount: number | undefined;
+        tick: import('vue').SVGAttributes | boolean;
+        padding: import('../types/axis.js').YAxisPadding;
+        orientation: import('../types/axis.js').YAxisOrientation;
+        width: number | "auto";
+    }>;
+};

package/dist/model/axisScale.d.ts

@@ -0,0 +1,41 @@
+import { StackGroup } from '../core/axis/stacks.js';
+import { AppliedChartData, ChartData } from '../types/chartData.js';
+import { ComputedRef } from 'vue';
+import { AxisRange, AxisType, BaseCartesianAxis, NumberDomain } from '../types/axis.js';
+import { CategoricalDomain } from '../types/categorical.js';
+import { ChartOffsetRequired, LayoutType } from '../types/common.js';
+import { TicksSettings } from '../types/axisSettings.js';
+import { ChartCapabilities } from './options.js';
+export interface AxisScaleSources {
+    layout: () => LayoutType;
+    categoryScale: () => ChartCapabilities['categoryScale'];
+    hasBar: () => boolean;
+    offset: () => ChartOffsetRequired;
+}
+export declare function createAxisScale<S extends BaseCartesianAxis & Partial<TicksSettings>>(sources: AxisScaleSources, type: AxisType, settings: ComputedRef<S>, domain: ComputedRef<NumberDomain | CategoricalDomain | undefined>, appliedValues: ComputedRef<AppliedChartData>, range: ComputedRef<AxisRange | undefined>): {
+    realScaleType: ComputedRef<string | undefined>;
+    niceTicks: ComputedRef<readonly number[] | undefined>;
+    range: ComputedRef<AxisRange | undefined>;
+    reversedRange: ComputedRef<AxisRange | undefined>;
+    scale: ComputedRef<import('../types/scale.js').RechartsScale | undefined>;
+    duplicateDomain: ComputedRef<readonly unknown[] | undefined>;
+    categoricalDomain: ComputedRef<readonly unknown[] | undefined>;
+    ticks: ComputedRef<readonly import('../types/common.js').TickItem[] | undefined>;
+    graphicalTicks: ComputedRef<import('../types/common.js').TickItem[] | null>;
+    tooltipTicks: ComputedRef<readonly import('../types/common.js').TickItem[] | null>;
+    withScale: ComputedRef<(S & {
+        scale: import('../types/scale.js').RechartsScale;
+    }) | undefined>;
+    bandSize: ComputedRef<number | undefined>;
+    barBandSize: ComputedRef<number | undefined>;
+    inverseScale: ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
+    inverseDataScale: ComputedRef<import('../utils/createCategoricalInverse.js').InverseScaleFunction | undefined>;
+    inverseTickScale: ComputedRef<((pixel: number) => unknown) | undefined>;
+};
+export type AxisScaleModel<S extends BaseCartesianAxis & Partial<TicksSettings> = BaseCartesianAxis> = ReturnType<typeof createAxisScale<S>>;
+export interface AxisModel<S extends BaseCartesianAxis = BaseCartesianAxis> extends AxisScaleModel<S> {
+    readonly settings: ComputedRef<S>;
+    readonly displayedData: ComputedRef<ChartData>;
+    readonly stackGroups: ComputedRef<Record<string, StackGroup>>;
+    readonly domain: ComputedRef<NumberDomain | CategoricalDomain | undefined>;
+}

package/dist/model/brush.d.ts

@@ -0,0 +1,17 @@
+import { Padding } from '../types/index.js';
+import { BrushStartEndIndex } from '../types/chartData.js';
+export interface BrushSettings {
+    x: number | undefined;
+    y: number | undefined;
+    width: number | undefined;
+    height: number;
+    padding: Padding;
+    /** The Brush's requested window: its controlled `range` or its own state; `null` = all rows. */
+    range: BrushStartEndIndex | null;
+    onRangeChange?: (range: BrushStartEndIndex) => void;
+}
+export declare function createChartBrush(): {
+    state: import('vue').ComputedRef<BrushSettings>;
+    range: import('vue').ComputedRef<BrushStartEndIndex | null | undefined>;
+    register: (entry: Readonly<import('vue').Ref<BrushSettings | undefined, BrushSettings | undefined>>) => void;
+};

package/dist/model/chart.d.ts

@@ -0,0 +1,44 @@
+import { createTooltip } from './tooltip.js';
+import { createPolarLayout } from './polar.js';
+import { AxisLookup } from './axis.js';
+import { createChartData } from './dataRange.js';
+import { ChartGeometry } from './layout.js';
+import { createChartBrush } from './brush.js';
+import { createChartLegend } from './legend.js';
+import { ChartRegistries } from './registries.js';
+import { ComputedRef } from 'vue';
+import { LayoutType, Margin, Size } from '../types/index.js';
+import { CartesianViewBoxRequired } from '../types/viewBox.js';
+import { ChartData } from '../types/chartData.js';
+import { ChartFrame } from '../types/chartLayout.js';
+import { ChartOptions } from './options.js';
+import { PolarChartOptions } from '../types/polarOptions.js';
+import { UpdatableChartOptions } from '../types/chartOptions.js';
+export interface ChartInputs {
+    data: () => ChartData | undefined;
+    layout: () => LayoutType;
+    size: () => Size;
+    margin: () => Margin;
+    options: () => UpdatableChartOptions;
+    polar: () => PolarChartOptions | null;
+    tooltip: () => Omit<ChartOptions, 'eventEmitter'>;
+}
+export interface Chart extends ChartRegistries, ChartGeometry {
+    readonly legendArea: ComputedRef<CartesianViewBoxRequired>;
+    readonly direction: ComputedRef<string | undefined>;
+    readonly tooltip: ReturnType<typeof createTooltip>;
+    readonly polarLayout: ReturnType<typeof createPolarLayout>;
+    readonly axis: AxisLookup;
+    readonly dataRange: ReturnType<typeof createChartData>;
+    readonly inputs: ChartInputs;
+    readonly data: ComputedRef<ChartData | undefined>;
+    readonly layout: ComputedRef<ChartFrame>;
+    readonly options: ComputedRef<UpdatableChartOptions>;
+    readonly polar: ComputedRef<PolarChartOptions | null>;
+    readonly tooltipOptions: ComputedRef<ChartOptions>;
+    readonly brush: ReturnType<typeof createChartBrush>;
+    readonly legend: ReturnType<typeof createChartLegend>;
+}
+export declare function createChart(inputs: ChartInputs): Chart;
+export declare function provideChart(chart: Chart): void;
+export declare function useChart(): Chart;

package/dist/model/dataRange.d.ts

@@ -0,0 +1,19 @@
+import { BrushStartEndIndex, ChartData } from '../types/chartData.js';
+/**
+ * The displayed row window. A registered Brush owns it (`null` = all rows); without a Brush the
+ * chart follows the last range received from a synchronised peer. `undefined` from `brushRange`
+ * means no Brush is registered.
+ */
+export declare function createChartData(source: () => ChartData | undefined, brushRange?: () => BrushStartEndIndex | null | undefined): {
+    state: import('vue').ComputedRef<{
+        chartData: ChartData | undefined;
+        dataStartIndex: number;
+        dataEndIndex: number;
+    }>;
+    receiveSyncedRange: (value: BrushStartEndIndex) => void;
+    displayedData: <T extends readonly unknown[]>(item: {
+        data?: T;
+    }, range?: "brush" | "all") => ChartData | T | undefined;
+    tooltipData: (itemData: unknown) => unknown;
+};
+export declare function normalizeBrushRange(value: BrushStartEndIndex | null, length: number): BrushStartEndIndex | null;

package/dist/model/defaults.d.ts

@@ -0,0 +1,7 @@
+import { LayoutType, Margin } from '../types/index.js';
+import { UpdatableChartOptions } from '../types/chartOptions.js';
+import { PolarChartOptions } from '../types/polarOptions.js';
+export declare const chartDefaults: UpdatableChartOptions & PolarChartOptions & {
+    layout: LayoutType;
+    margin: Margin;
+};

package/dist/model/layout.d.ts

@@ -0,0 +1,38 @@
+import { ChartFrame } from '../types/chartLayout.js';
+import { BrushSettings } from './brush.js';
+import { LegendSettings } from './legend.js';
+import { Size } from '../types/common.js';
+import { ChartRegistries } from './registries.js';
+interface LayoutSources {
+    layout: () => ChartFrame;
+    brush: () => BrushSettings;
+    legendSettings: () => LegendSettings;
+    legendSize: () => Size;
+    axes: ChartRegistries['axes'];
+}
+export declare function createLayout(sources: LayoutSources): {
+    width: import('vue').ComputedRef<number>;
+    height: import('vue').ComputedRef<number>;
+    margin: import('vue').ComputedRef<import('../types/common.js').Margin>;
+    offset: import('vue').ComputedRef<import('../types/common.js').ChartOffset>;
+    viewBox: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    axisViewBox: import('vue').ComputedRef<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    brushDimensions: import('vue').ComputedRef<{
+        height: number;
+        x: number;
+        y: number;
+        width: number;
+    }>;
+};
+export type ChartGeometry = ReturnType<typeof createLayout>;
+export {};

package/dist/model/legend.d.ts

@@ -0,0 +1,28 @@
+import { HorizontalAlignmentType, LegendPayload, VerticalAlignmentType } from '../types/legend.js';
+import { CartesianPosition } from '../cartesian/getCartesianPosition.js';
+import { LayoutType, Size } from '../types/index.js';
+export interface LegendSettings {
+    layout: LayoutType;
+    align: HorizontalAlignmentType;
+    verticalAlign: VerticalAlignmentType;
+    position?: CartesianPosition;
+    offset?: number;
+}
+export declare function createChartLegend(): {
+    state: import('vue').ComputedRef<{
+        settings: LegendSettings;
+        hidden: Set<string>;
+        size: Size;
+    }>;
+    entries: import('./registry.js').Registry<readonly LegendPayload[]>;
+    payload: import('vue').ComputedRef<LegendPayload[]>;
+    register: (entry: Readonly<import('vue').Ref<{
+        settings: LegendSettings;
+        hidden: readonly string[] | undefined;
+        size: Size | undefined;
+    } | undefined, {
+        settings: LegendSettings;
+        hidden: readonly string[] | undefined;
+        size: Size | undefined;
+    } | undefined>>) => void;
+};

package/dist/model/options.d.ts

@@ -0,0 +1,30 @@
+import { TooltipPayloadSearcher } from '../types/tooltip.js';
+import { TooltipEventType } from '../types/index.js';
+/**
+ * What a chart root draws, declared by the chart instead of read from its name, so a chart
+ * defined with another name behaves the same.
+ */
+export interface ChartCapabilities {
+    /**
+     * Scale of a category axis with `scale="auto"`: `point` (Line, Area), `band` (Bar), or `auto`,
+     * which is point unless the chart holds a Bar.
+     */
+    categoryScale: 'point' | 'band' | 'auto';
+    /** Axis tooltip cursor: a line (a sector in radial layout), a band rectangle, or a cross. */
+    cursor: 'line' | 'rect' | 'cross';
+    /** Connected series the chart draws; Line and Area render only where listed. */
+    series: ReadonlyArray<'line' | 'area'>;
+}
+export declare const defaultChartCapabilities: ChartCapabilities;
+/** Internal options remain fixed for the lifetime of a chart root. */
+export type ChartOptions = {
+    chartName: string;
+    capabilities: ChartCapabilities;
+    defaultTooltipEventType: TooltipEventType;
+    validateTooltipEventTypes?: ReadonlyArray<TooltipEventType>;
+    tooltipPayloadSearcher?: TooltipPayloadSearcher;
+    /**
+     * Identifies the sending chart when synchronising, so a chart ignores its own broadcasts.
+     */
+    eventEmitter: symbol | undefined;
+};

package/dist/model/polar.d.ts

@@ -0,0 +1,24 @@
+import { ChartOffsetRequired, LayoutType, Size } from '../types/common.js';
+import { PolarChartOptions } from '../types/polarOptions.js';
+export declare function createPolarLayout(sources: {
+    layout: () => LayoutType;
+    size: () => Size;
+    offset: () => ChartOffsetRequired;
+    polar: () => PolarChartOptions | null;
+}): {
+    maxRadius: import('vue').ComputedRef<number>;
+    innerRadius: import('vue').ComputedRef<number | undefined>;
+    outerRadius: import('vue').ComputedRef<number | undefined>;
+    angleRange: import('vue').ComputedRef<readonly [number, number]>;
+    radiusRange: import('vue').ComputedRef<readonly [number, number] | undefined>;
+    viewBox: import('vue').ComputedRef<{
+        cx: number;
+        cy: number;
+        innerRadius: number;
+        outerRadius: number;
+        startAngle: number;
+        endAngle: number;
+        clockWise: boolean;
+    } | undefined>;
+};
+export type PolarLayout = ReturnType<typeof createPolarLayout>;

package/dist/model/polarAxis.d.ts

@@ -0,0 +1,39 @@
+import { AxisId } from '../types/axis.js';
+import { AngleAxisSettings } from '../types/axisSettings.js';
+import { StackOffsetType } from '../types/common.js';
+import { ChartRegistries } from './registries.js';
+import { AxisScaleSources } from './axisScale.js';
+import { createChartData } from './dataRange.js';
+import { PolarLayout } from './polar.js';
+export declare function createPolarAxis(sources: AxisScaleSources & Pick<ChartRegistries, 'items' | 'axes'> & {
+    dataRange: ReturnType<typeof createChartData>;
+    stackOffset: () => StackOffsetType;
+    reverseStackOrder: () => boolean;
+    polarLayout: PolarLayout;
+}, type: 'angleAxis' | 'radiusAxis', id: AxisId): {
+    realScaleType: import('vue').ComputedRef<string | undefined>;
+    niceTicks: import('vue').ComputedRef<readonly number[] | undefined>;
+    range: import('vue').ComputedRef<import('../types/axis.js').AxisRange | undefined>;
+    reversedRange: import('vue').ComputedRef<import('../types/axis.js').AxisRange | undefined>;
+    scale: import('vue').ComputedRef<import('../types/scale.js').RechartsScale | undefined>;
+    duplicateDomain: import('vue').ComputedRef<readonly unknown[] | undefined>;
+    categoricalDomain: import('vue').ComputedRef<readonly unknown[] | undefined>;
+    ticks: import('vue').ComputedRef<readonly import('../types/common.js').TickItem[] | undefined>;
+    graphicalTicks: import('vue').ComputedRef<import('../types/common.js').TickItem[] | null>;
+    tooltipTicks: import('vue').ComputedRef<readonly import('../types/common.js').TickItem[] | null>;
+    withScale: import('vue').ComputedRef<(import('../types/axis.js').BaseCartesianAxis & Omit<import('../types/tick.js').TicksSettings, "tick" | "tickCount"> & {
+        tickCount: number | undefined;
+        tick: import('vue').SVGAttributes | boolean;
+    } & {
+        scale: import('../types/scale.js').RechartsScale;
+    }) | undefined>;
+    bandSize: import('vue').ComputedRef<number | undefined>;
+    barBandSize: import('vue').ComputedRef<number | undefined>;
+    inverseScale: import('vue').ComputedRef<import('../index.js').InverseScaleFunction | undefined>;
+    inverseDataScale: import('vue').ComputedRef<import('../index.js').InverseScaleFunction | undefined>;
+    inverseTickScale: import('vue').ComputedRef<((pixel: number) => unknown) | undefined>;
+    settings: import('vue').ComputedRef<AngleAxisSettings>;
+    displayedData: import('vue').ComputedRef<import('../types/chartData.js').ChartData>;
+    stackGroups: import('vue').ComputedRef<Record<import('../types/tick.js').StackId, import('../core/axis/stacks.js').StackGroup>>;
+    domain: import('vue').ComputedRef<import('../types/axis.js').NumberDomain | import('../types/index.js').CategoricalDomain | undefined>;
+};

package/dist/model/presentation.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef } from 'vue';
+import { CartesianViewBoxRequired } from '../types/viewBox.js';
+import { ChartOffsetRequired, LayoutType, Margin } from '../types/index.js';
+import { ChartCapabilities } from './options.js';
+export interface ChartPresentation {
+    capabilities: ComputedRef<ChartCapabilities>;
+    layout: ComputedRef<LayoutType>;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+    margin: ComputedRef<Margin>;
+    viewBox: ComputedRef<CartesianViewBoxRequired>;
+    offset: ComputedRef<ChartOffsetRequired>;
+    accessibility: ComputedRef<boolean>;
+    bandSize: ComputedRef<number | undefined>;
+    syncId: ComputedRef<string | number | undefined>;
+    emitter: ComputedRef<symbol | undefined>;
+}
+export declare function provideChartPresentation(presentation: ChartPresentation): void;
+export declare function useChartPresentation(): ChartPresentation;

package/dist/model/registries.d.ts

@@ -0,0 +1,27 @@
+import { AngleAxisSettings, RadiusAxisSettings, XAxisSettings, YAxisSettings, ZAxisSettings } from '../types/axisSettings.js';
+import { CartesianGraphicalItemSettings, PolarGraphicalItemSettings } from '../types/graphical.js';
+import { ReferenceAreaSettings, ReferenceDotSettings, ReferenceLineSettings } from '../types/reference.js';
+import { ComputedRef } from 'vue';
+import { Registry } from './registry.js';
+export interface AxisRegistry<T> extends Registry<T> {
+    readonly byId: ComputedRef<ReadonlyMap<string, T>>;
+}
+export declare function createRegistries(): {
+    items: {
+        cartesian: Registry<CartesianGraphicalItemSettings>;
+        polar: Registry<PolarGraphicalItemSettings>;
+    };
+    axes: {
+        xAxis: AxisRegistry<XAxisSettings>;
+        yAxis: AxisRegistry<YAxisSettings>;
+        zAxis: AxisRegistry<ZAxisSettings>;
+        angleAxis: AxisRegistry<AngleAxisSettings>;
+        radiusAxis: AxisRegistry<RadiusAxisSettings>;
+    };
+    references: {
+        dots: Registry<ReferenceDotSettings>;
+        areas: Registry<ReferenceAreaSettings>;
+        lines: Registry<ReferenceLineSettings>;
+    };
+};
+export type ChartRegistries = ReturnType<typeof createRegistries>;

package/dist/model/registry.d.ts

@@ -0,0 +1,7 @@
+import { ComputedRef, Ref } from 'vue';
+export interface Registry<T> {
+    readonly registrations: ComputedRef<readonly Readonly<Ref<T | undefined>>[]>;
+    readonly entries: ComputedRef<readonly T[]>;
+    register: (entry: Readonly<Ref<T | undefined>>) => void;
+}
+export declare function createRegistry<T>(): Registry<T>;