@moderneinc/react-charts 1.1.0 → 1.2.0-next.0d3f64

package/dist/components/parliament-chart/{ParliamentChart.types.d.ts → parliament-chart.types.d.ts}

@@ -1,4 +1,5 @@
-import { ParliamentChartTheme } from '../../theme/defaultColors';
+import { ParliamentChartTheme } from '../../theme/default-colors';
+import { ArcSweepDirection } from './utils/parliament-animation';
 type ParliamentDataSeries = {
     value: number;
     label: string;
@@ -12,6 +13,10 @@ export type ParliamentChartProps = {
     arcAngle?: number;
     useEnhanced?: boolean;
     theme?: ParliamentChartTheme;
+    showTable?: boolean;
+    shouldAnimate?: boolean;
+    animationDirection?: ArcSweepDirection;
+    onAnimationComplete?: () => void;
 };
 export type ProcessedDataItem = {
     id: string | number;

package/dist/components/parliament-chart/utils/parliament-animation.d.ts

@@ -0,0 +1,13 @@
+export type ArcSweepDirection = 'left-to-right' | 'right-to-left';
+/**
+ * Animates the parliament chart with an arc sweep reveal effect.
+ * Creates a clipPath that progressively reveals or collapses seats.
+ *
+ * @param svgElement - The SVG element containing the parliament chart
+ * @param arcAngle - The arc angle in degrees (e.g., 200)
+ * @param radius - The radius of the parliament arc
+ * @param direction - Direction of the sweep: 'left-to-right' (expand) or 'right-to-left' (collapse)
+ * @param duration - Animation duration in milliseconds (default: 900ms)
+ * @param onComplete - Optional callback fired when animation completes
+ */
+export declare function animateArcSweep(svgElement: SVGSVGElement, arcAngle: number, radius: number, direction?: ArcSweepDirection, duration?: number, onComplete?: () => void): void;

package/dist/components/stacked-area-chart/hooks/use-stacked-area-chart.hook.d.ts

@@ -0,0 +1,6 @@
+import { UseStackedAreaChartProps, UseStackedAreaChartReturn } from '../stacked-area-chart.types';
+/**
+ * Manages stacked area chart data validation, processing, and formatting.
+ * Handles category validation, timestamp ranges, and max value computation.
+ */
+export declare function useStackedAreaChart(props: UseStackedAreaChartProps): UseStackedAreaChartReturn;

package/dist/components/stacked-area-chart/stacked-area-chart.component.d.ts

@@ -0,0 +1,10 @@
+import { FunctionComponent } from 'react';
+import { StackedAreaChartProps } from './stacked-area-chart.types';
+/**
+ * Displays time-series data as a stacked area chart with responsive sizing,
+ * customizable colors, interactive tooltips, and smooth animations.
+ *
+ * Designed for ParliamentChart transitions - data structure supports point-in-time
+ * views enabling animated morphing between visualizations.
+ */
+export declare const StackedAreaChart: FunctionComponent<StackedAreaChartProps>;

package/dist/components/stacked-area-chart/stacked-area-chart.constants.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Default colors for stacked area chart categories
+ * These colors are designed to work well together and provide good contrast
+ * Migration colors match the exact gradient used in ParliamentChart for visual consistency
+ */
+export declare const DEFAULT_STACKED_AREA_COLORS: {
+    readonly critical: "#dc3545";
+    readonly high: "#fd7e14";
+    readonly medium: "#ffc107";
+    readonly low: "#17a2b8";
+    readonly complete: "#40c048";
+    readonly inProgress: "#007bff";
+    readonly farthest: string | undefined;
+    readonly far: string | undefined;
+    readonly close: string | undefined;
+    readonly closest: string | undefined;
+    readonly completed: string | undefined;
+    readonly primary: "#007bff";
+    readonly secondary: "#6c757d";
+    readonly success: "#40c048";
+    readonly danger: "#dc3545";
+    readonly warning: "#ffc107";
+    readonly info: "#17a2b8";
+    readonly light: "#EDEFEF";
+    readonly dark: "#343a40";
+};
+/**
+ * Default configuration for stacked area chart
+ */
+export declare const DEFAULT_STACKED_AREA_CONFIG: {
+    readonly dimensions: {
+        readonly height: 400;
+        readonly width: "100%";
+        readonly minHeight: 200;
+    };
+    readonly margin: {
+        readonly top: 10;
+        readonly right: 30;
+        readonly left: 0;
+        readonly bottom: 0;
+    };
+    readonly animation: {
+        readonly enabled: true;
+        readonly duration: 1500;
+        readonly easing: "ease";
+    };
+    readonly display: {
+        readonly showHeader: true;
+        readonly showLegend: true;
+        readonly showTooltip: true;
+        readonly showXAxis: true;
+        readonly showYAxis: true;
+        readonly showGrid: true;
+    };
+    readonly curve: {
+        readonly type: "monotone";
+    };
+    readonly stack: {
+        readonly offset: "none";
+    };
+    readonly axis: {
+        readonly strokeColor: "#ADB5BD";
+        readonly tickColor: "#666";
+        readonly labelColor: "#666";
+    };
+    readonly tooltip: {
+        readonly backgroundColor: "rgba(255, 255, 255, 0.95)";
+        readonly borderColor: "#ADB5BD";
+        readonly borderWidth: 1;
+        readonly borderRadius: 4;
+        readonly padding: 10;
+    };
+    readonly legend: {
+        readonly iconSize: 14;
+        readonly iconType: "square";
+        readonly layout: "horizontal";
+        readonly align: "center";
+        readonly verticalAlign: "bottom";
+    };
+    readonly marker: {
+        readonly strokeColor: "#666";
+        readonly strokeWidth: 2;
+        readonly strokeDasharray: "5 5";
+        readonly labelColor: "#666";
+    };
+};
+/**
+ * Predefined color palettes for common use cases
+ */
+export declare const STACKED_AREA_PALETTES: {
+    readonly migration: string[];
+    readonly severity: readonly ["#dc3545", "#fd7e14", "#ffc107", "#17a2b8", "#17a2b8"];
+    readonly status: readonly ["#dc3545", "#ffc107", "#40c048"];
+    readonly extended: readonly ["#e74c3c", "#e67e22", "#f39c12", "#2ecc71", "#3498db", "#9b59b6", "#1abc9c", "#95a5a6"];
+    readonly colorblindSafe: readonly ["#0173B2", "#DE8F05", "#029E73", "#CC78BC", "#CA9161", "#FBAFE4", "#949494", "#ECE133"];
+};
+/**
+ * Category label constants for common use cases
+ * These match the categories used in ParliamentChart for transition compatibility
+ */
+export declare const CATEGORY_LABELS: {
+    readonly FARTHEST: "Farthest";
+    readonly FAR: "Far";
+    readonly CLOSE: "Close";
+    readonly CLOSEST: "Closest";
+    readonly COMPLETE: "Complete";
+    readonly CRITICAL: "Critical";
+    readonly HIGH: "High";
+    readonly MEDIUM: "Medium";
+    readonly LOW: "Low";
+    readonly INFO: "Info";
+    readonly NOT_APPLICABLE: "N/A";
+    readonly NO_LST: "No LST";
+    readonly DATA_MISSING: "Data Missing";
+};

package/dist/components/stacked-area-chart/stacked-area-chart.types.d.ts

@@ -0,0 +1,186 @@
+import { BoxProps, StackProps, TypographyProps } from '@mui/material';
+/**
+ * Represents a single data point in the stacked area chart.
+ * Each property beyond timestamp represents a category value at that point in time.
+ *
+ * Example:
+ * {
+ *   timestamp: 1704067200000,
+ *   Complete: 120,
+ *   Close: 45,
+ *   Far: 30
+ * }
+ */
+export type StackedAreaDataPoint = {
+    timestamp: number;
+    [category: string]: number;
+};
+/**
+ * Defines a category (area) in the stacked area chart.
+ * The dataKey must match a property in StackedAreaDataPoint.
+ */
+export type StackedAreaCategory = {
+    /** Key matching the property name in data points */
+    dataKey: string;
+    /** Display label for the category */
+    label: string;
+    /** Color for this area (hex color or CSS color string) */
+    color: string;
+    /** Optional stroke width in pixels (default: 2) */
+    strokeWidth?: number;
+    /** Optional dash pattern for the stroke (e.g., '5 5' for dashed) */
+    strokeDasharray?: string;
+    /** Optional fill opacity (0-1, default: 0.7) */
+    fillOpacity?: number;
+};
+/**
+ * Defines a marker (vertical line) at a specific timestamp.
+ * Markers are useful for highlighting significant events like releases, deployments, or milestones.
+ */
+export type StackedAreaMarker = {
+    /** Timestamp where the marker should be placed on the X-axis */
+    timestamp: number;
+    /** Optional label to display on the marker */
+    label?: string;
+    /** Optional color for the marker line (default: from config) */
+    color?: string;
+    /** Optional stroke width in pixels (default: from config) */
+    strokeWidth?: number;
+    /** Optional dash pattern for the stroke (e.g., '5 5' for dashed) */
+    strokeDasharray?: string;
+};
+/**
+ * Slot props for customizing stacked area chart component styles
+ */
+export type StackedAreaChartSlotProps = {
+    /** Props for the outer container (Stack) */
+    container?: StackProps;
+    /** Props for the header container (Stack) */
+    header?: StackProps;
+    /** Props for the title Typography component */
+    title?: TypographyProps;
+    /** Props for the subtitle/description Typography component */
+    subtitle?: TypographyProps;
+    /** Props for the chart container (Box) */
+    chartContainer?: BoxProps;
+};
+/**
+ * Props for the StackedAreaChart component
+ */
+export type StackedAreaChartProps = {
+    /** Array of data points sorted by timestamp (ascending) */
+    data: StackedAreaDataPoint[];
+    /** Array of category definitions for the areas to display */
+    categories: StackedAreaCategory[];
+    /** Optional array of markers (vertical lines) to display at specific timestamps */
+    markers?: StackedAreaMarker[];
+    /** Optional title displayed above the chart */
+    title?: string;
+    /** Optional subtitle/description displayed below the title */
+    subtitle?: string;
+    /** Show the chart header (title and subtitle) */
+    showHeader?: boolean;
+    /** Height of the chart in pixels (default: 400) */
+    height?: number;
+    /** Width of the chart (default: '100%') */
+    width?: string | number;
+    /** Show the legend */
+    showLegend?: boolean;
+    /** Show the tooltip on hover */
+    showTooltip?: boolean;
+    /** Show X-axis labels */
+    showXAxis?: boolean;
+    /** Show Y-axis labels */
+    showYAxis?: boolean;
+    /** Show grid lines */
+    showGrid?: boolean;
+    /** Enable animations */
+    enableAnimation?: boolean;
+    /** Animation duration in milliseconds (default: 1500) */
+    animationDuration?: number;
+    /** Animation easing function (default: 'ease') */
+    animationEasing?: 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | 'linear';
+    /** Custom date formatter for X-axis and tooltip */
+    formatDate?: (timestamp: number) => string;
+    /** Custom value formatter for Y-axis and tooltip */
+    formatValue?: (value: number) => string;
+    /** Custom tooltip formatter */
+    tooltipFormatter?: (value: number, name: string, props: unknown) => [string, string];
+    /** Props for customizing individual component slots */
+    slotProps?: StackedAreaChartSlotProps;
+    /** Margin around the chart (for axis labels) */
+    margin?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+    };
+    /**
+     * Curve type for the area paths
+     * - 'monotone': Smooth curves that preserve monotonicity
+     * - 'linear': Straight lines between points
+     * - 'step': Step function
+     * - 'stepBefore': Step function with vertical at start
+     * - 'stepAfter': Step function with vertical at end
+     */
+    curveType?: 'monotone' | 'linear' | 'step' | 'stepBefore' | 'stepAfter';
+    /**
+     * Stack offset type
+     * - 'none': Stack normally
+     * - 'expand': Normalize to 0-100%
+     * - 'wiggle': Streamgraph layout
+     * - 'silhouette': Centered streamgraph
+     */
+    stackOffset?: 'none' | 'expand' | 'wiggle' | 'silhouette';
+    /**
+     * External time domain control [minTimestamp, maxTimestamp]
+     * When provided, overrides automatic domain calculation and controls the X-axis range.
+     * Useful for synchronizing multiple charts to show the same time range.
+     */
+    timeRange?: [number, number] | null;
+    /**
+     * Callback when user selects a time range via brush or other interaction
+     * Returns [startTimestamp, endTimestamp]
+     */
+    onTimeRangeChange?: (range: [number, number]) => void;
+    /**
+     * Enable brush component for time range selection
+     * When enabled, displays a brush control below the chart that users can drag to select a time range.
+     * Triggers onTimeRangeChange callback when the brush is moved.
+     */
+    enableBrush?: boolean;
+    /**
+     * Zoom to selection mode - When enabled, dragging to select a range
+     * will automatically rescale the chart to show only that range via the timeRange prop.
+     * Selection highlight only shows during drag.
+     */
+    zoomToSelection?: boolean;
+};
+/**
+ * Props for the custom hook
+ */
+export type UseStackedAreaChartProps = {
+    data: StackedAreaDataPoint[];
+    categories: StackedAreaCategory[];
+    formatDate?: (timestamp: number) => string;
+    formatValue?: (value: number) => string;
+};
+/**
+ * Return type for the custom hook
+ */
+export type UseStackedAreaChartReturn = {
+    /** Validated and processed data */
+    processedData: StackedAreaDataPoint[];
+    /** Validated categories */
+    processedCategories: StackedAreaCategory[];
+    /** Minimum timestamp in data */
+    minTimestamp: number;
+    /** Maximum timestamp in data */
+    maxTimestamp: number;
+    /** Total value at each timestamp (sum of all categories) */
+    maxTotalValue: number;
+    /** Default date formatter */
+    dateFormatter: (timestamp: number) => string;
+    /** Default value formatter */
+    valueFormatter: (value: number) => string;
+};

package/dist/components/stacked-area-chart/utils/color.utils.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Generates gradient colors for categories, ordered from worst (red) to best (green).
+ */
+export declare function generateMeasureGradient(count: number): string[];

package/dist/components/stacked-area-with-timeline/hooks/use-stacked-area-with-timeline.hook.d.ts

@@ -0,0 +1,52 @@
+import { RefObject } from 'react';
+import { D3StackedAreaCategory } from '../../d3-stacked-area-chart/d3-stacked-area-chart.types';
+import { HoveredData, HoveredMarker, HoveredTimelineEvent, StackedAreaDataPoint, TimelineEvent } from '../stacked-area-with-timeline.types';
+export type UseStackedAreaWithTimelineOptions = {
+    containerRef: RefObject<SVGSVGElement | null>;
+    data: StackedAreaDataPoint[];
+    categories: D3StackedAreaCategory[];
+    width: number;
+    height: number;
+    margin: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    timelineEvents?: TimelineEvent[];
+    showTimeline?: boolean;
+    timelineHeight?: number;
+    timelineOffset?: number;
+    timeRange?: [number, number];
+    showGrid?: boolean;
+    showAxes?: boolean;
+    axisLabelColor?: string;
+    axisLabelSize?: number;
+    enableBrush?: boolean;
+    onTimeRangeChange?: (range: [number, number]) => void;
+    minAllowedTime?: number;
+    maxAllowedTime?: number;
+    brushColor?: string;
+    formatDate?: (timestamp: number) => string;
+    formatValue?: (value: number) => string;
+    markers?: Array<{
+        timestamp: number;
+        label?: string;
+        color?: string;
+    }>;
+    onHoveredDataChange?: (data: HoveredData) => void;
+    hoveredCategory?: string | null;
+    onTimelineEventHover?: (event: HoveredTimelineEvent) => void;
+};
+export type VisibleMarker = {
+    timestamp: number;
+    label?: string;
+    color?: string;
+    x: number;
+};
+export type UseStackedAreaWithTimelineResult = {
+    hoveredTimelineEvent: HoveredTimelineEvent;
+    hoveredMarker: HoveredMarker;
+    visibleMarkers: VisibleMarker[];
+};
+export declare const useStackedAreaWithTimeline: ({ containerRef, data, categories, width, height, margin, timelineEvents, showTimeline, timelineHeight, timelineOffset, timeRange, showGrid, showAxes, axisLabelColor, axisLabelSize, enableBrush, onTimeRangeChange, minAllowedTime, maxAllowedTime, brushColor, formatDate, formatValue, markers, onHoveredDataChange, hoveredCategory, onTimelineEventHover }: UseStackedAreaWithTimelineOptions) => UseStackedAreaWithTimelineResult;

package/dist/components/stacked-area-with-timeline/index.d.ts

@@ -0,0 +1,4 @@
+export { StackedAreaWithTimeline } from './stacked-area-with-timeline.component';
+export type { HoveredData, HoveredTimelineEvent, StackedAreaDataPoint, StackedAreaWithTimelineProps, TimelineEvent } from './stacked-area-with-timeline.types';
+export type { HoveredTimelineEvent as TimelineHoveredEvent, RenderTimelineTrackOptions, TimelineEvent as TimelineEventData } from './utils/render-timeline-track';
+export { renderTimelineTrack } from './utils/render-timeline-track';

package/dist/components/stacked-area-with-timeline/stacked-area-with-timeline.component.d.ts

@@ -0,0 +1,3 @@
+import { FunctionComponent } from 'react';
+import { StackedAreaWithTimelineProps } from './stacked-area-with-timeline.types';
+export declare const StackedAreaWithTimeline: FunctionComponent<StackedAreaWithTimelineProps>;

package/dist/components/stacked-area-with-timeline/stacked-area-with-timeline.types.d.ts

@@ -0,0 +1,97 @@
+import { D3StackedAreaCategory } from '../d3-stacked-area-chart/d3-stacked-area-chart.types';
+export type StackedAreaDataPoint = {
+    timestamp: number;
+    values: Record<string, number>;
+};
+export type TimelineEvent = {
+    timestamp: number;
+    eventName: string;
+    color?: string;
+};
+export type HoveredData = {
+    label: string;
+    value: number;
+    color: string;
+} | null;
+export type HoveredTimelineEvent = {
+    timestamp: number;
+    eventName: string;
+    x: number;
+} | null;
+export type HoveredMarker = {
+    timestamp: number;
+    label?: string;
+    color?: string;
+    x: number;
+} | null;
+export type StackedAreaWithTimelineProps = {
+    /** Time series data points */
+    data: StackedAreaDataPoint[];
+    /** Category definitions (colors, labels, data keys) */
+    categories: D3StackedAreaCategory[];
+    /** Timeline events to display below the chart */
+    timelineEvents?: TimelineEvent[];
+    /** Show the timeline track (default: true if timelineEvents provided) */
+    showTimeline?: boolean;
+    /** Height of the timeline track in pixels (default: 40) */
+    timelineHeight?: number;
+    /** Vertical space between chart and timeline in pixels (default: 35) */
+    timelineOffset?: number;
+    /** Chart width in pixels (default: 900) */
+    width?: number;
+    /** Chart height in pixels, not including timeline (default: 400) */
+    height?: number;
+    /** Chart margins */
+    margin?: {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    /** Show grid lines (default: true) */
+    showGrid?: boolean;
+    /** Show axes (default: true) */
+    showAxes?: boolean;
+    /**
+     * Color for axis labels (dates on x-axis, values on y-axis).
+     * @default undefined (inherits from SVG default, typically black)
+     */
+    axisLabelColor?: string;
+    /**
+     * Font size for axis labels in pixels.
+     * Increase for smaller chart displays (e.g., dashboards).
+     * @default 14
+     */
+    axisLabelSize?: number;
+    /** Custom date formatter for x-axis */
+    formatDate?: (timestamp: number) => string;
+    /** Custom value formatter for y-axis */
+    formatValue?: (value: number) => string;
+    /** Time range to display [start, end] timestamps */
+    timeRange?: [number, number];
+    /** Enable brush selection for zooming/panning */
+    enableBrush?: boolean;
+    /** Callback when time range changes via brush */
+    onTimeRangeChange?: (range: [number, number]) => void;
+    /** Minimum allowed timestamp for brush constraint */
+    minAllowedTime?: number;
+    /** Maximum allowed timestamp for brush constraint */
+    maxAllowedTime?: number;
+    /**
+     * Color for brush selection overlay.
+     * @default '#69b3a2'
+     */
+    brushColor?: string;
+    /** Event markers (vertical lines on the main chart) */
+    markers?: Array<{
+        timestamp: number;
+        label?: string;
+        color?: string;
+    }>;
+    /** Callback when a category is hovered */
+    onHoveredDataChange?: (data: HoveredData) => void;
+    /** Currently hovered category (for external highlighting control) */
+    hoveredCategory?: string | null;
+    /** Callback when a timeline event is hovered */
+    onTimelineEventHover?: (event: HoveredTimelineEvent) => void;
+};

package/dist/components/stacked-area-with-timeline/utils/render-timeline-track.d.ts

@@ -0,0 +1,54 @@
+import { ScaleTime } from 'd3-scale';
+import { Selection } from 'd3-selection';
+export type TimelineEvent = {
+    timestamp: number;
+    eventName: string;
+    color?: string;
+};
+export type HoveredTimelineEvent = {
+    timestamp: number;
+    eventName: string;
+    x: number;
+} | null;
+export type RenderTimelineTrackOptions = {
+    /** D3 SVG selection */
+    svg: Selection<SVGSVGElement, unknown, null, undefined>;
+    /** Timeline events to display */
+    events: TimelineEvent[];
+    /** D3 time scale for x-axis */
+    xScale: ScaleTime<number, number>;
+    /** Height of the main chart area (timeline renders below this) */
+    chartHeight: number;
+    /** Width of the chart area */
+    chartWidth: number;
+    /** Height of the timeline track */
+    timelineHeight: number;
+    /** Vertical offset between chart and timeline */
+    timelineOffset: number;
+    /** Optional instance ID for unique CSS classes */
+    instanceId?: string;
+    /** Callback when an event is hovered */
+    setHoveredTimelineEvent: (event: HoveredTimelineEvent) => void;
+    /** Enable brush selection on timeline */
+    enableBrush?: boolean;
+    /** Callback when time range changes via brush */
+    onTimeRangeChange?: (range: [number, number]) => void;
+    /** Minimum allowed timestamp for brush constraint */
+    minAllowedTime?: number;
+    /** Maximum allowed timestamp for brush constraint */
+    maxAllowedTime?: number;
+    /** Color for brush selection overlay */
+    brushColor?: string;
+    /** CSS selector for the main chart group (default: '.main-chart-group') */
+    mainGroupSelector?: string;
+};
+/**
+ * Renders an interactive timeline track below a chart
+ *
+ * Features:
+ * - Event markers as vertical colored lines
+ * - Hover interactions with width expansion
+ * - Optional brush selection with constraint bounds
+ * - Double-click to reset to full time range
+ */
+export declare function renderTimelineTrack({ svg, events, xScale, chartHeight, chartWidth, timelineHeight, timelineOffset, instanceId, setHoveredTimelineEvent, enableBrush, onTimeRangeChange, minAllowedTime, maxAllowedTime, brushColor, mainGroupSelector }: RenderTimelineTrackOptions): void;

package/dist/components/timeline-chart/hooks/use-timeline-chart.hook.d.ts

@@ -0,0 +1,2 @@
+import { UseTimelineChartProps, UseTimelineChartReturn } from '../timeline-chart.types';
+export declare const useTimelineChart: ({ events, selectedRange, onSelectionChange, enableZoom, zoomToSelection, visibleRange, onVisibleRangeChange }: UseTimelineChartProps) => UseTimelineChartReturn;

package/dist/components/timeline-chart/timeline-chart.component.d.ts

@@ -0,0 +1,9 @@
+import { FunctionComponent } from 'react';
+import { TimelineChartProps } from './timeline-chart.types';
+/**
+ * TimelineChart component - Interactive timeline with drag selection and zoom
+ *
+ * Displays events on a timeline with interactive selection capabilities.
+ * Users can click and drag to select date ranges, and use mouse wheel to zoom.
+ */
+export declare const TimelineChart: FunctionComponent<TimelineChartProps>;