@solidports/recharts 0.1.0 → 0.1.1

package/src/state/types/StackedGraphicalItem.ts

@@ -1,34 +0,0 @@
-/* eslint-disable import/no-cycle */
-import { GraphicalItemSettings } from "../graphicalItemsSlice"
-import { NormalizedStackId } from "../../util/ChartUtils"
-import { DataKey } from "../../util/types"
-
-/**
- * Some graphical items allow data stacking. The stacks are optional,
- * so all props here are optional too.
- */
-export interface MaybeStackedGraphicalItem extends GraphicalItemSettings {
-	stackId: NormalizedStackId | undefined
-	/**
-	 * Bars have a size but Area does not.
-	 */
-	barSize: number | string | undefined
-}
-
-/**
- * Some graphical items allow data stacking.
- * This interface is used to represent the items that are stacked
- * because the user has provided the stackId and dataKey properties.
- */
-export interface DefinitelyStackedGraphicalItem extends MaybeStackedGraphicalItem {
-	stackId: NormalizedStackId
-	dataKey: DataKey<unknown>
-}
-
-export function isStacked<T extends GraphicalItemSettings>(
-	graphicalItem: T,
-): graphicalItem is T & DefinitelyStackedGraphicalItem {
-	return (
-		"stackId" in graphicalItem && graphicalItem.stackId != null && graphicalItem.dataKey != null
-	)
-}

package/src/state/useChartState.ts

@@ -1,17 +0,0 @@
-import { useContext } from 'solid-js';
-import { RechartsStateContext } from "./RechartsStateContext"
-import type { RechartsStateContextValue } from "./RechartsStateContext"
-
-/** Returns state + setState from the nearest RechartsStateProvider. Throws outside one. */
-export function useChartState(): RechartsStateContextValue {
-	const ctx = useContext(RechartsStateContext)
-	if (ctx == null) {
-		throw new Error("@solidports/recharts: useChartState called outside RechartsStateProvider")
-	}
-	return ctx
-}
-
-/** Returns state + setState from the nearest RechartsStateProvider, or null outside one. */
-export function useOptionalChartState(): RechartsStateContextValue | null {
-	return useContext(RechartsStateContext)
-}

package/src/state/zIndexSlice.ts

@@ -1,39 +0,0 @@
-import { DefaultZIndexes } from "../zIndex/DefaultZIndexes"
-
-export type ZIndexEntry = {
-	/**
-	 * Reference to the DOM element that corresponds to this z-index.
-	 * This element is used to create a portal for rendering components at this z-index.
-	 *
-	 * If undefined, it means no element is currently registered for this z-index,
-	 * and registration is in progress. If that happens, wait for the next render cycle.
-	 */
-	element: Element | undefined
-	/**
-	 * Panorama items can't mix with normal items in the same z-index layer,
-	 * because they are rendered in a different SVG element.
-	 * So we need to have a separate element reference for panorama z-index portals.
-	 */
-	panoramaElement: Element | undefined
-	consumers: number
-}
-
-export type ZIndexState = {
-	zIndexMap: Record<number, ZIndexEntry>
-}
-
-export function createInitialZIndexState(): ZIndexState {
-	const zIndexMap: ZIndexState["zIndexMap"] = {}
-	for (const current of Object.values(DefaultZIndexes)) {
-		zIndexMap[current] = { consumers: 0, element: undefined, panoramaElement: undefined }
-	}
-	return { zIndexMap }
-}
-
-export const initialZIndexState: ZIndexState = createInitialZIndexState()
-
-const defaultZIndexSet = new Set<number>(Object.values(DefaultZIndexes))
-
-export function isDefaultZIndex(zIndex: number): boolean {
-	return defaultZIndexSet.has(zIndex)
-}

package/src/synchronisation/syncSelectors.ts

@@ -1,7 +0,0 @@
-import type { ChartState } from "../state/store"
-import type { TooltipSyncState } from "../state/tooltipSlice"
-import { readChartState } from "../state/chartState"
-
-export function selectSynchronisedTooltipState(state: ChartState): TooltipSyncState {
-	return readChartState(state).tooltip.syncInteraction
-}

package/src/synchronisation/types.ts

@@ -1,44 +0,0 @@
-/* eslint-disable import/no-cycle */
-import { Coordinate, DataKey, TickItem } from "../util/types"
-import { TooltipIndex } from "../state/tooltipSlice"
-
-export type ActiveLabel = string | number | undefined
-
-/**
- * Despite the name, this type is used for all event types, not just mouse events.
- */
-export type MouseHandlerDataParam = {
-	/**
-	 * Index of the active tick in the current chart. Only works with number-indexed one-dimensional data charts,
-	 * like Line, Area, Bar, Pie, etc.
-	 *
-	 * Doesn't work with two-dimensional data charts like Treemap, Sankey. But one day it will which is why the TooltipIndex type is here.
-	 */
-	activeTooltipIndex: number | TooltipIndex | undefined
-	isTooltipActive: boolean
-	/**
-	 * Exactly the same as activeTooltipIndex - this was also duplicated in recharts@2 so let's keep both properties for better backwards compatibility.
-	 */
-	activeIndex: number | TooltipIndex | undefined
-	/**
-	 * The category or domain value of the active tooltip entry.
-	 */
-	activeLabel: ActiveLabel
-	activeDataKey: DataKey<unknown> | undefined
-	activeCoordinate: Coordinate | undefined
-}
-
-/**
- * Allows customisation of how the charts will synchronize tooltips and brushes.
- * Default: index
- *
- * 'index': other charts will reuse current datum's index within the data array. In cases where data does not have the same length, this might yield unexpected results.
- * 'value': will try to match other charts values
- * custom function: will receive two arguments and should return an index of the active tick in the current chart:
- * argument 1: ticks from the current chart
- * argument 2: active tooltip state from the other chart
- */
-export type SyncMethod =
-	| "index"
-	| "value"
-	| ((ticks: ReadonlyArray<TickItem>, data: MouseHandlerDataParam) => number)

package/src/synchronisation/useChartSynchronisation.tsx

@@ -1,404 +0,0 @@
-/* eslint-disable import/no-cycle */
-import { createEffect, untrack, createMemo } from 'solid-js';
-import { useChartStore } from "../state/RechartsStoreContext"
-import {
-	selectEventEmitter,
-	selectSyncId,
-	selectSyncMethod,
-} from "../state/selectors/rootPropsSelectors"
-import { BRUSH_SYNC_EVENT, eventCenter, TOOLTIP_SYNC_EVENT } from "../util/Events"
-import type { TooltipIndex, TooltipSyncState } from "../state/tooltipSlice"
-import { selectTooltipDataKey } from "../state/selectors/selectors"
-import type { Coordinate, TickItem, TooltipEventType } from "../util/types"
-import type { TooltipTrigger } from "../chart/types"
-import { selectActiveTooltipGraphicalItemId, selectTooltipAxisTicks } from "../state/selectors/tooltipSelectors"
-import { selectSynchronisedTooltipState } from "./syncSelectors"
-import { selectChartLayout, useViewBox } from "../context/chartLayoutContext"
-import { useIsPanorama } from "../context/PanoramaContext"
-import { selectChartViewBox } from "../state/selectors/selectChartOffsetInternal"
-import {
-	selectBrushDimensions,
-	selectBrushSettings,
-} from "../state/selectors/brushSelectors"
-import type { CartesianViewBoxRequired } from "../util/types"
-import type { BrushStartEndIndex } from "../context/brushUpdateContext"
-import type { ActiveLabel, MouseHandlerDataParam } from "./types"
-
-function useTooltipSyncEventsListener() {
-	const ctx = useChartStore()
-	if (ctx == null) {
-		return
-	}
-	const { store, setStore } = ctx
-	/* Capture isPanorama at owner setup. The listener fires from a non-Solid
-	   event bus (no owner on the call stack), so `useContext` inside `useViewBox`
-	   would return the default. Read viewBox directly off the captured store
-	   instead. Mirrors the original useViewBox body. */
-	const isPanorama = useIsPanorama()
-	const viewBox = (): CartesianViewBoxRequired | undefined => {
-		const rootViewBox = selectChartViewBox(store)
-		const brushDimensions = selectBrushDimensions(store)
-		const brushPadding = selectBrushSettings(store)?.padding
-		if (isPanorama === false || brushDimensions == null || brushPadding == null) {
-			return rootViewBox
-		}
-		return {
-			height: brushDimensions.height - brushPadding.top - brushPadding.bottom,
-			width: brushDimensions.width - brushPadding.left - brushPadding.right,
-			x: brushPadding.left,
-			y: brushPadding.top,
-		}
-	}
-
-	createEffect(
-		() => {
-			const mySyncId = selectSyncId(store)
-			/* Unsynchronised charts must not track the tooltip ticks (every data point). */
-			if (mySyncId == null) {
-				return null
-			}
-			return {
-				layout: selectChartLayout(store),
-				myEventEmitter: selectEventEmitter(store),
-				mySyncId,
-				syncMethod: selectSyncMethod(store),
-				tooltipTicks: selectTooltipAxisTicks(store),
-			}
-		},
-		(sync) => {
-		if (sync == null) {
-			/* This chart is not synchronised with any other chart so we don't need to listen for any events. */
-			return undefined
-		}
-		const { layout, myEventEmitter, mySyncId, syncMethod, tooltipTicks } = sync
-
-		const listener = (
-			incomingSyncId: number | string,
-			incomingState: TooltipSyncState,
-			emitter: symbol,
-		) => {
-			if (myEventEmitter === emitter) {
-				/* We don't want to process events that we sent ourselves. */
-				return
-			}
-			if (mySyncId !== incomingSyncId) {
-				/* This event is not for this chart */
-				return
-			}
-
-			/*
-			 * Handle source chart deactivation (mouseLeave) for ALL sync methods.
-			 * This must be checked before any syncMethod-specific logic to ensure
-			 * sourceViewBox is cleared, which allows isReceivingSynchronisation
-			 * to become false and lets the normal emission flow resume.
-			 */
-			if (incomingState.active === false) {
-				setStore("tooltip", "syncInteraction", {
-					active: false,
-					coordinate: undefined,
-					dataKey: undefined,
-					graphicalItemId: undefined,
-					index: null,
-					label: undefined,
-					sourceViewBox: undefined,
-				})
-				return
-			}
-
-			if (syncMethod === "index") {
-				const vb = viewBox()
-				if (vb && incomingState?.coordinate && incomingState.sourceViewBox) {
-					const { x, y, ...otherCoordinateProps } = incomingState.coordinate
-					const {
-						x: sourceX,
-						y: sourceY,
-						width: sourceWidth,
-						height: sourceHeight,
-					} = incomingState.sourceViewBox
-
-					const scaledCoordinate = {
-						...otherCoordinateProps,
-						x: vb.x + (sourceWidth ? (x - sourceX) / sourceWidth : 0) * vb.width,
-						y: vb.y + (sourceHeight ? (y - sourceY) / sourceHeight : 0) * vb.height,
-					}
-
-					const syncPayload = { ...incomingState, coordinate: scaledCoordinate }
-					setStore("tooltip", "syncInteraction", syncPayload)
-				} else {
-					setStore("tooltip", "syncInteraction", incomingState)
-				}
-				return
-			}
-
-			if (tooltipTicks == null) {
-				/* for the other two sync methods, we need the ticks to be available */
-				return
-			}
-
-			let activeTick: TickItem | undefined
-			if (typeof syncMethod === "function") {
-				/*
-				 * This is what the data shape in 2.x CategoricalChartState used to look like.
-				 * In 3.x we store things differently but let's try to keep the old shape for compatibility.
-				 */
-				const syncMethodParam: MouseHandlerDataParam = {
-					activeCoordinate: incomingState.coordinate,
-					activeDataKey: incomingState.dataKey,
-					activeIndex: incomingState.index == null ? undefined : Number(incomingState.index),
-					activeLabel: incomingState.label,
-					activeTooltipIndex: incomingState.index == null ? undefined : Number(incomingState.index),
-					isTooltipActive: incomingState.active,
-				}
-				/* Call a callback function. If there is an application specific algorithm */
-				const activeTooltipIndex = syncMethod(tooltipTicks, syncMethodParam)
-				activeTick = tooltipTicks[activeTooltipIndex]
-			} else if (syncMethod === "value") {
-				/* labels are always strings, tick.value might be a string or a number, depending on axis type */
-				activeTick = tooltipTicks.find((tick) => String(tick.value) === incomingState.label)
-			}
-
-			const { coordinate } = incomingState
-
-			const vbSync = viewBox()
-			if (coordinate == null || vbSync == null) {
-				setStore("tooltip", "syncInteraction", {
-					active: false,
-					coordinate: undefined,
-					dataKey: undefined,
-					graphicalItemId: undefined,
-					index: null,
-					label: undefined,
-					sourceViewBox: undefined,
-				})
-				return
-			}
-
-			if (activeTick == null) {
-				/*
-				 * The label from the source chart doesn't match any tick in this chart.
-				 * This happens when synced charts have different data arrays
-				 * (e.g., one chart has 3 data points while another has 252).
-				 *
-				 * We set active: false so the tooltip hides (correct — no data for this date),
-				 * but we keep sourceViewBox set to signal that we're still receiving sync events.
-				 * The emission guard in useTooltipChartSynchronisation checks sourceViewBox
-				 * (not active) to decide whether to suppress outgoing sync events.
-				 * Without this, the chart would emit a counter-sync event with active: false,
-				 * cascading to clear tooltips on ALL other synced charts.
-				 */
-				setStore("tooltip", "syncInteraction", {
-					active: false,
-					coordinate: undefined,
-					dataKey: undefined,
-					graphicalItemId: undefined,
-					index: null,
-					label: undefined,
-					sourceViewBox: incomingState.sourceViewBox,
-				})
-				return
-			}
-
-			const { x, y } = coordinate
-			const validateChartX = Math.min(x, vbSync.x + vbSync.width)
-			const validateChartY = Math.min(y, vbSync.y + vbSync.height)
-			const activeCoordinate: Coordinate = {
-				x: layout === "horizontal" ? activeTick.coordinate : validateChartX,
-				y: layout === "horizontal" ? validateChartY : activeTick.coordinate,
-			}
-
-			const activePayload = {
-				active: incomingState.active,
-				coordinate: activeCoordinate,
-				dataKey: incomingState.dataKey,
-				graphicalItemId: incomingState.graphicalItemId,
-				index: String(activeTick.index),
-				label: incomingState.label,
-				sourceViewBox: incomingState.sourceViewBox,
-			}
-			setStore("tooltip", "syncInteraction", activePayload)
-		}
-		/* Listeners fire inside another chart's effect; they read this chart's current state. */
-		const untrackedListener: typeof listener = (...args) => untrack(() => listener(...args))
-		eventCenter.on(TOOLTIP_SYNC_EVENT, untrackedListener)
-
-		return () => {
-			eventCenter.off(TOOLTIP_SYNC_EVENT, untrackedListener)
-		}
-		},
-	)
-}
-
-function useBrushSyncEventsListener() {
-	const ctx = useChartStore()
-	if (ctx == null) {
-		return
-	}
-	const { store, setStore } = ctx
-
-	createEffect(
-		() => ({ myEventEmitter: selectEventEmitter(store), mySyncId: selectSyncId(store) }),
-		({ myEventEmitter, mySyncId }) => {
-		if (mySyncId == null) {
-			/* This chart is not synchronised with any other chart so we don't need to listen for any events. */
-			return undefined
-		}
-
-		const listener = (
-			incomingSyncId: number | string,
-			action: BrushStartEndIndex,
-			emitter: symbol,
-		) => {
-			if (myEventEmitter === emitter) {
-				/* We don't want to process events that we sent ourselves. */
-				return
-			}
-			if (mySyncId === incomingSyncId) {
-				setStore("chartData", "dataStartIndex", action.startIndex)
-				setStore("chartData", "dataEndIndex", action.endIndex)
-			}
-		}
-		/* Listeners fire inside another chart's effect; they read this chart's current state. */
-		const untrackedListener: typeof listener = (...args) => untrack(() => listener(...args))
-		eventCenter.on(BRUSH_SYNC_EVENT, untrackedListener)
-
-		return () => {
-			eventCenter.off(BRUSH_SYNC_EVENT, untrackedListener)
-		}
-		},
-	)
-}
-
-/**
- * Will receive synchronisation events from other charts.
- *
- * Reads syncMethod from state and decides how to synchronise the tooltip based on that.
- *
- * @returns void
- */
-export function useSynchronisedEventsFromOtherCharts() {
-	const ctx = useChartStore()
-	if (ctx == null) {
-		return
-	}
-	const { store, setStore } = ctx
-
-	createEffect(
-		() => store.options.eventEmitter,
-		(eventEmitter) => {
-			if (eventEmitter == null) {
-				setStore("options", "eventEmitter", Symbol("rechartsEventEmitter"))
-			}
-		},
-	)
-
-	useTooltipSyncEventsListener()
-	useBrushSyncEventsListener()
-}
-
-/**
- * Will send events to other charts.
- * If syncId is undefined, no events will be sent.
- *
- * This ignores the syncMethod, because that is set and computed on the receiving end.
- *
- * @param tooltipEventType from Tooltip
- * @param trigger from Tooltip
- * @param activeCoordinate from state
- * @param activeLabel from state
- * @param activeIndex from state
- * @param isTooltipActive from state
- * @returns void
- */
-/* Each param is an accessor — reading inside the effect tracks the upstream
-   memo, so emit fires whenever finalIsActive / coordinate / index transitions.
-   Plain T params would be snapshotted at call time and never refreshed (GOTCHA-002). */
-export function useTooltipChartSynchronisation(
-	tooltipEventType: () => TooltipEventType | undefined,
-	trigger: () => TooltipTrigger,
-	activeCoordinate: () => Coordinate | undefined,
-	activeLabel: () => ActiveLabel,
-	activeIndex: () => TooltipIndex | undefined,
-	isTooltipActive: () => boolean,
-) {
-	const ctx = useChartStore()
-	if (ctx == null) {
-		return
-	}
-	const { store } = ctx
-	const viewBox = createMemo(() => useViewBox())
-
-	createEffect(
-		() => {
-			const syncId = selectSyncId(store)
-			if (syncId == null) {
-				return null
-			}
-			const activeDataKey = selectTooltipDataKey(store, tooltipEventType(), trigger())
-			const eventEmitterSymbol = selectEventEmitter(store)
-			const tooltipState = selectSynchronisedTooltipState(store)
-			/*
-			 * Use sourceViewBox (not active) to detect incoming synchronisation. It is set whenever
-			 * another chart sends us a sync event, even when our own tooltip stays inactive, so charts
-			 * with sparse data do not emit counter-sync events that clear the other tooltips.
-			 */
-			const isReceivingSynchronisation = tooltipState?.sourceViewBox != null
-
-			if (isReceivingSynchronisation) {
-				return null
-			}
-			if (eventEmitterSymbol == null) {
-				return null
-			}
-			const labelValue = activeLabel()
-			const idxValue = activeIndex()
-			const syncState: TooltipSyncState = {
-				active: isTooltipActive(),
-				coordinate: activeCoordinate(),
-				dataKey: activeDataKey,
-				graphicalItemId: selectActiveTooltipGraphicalItemId(store),
-				index: idxValue ?? null,
-				label: typeof labelValue === "number" ? String(labelValue) : labelValue,
-				sourceViewBox: viewBox(),
-			}
-			return { eventEmitterSymbol, syncId, syncState }
-		},
-		(sync) => {
-			if (sync != null) {
-				eventCenter.emit(TOOLTIP_SYNC_EVENT, sync.syncId, sync.syncState, sync.eventEmitterSymbol)
-			}
-		},
-	)
-}
-
-export function useBrushChartSynchronisation() {
-	const ctx = useChartStore()
-	if (ctx == null) {
-		return
-	}
-	const { store } = ctx
-
-	createEffect(
-		() => {
-			const syncId = selectSyncId(store)
-			const eventEmitterSymbol = selectEventEmitter(store)
-			const brushStartIndex = store.chartData.dataStartIndex
-			const brushEndIndex = store.chartData.dataEndIndex
-
-			if (
-				syncId == null ||
-				brushStartIndex == null ||
-				brushEndIndex == null ||
-				eventEmitterSymbol == null
-			) {
-				return null
-			}
-			const syncAction: BrushStartEndIndex = { endIndex: brushEndIndex, startIndex: brushStartIndex }
-			return { eventEmitterSymbol, syncAction, syncId }
-		},
-		(sync) => {
-			if (sync != null) {
-				eventCenter.emit(BRUSH_SYNC_EVENT, sync.syncId, sync.syncAction, sync.eventEmitterSymbol)
-			}
-		},
-	)
-}

package/src/theme/RechartsTheme.ts

@@ -1,16 +0,0 @@
-/**
- * Styling presets for Recharts components.
- * The theme can be used to customize the appearance of charts, including colors, fonts, and other visual properties.
- *
- * @experimental
- */
-export interface RechartsTheme {
-	grid: Partial<{
-		stroke: string
-		strokeOpacity: number
-		strokeWidth: number
-		strokeDasharray: string | number | ReadonlyArray<number>
-		fillOpacity: number
-		fill: string
-	}>
-}

package/src/theme/RechartsThemeContext.ts

@@ -1,19 +0,0 @@
-import { createContext, useContext } from "solid-js"
-import type { RechartsTheme } from "./RechartsTheme"
-import { legacyTheme } from "./legacyTheme"
-
-const RechartsThemeContext = createContext<RechartsTheme>(legacyTheme)
-
-/**
- * Applies the provided theme to all charts in the children tree.
- *
- * @experimental
- */
-export const RechartsThemeProvider = RechartsThemeContext
-
-/**
- * Reads the currently active theme in the children tree.
- *
- * @experimental
- */
-export const useRechartsTheme = (): RechartsTheme => useContext(RechartsThemeContext)

package/src/theme/darkTheme.ts

@@ -1,13 +0,0 @@
-import type { RechartsTheme } from "./RechartsTheme"
-
-/**
- * Dark mode theme
- *
- * @experimental
- */
-export const darkTheme: RechartsTheme = {
-	grid: {
-		stroke: "#3f3f46",
-		fill: "none",
-	},
-}

package/src/theme/graphicalItemIdentity.ts

@@ -1,70 +0,0 @@
-/**
- * @fileOverview
- * This file provides helper methods for assigning theme identity to a
- * graphical item. Graphical items are individual drawable data representations,
- * such as Line or Bar. In previous Recharts versions these can be styled
- * individually. In next version, Recharts will allow the user to provide an
- * array of themes, and then have the graphical items pick one. There is a gap
- * however; graphical items are not sorted and not indexed. We can"t use DOM
- * order because that order changes. So instead we need an identifier that:
- * - we can calculate from props, without requiring the user to provide an
- *   explicit id
- * - is stable across renders, so that the same item will always get the same
- *   theme
- * - is (within possibilities) unique across all items, so that no two items
- *   will get the same theme The uniqueness is impossible to guarantee 100% so
- * we will only provide a best-effort. This file provides a helper method to
- * calculate such an identifier.
- */
-
-import type { DataKey } from "../util/types"
-
-export type ThemableItem = {
-	dataKey: DataKey<unknown>
-}
-
-/**
- * Computes a deterministic numeric hash for the given string. Uses djb2 hash
- * algorithm with additional bit-mixing to improve distribution across small
- * moduli (e.g., themeCount = 5).
- */
-function computeHash(str: string): number {
-	let hash = 5381
-	for (let i = 0; i < str.length; i++) {
-		hash = (hash << 5) + hash + str.charCodeAt(i); // hash * 33 + charCode
-	}
-
-	// Bit-mixing step: multiply by a large prime, then XOR-shift to spread
-	// bit patterns. This prevents collisions that can occur with raw %
-	// themeCount when the raw hash"s low bits correlate poorly across inputs.
-	hash ^= hash >>> 16
-	hash *= 0x85ebca6b
-	hash ^= hash >>> 16
-
-	return hash & 0x7fffffff; // Mask to ensure non-negative 31-bit integer
-}
-
-/**
- * Calculates theme index from a given item. The identity is computed
- * deterministically from the dataKey string, ensuring stability across renders
- * and module reloads.
- * @param item - The themable item to calculate identity for
- * @param themeCount - Optional number of available themes; if provided, clamps
- *  the hash to [0, themeCount).
- */
-export function graphicalItemIdentity(item: ThemableItem, themeCount?: number): number {
-	// Negative or zero themeCount is semantically invalid (can"t have negative themes,
-	// and zero themes means none available)
-	if (themeCount != null && themeCount <= 0) {
-		return 0
-	}
-
-	const keyString = String(item.dataKey)
-	const hashResult = computeHash(keyString)
-
-	if (themeCount != null && themeCount > 0) {
-		return hashResult % themeCount
-	}
-
-	return hashResult
-}

package/src/theme/legacyTheme.ts

@@ -1,17 +0,0 @@
-import type { RechartsTheme } from "./RechartsTheme"
-
-/**
- * This is the theme as was the default in 2.x and 3.x branches.
- *
- * It"s not very consistent, colors are all over the place and overall exists only for backwards compatibility.
- * Prefer to use either {@link lightTheme} or {@link darkTheme} instead.
- *
- * @deprecated
- * @experimental
- */
-export const legacyTheme: RechartsTheme = {
-	grid: {
-		stroke: "#ccc",
-		fill: "none",
-	},
-}