stream-charts 1.2.0 → 2.0.0

package/src/app/charts/hooks/useDataSource.tsx

@@ -0,0 +1,106 @@
+import {createContext, useCallback, useContext, useSyncExternalStore} from "react";
+import type {ChartData} from "../observables/ChartData";
+import type {BaseSeries} from "../series/baseSeries";
+import type {StreamingDataSource} from "../datasources/StreamingDataSource";
+
+/**
+ * The chart's data: its data source, the series the source held when it was handed to the chart,
+ * and the chart's streaming settings and callbacks
+ * @template CD The type of the chart data
+ * @template D The type of datum held in each series
+ * @template S The type of series
+ */
+export interface ChartDataValues<CD extends ChartData, D, S extends BaseSeries<D> = BaseSeries<D>> {
+    /**
+     * The data source handed to the chart (its `dataSource` prop)
+     */
+    dataSource: StreamingDataSource<CD, D, S>
+    /**
+     * The series the data source held when it was handed to the chart (a new data source means
+     * new initial data, so plots keyed on it reset)
+     */
+    initialData: Array<S>
+    /**
+     * The time (ms) over which incoming data is batched before the plot redraws
+     */
+    windowingTime: number
+    /**
+     * The period (ms) at which the data source's generator emits new data, when known. When
+     * provided, batching switches from wall-clock-based to a fixed tick count derived from
+     * `windowingTime / dataUpdatePeriod` (see the view drivers in `subscriptions/viewDrivers.ts`).
+     */
+    dataUpdatePeriod?: number
+    /**
+     * Called when the chart time is updated (e.g. by plots whose axes aren't time)
+     * @param time The new chart time
+     */
+    onUpdateChartTime: (time: number) => void
+}
+
+// the context is generic over the same type parameters as `ChartDataValues`, but a context object
+// can't itself carry unbound generics -- the hooks below cast it back to the caller's concrete
+// types, which is safe because `<Chart/>` is what actually supplies the value
+export const ChartDataContext = createContext<unknown>(undefined)
+
+/**
+ * @return The chart's data, and its streaming settings
+ * @throws Error when used outside a `<Chart>`
+ */
+function useChartData<CD extends ChartData, D, S extends BaseSeries<D>>(): ChartDataValues<CD, D, S> {
+    const context = useContext(ChartDataContext)
+    if (context === undefined) {
+        throw new Error("The chart's data can only be used within a <Chart/>")
+    }
+    return context as ChartDataValues<CD, D, S>
+}
+
+/**
+ * @return The {@link StreamingDataSource} handed to the enclosing {@link Chart} through its
+ * `dataSource` prop (`undefined` only outside of a chart)
+ * @template CD The type of the chart data
+ * @template D The type of datum held in each series
+ * @template S The type of series
+ */
+export function useDataSource<CD extends ChartData, D, S extends BaseSeries<D> = BaseSeries<D>>(): StreamingDataSource<CD, D, S> | undefined {
+    return (useContext(ChartDataContext) as ChartDataValues<CD, D, S> | undefined)?.dataSource
+}
+
+/**
+ * @return The series the chart's data source held when it was handed to the chart (for
+ * components that need the set of series up front, e.g. the legend, or a plot resetting itself
+ * for new data)
+ * @throws Error when used outside a `<Chart>`
+ * @template D The type of the datum held in each series
+ */
+export function useInitialData<D>(): {initialData: Array<BaseSeries<D>>} {
+    const {initialData} = useChartData<ChartData, D, BaseSeries<D>>()
+    return {initialData}
+}
+
+/**
+ * @return The chart's streaming settings (how updates are batched for rendering) and callbacks
+ * @throws Error when used outside a `<Chart>`
+ */
+export function useStreamingSettings(): Pick<ChartDataValues<ChartData, unknown>, 'windowingTime' | 'dataUpdatePeriod' | 'onUpdateChartTime'> {
+    const {windowingTime, dataUpdatePeriod, onUpdateChartTime} = useChartData<ChartData, unknown, BaseSeries<unknown>>()
+    return {windowingTime, dataUpdatePeriod, onUpdateChartTime}
+}
+
+/**
+ * Subscribes the calling component to the data source's running state, so it re-renders when the
+ * source starts or stops (e.g. to switch the zoom pivot, or hide markers while running).
+ * @param dataSource The data source, or `undefined` (in which case this is always `false`)
+ * @return Whether the data source is currently running
+ */
+export function useDataSourceRunning<CD extends ChartData, D>(dataSource: StreamingDataSource<CD, D> | undefined): boolean {
+    const subscribe = useCallback(
+        (onChange: () => void): (() => void) => {
+            if (dataSource === undefined) return () => {
+            }
+            const subscription = dataSource.isRunningObservable.subscribe(() => onChange())
+            return () => subscription.unsubscribe()
+        },
+        [dataSource]
+    )
+    return useSyncExternalStore(subscribe, () => dataSource?.running ?? false)
+}

package/src/app/charts/hooks/useHoveredSeries.tsx

@@ -0,0 +1,33 @@
+import {createContext, type Dispatch, type SetStateAction, useContext} from "react";
+
+/**
+ * The series the mouse is over (in a plot, or in the legend), which the plots and the legend
+ * highlight
+ */
+export interface HoveredSeriesValues {
+    /**
+     * The name of the hovered series, or `null` when no series is hovered
+     */
+    hoveredSeriesName: string | null
+    /**
+     * Sets (or, with `null`, clears) the hovered series -- e.g. when the mouse is over the series'
+     * entry in the legend. (A plot's own mouse-over and mouse-leave set it, through the chart's
+     * mouse handlers -- see `useMouse`.)
+     */
+    setHoveredSeriesName: Dispatch<SetStateAction<string | null>>
+}
+
+export const HoveredSeriesContext = createContext<HoveredSeriesValues>({
+    hoveredSeriesName: null,
+    setHoveredSeriesName: () => {
+    },
+})
+
+/**
+ * React hook for the series the mouse is over. Kept apart from {@link useChart}, so that only the
+ * components that show the hover (the plots and the legend) re-render when it changes.
+ * @return The hovered series' name, and its setter
+ */
+export function useHoveredSeries(): HoveredSeriesValues {
+    return useContext(HoveredSeriesContext)
+}

package/src/app/charts/hooks/useMouse.tsx

@@ -1,25 +1,42 @@
-import {createContext, JSX, useContext, useRef} from "react";
-import {TooltipData} from "./useTooltip";
+import {createContext, useContext} from "react";
+import type {TooltipData} from "./useTooltip";
 
 /**
- * No operation function for use when a default function is needed
+ * Called when the mouse moves over a series (e.g. to show the tooltip)
+ * @param seriesName The name of the series under the mouse
+ * @param time The time (x-value) under the mouse
+ * @param tooltipData The data for the tooltip (the series, and the plot's metadata about it)
+ * @param mouseCoords The mouse coordinates
+ * @param [providerId] The ID of the tooltip content provider to use (e.g. for a plot whose
+ * elements have different tooltips)
  */
-const noop = () => {
-    /* empty on purpose */
-}
+export type TooltipMouseOverHandlerFn<D, TM> = (
+    seriesName: string,
+    time: number,
+    tooltipData: TooltipData<D, TM>,
+    mouseCoords: [x: number, y: number],
+    providerId?: string
+) => void
+
+/**
+ * Called when the mouse leaves a series (e.g. to hide the tooltip)
+ * @param seriesName The name of the series the mouse left
+ */
+export type TooltipMouseLeaveHandlerFn = (seriesName: string) => void
 
 /**
- * Type representing the values exposed through the {@link useMouse} react hook.
+ * Type representing the values exposed through the `useMouse` react hook.
  * @template D The type of the data object for the series
  * @template TM The type of the metadata object for the series
  */
 export type UseMouseValues<D, TM> = {
     /**
-     * Adds a mouse-over-series handler with the specified ID and handler function
+     * Adds a mouse-over-series handler with the specified ID and handler function (replacing any
+     * handler already registered with that ID)
      * @param handlerId The handler ID
      * @param handler The handler function called when a mouse-over-series event occurs.
-     * The handler function is handed the series name, the time (x-value), the actual
-     * series, and the mouse coordinates over which the mouse has moved over.
+     * The handler function is handed the series name, the time (x-value), the tooltip data (the
+     * series and its metadata), and the mouse coordinates.
      * @return The handler ID.
      */
     registerMouseOverHandler: (
@@ -32,97 +49,56 @@ export type UseMouseValues<D, TM> = {
      */
     unregisterMouseOverHandler: (handlerId: string) => void
     /**
-     * Attempts to retrieve the mouse-over-series handler for the specified ID
-     * @param handlerId The ID of the handler
-     * @return The mouse-over-series handler for the ID, or `undefined` if not found
+     * Retrieves the mouse-over-series handler a plot calls when the mouse is over one of its
+     * series: it sets the hovered series (see {@link useHoveredSeries}), and calls *every*
+     * registered mouse-over-series handler, handing each the specified provider ID. (The
+     * `handlerId` is accepted, but unused.)
+     * @param handlerId The ID of the handler (unused)
+     * @param [providerId] The ID of the tooltip content provider handed to the handlers
+     * @return The mouse-over-series handler
      */
-    mouseOverHandlerFor: (handlerId: string, providerId?: string) =>
-        ((seriesName: string, time: number, tooltipData: TooltipData<D, TM>, mouseCoords: [x: number, y: number], providerId?: string) => void) | undefined
+    mouseOverHandlerFor: (handlerId: string, providerId?: string) => TooltipMouseOverHandlerFn<D, TM>
     /**
-     * Adds a mouse-leave-series handler with the specified ID and handler function
+     * Adds a mouse-leave-series handler with the specified ID and handler function (replacing any
+     * handler already registered with that ID)
      * @param handlerId The handler ID
      * @param handler The handler function called when a mouse-leave-series event occurs
      * @return The handler ID
      */
-    registerMouseLeaveHandler: (handlerId: string, handler: (seriesName: string) => void) => string
+    registerMouseLeaveHandler: (handlerId: string, handler: TooltipMouseLeaveHandlerFn) => string
     /**
      * Removes the mouse-leave-series handler with the specified ID
      * @param handlerId The ID of the handler to remove
      */
     unregisterMouseLeaveHandler: (handlerId: string) => void
     /**
-     * Attempts to retrieve the mouse-leave-series handler for the specified ID
-     * @param handlerId The ID of the handler
-     * @return The mouse-leave-series handler for the ID, or `undefined` if not found
+     * Retrieves the mouse-leave-series handler a plot calls when the mouse leaves one of its
+     * series: it clears the hovered series, and calls *every* registered mouse-leave-series
+     * handler, handing each the specified provider ID. (The `handlerId` is accepted, but unused.)
+     * @param handlerId The ID of the handler (unused)
+     * @param [providerId] The ID of the tooltip content provider handed to the handlers
+     * @return The mouse-leave-series handler
      */
-    mouseLeaveHandlerFor: (handlerId: string, providerId?: string) => ((seriesName: string, providerId?: string) => void) | undefined
-}
-
-export const defaultMouseValues = (): UseMouseValues<any, any> => ({
-    registerMouseOverHandler: () => '',
-    unregisterMouseOverHandler: noop,
-    mouseOverHandlerFor: () => undefined,
-    registerMouseLeaveHandler: () => '',
-    unregisterMouseLeaveHandler: noop,
-    mouseLeaveHandlerFor: () => undefined,
-})
-
-const MouseContext = createContext<UseMouseValues<any, any>>(defaultMouseValues())
-
-export type Props = {
-    children: JSX.Element | Array<JSX.Element>
+    mouseLeaveHandlerFor: (handlerId: string, providerId?: string) => ((seriesName: string, providerId?: string) => void)
 }
 
-export default function MouseProvider<D, TM>(props: Props): JSX.Element {
-    const {children} = props
-
-    const mouseOverHandlersRef = useRef<Map<string, (seriesName: string, time: number, tooltipData: TooltipData<D, TM>, mouseCoords: [x: number, y: number], providerId?: string) => void>>(new Map())
-    const mouseLeaveHandlersRef = useRef<Map<string, (seriesName: string, providerId?: string) => void>>(new Map())
-
-    return <MouseContext.Provider
-        value={{
-            registerMouseOverHandler: (handlerId, handler) => {
-                mouseOverHandlersRef.current.set(handlerId, handler)
-                return handlerId
-            },
-            unregisterMouseOverHandler: handlerId => mouseOverHandlersRef.current.delete(handlerId),
-            mouseOverHandlerFor: (handlerId, providerId) => {
-                if (mouseOverHandlersRef.current.size === 0) return undefined
-                return (seriesName: string, time: number, tooltipData: TooltipData<D, TM>, mouseCoords: [x: number, y: number]) => {
-                    mouseOverHandlersRef.current.forEach(handler => {
-                        handler(seriesName, time, tooltipData, mouseCoords, providerId)
-                    })
-                }
-            },
-
-            registerMouseLeaveHandler: (handlerId, handler) => {
-                mouseLeaveHandlersRef.current.set(handlerId, handler)
-                return handlerId
-            },
-            unregisterMouseLeaveHandler: handlerId => mouseLeaveHandlersRef.current.delete(handlerId),
-            mouseLeaveHandlerFor: (handlerId, providerId) => {
-                if (mouseLeaveHandlersRef.current.size === 0) return undefined
-                return (seriesName: string) => {
-                    mouseLeaveHandlersRef.current.forEach(handler => {
-                        handler(seriesName, providerId)
-                    })
-                }
-            },
-        }}
-    >
-        {children}
-    </MouseContext.Provider>
-}
+// the context is generic over the same type parameters as `UseMouseValues`, but a context
+// object can't itself carry unbound generics -- `useMouse` below casts it back to the caller's
+// concrete types, which is safe because `<InteractionProvider/>` is what actually supplies the value
+export const MouseContext = createContext<unknown>(undefined)
 
 /**
- * React hook that sets up the React context for the mouse values.
+ * React hook for registering, and retrieving, the chart's mouse-over-series and
+ * mouse-leave-series handlers. Must be used within a `<Chart>`.
  * @return The {@link UseMouseValues} held in the React context.
+ * @throws Error when used outside a `<Chart>`
+ * @template D The type of the data object for the series
+ * @template TM The type of the metadata object for the series
  */
 export function useMouse<D, TM>(): UseMouseValues<D, TM> {
-    const context = useContext<UseMouseValues<D, TM>>(MouseContext)
-    const {mouseOverHandlerFor} = context
-    if (mouseOverHandlerFor === undefined || mouseOverHandlerFor === null) {
-        throw new Error("useMouse can only be used when the parent is a <MouseProvider/>")
+    const context = useContext(MouseContext)
+    if (context === undefined) {
+        throw new Error("useMouse can only be used within a <Chart/>")
     }
-    return context
+    return context as UseMouseValues<D, TM>
 }

package/src/app/charts/hooks/usePlotDimensions.tsx

@@ -1,24 +1,23 @@
-import {Dimensions, dimensionsNotEqual, Margin, plotDimensionsFrom} from "../styling/margins";
-import {createContext, JSX, useContext, useEffect, useRef, useState} from "react";
+import {type Dimensions, type Margin} from "../styling/margins";
+import {createContext, useContext} from "react";
 
 /**
- * No operation function for use when a default function is needed
+ * Called when the plot's dimensions change
+ * @param previousDimensions The plot's dimensions before the change
+ * @param newDimensions The plot's new dimensions
  */
-const noop = () => {
-    /* empty on purpose */
-}
-
-export const defaultMargin: Margin = {top: 30, right: 20, bottom: 30, left: 50}
-
 export type PlotDimensionChangeHandler = (previousDimensions: Dimensions, newDimensions: Dimensions) => void
 
+/**
+ * The values exposed through the {@link usePlotDimensions} react hook
+ */
 export type UsePlotDimensionsValues = {
     /**
-     * The width and height (in pixels) of this chart
+     * The width and height (in pixels) of the plot area (the chart without its margins)
      */
     plotDimensions: Dimensions
     /**
-     * The plot margins for the border of main G
+     * The margins between the edges of the chart and the plot area (where the axes are drawn)
      */
     margin: Margin
     /**
@@ -26,93 +25,30 @@ export type UsePlotDimensionsValues = {
      * @param dimensions the new dimensions of the plot
      */
     updateDimensions: (dimensions: Dimensions) => void
+    /**
+     * Registers a handler that's called whenever the plot dimensions change
+     * @param handler The handler
+     * @return The handler's ID (for unregistering it)
+     */
     registerPlotDimensionChangeHandler: (handler: PlotDimensionChangeHandler) => string
+    /**
+     * Unregisters the plot-dimension change handler with the specified ID
+     * @param handlerId The handler's ID (from {@link registerPlotDimensionChangeHandler})
+     */
     unregisterPlotDimensionChangeHandler: (handlerId: string) => void
 }
 
-export const defaultPlotDimensions = (): UsePlotDimensionsValues => ({
-    plotDimensions: {width: 0, height: 0},
-    margin: defaultMargin,
-    updateDimensions: noop,
-    registerPlotDimensionChangeHandler: () => "",
-    unregisterPlotDimensionChangeHandler: noop
-})
-
-const PlotDimensionsContext = createContext<UsePlotDimensionsValues>(defaultPlotDimensions())
-
-export type Props = {
-    containerDimensions: Dimensions
-    margin: Margin
-    children: JSX.Element | Array<JSX.Element>
-}
-
-export default function PlotDimensionsProvider(props: Props): JSX.Element {
-    const {
-        containerDimensions,
-        margin,
-        children
-    } = props
-
-    const [dimensions, setDimensions] = useState<Dimensions>(defaultPlotDimensions().plotDimensions)
-    const plotDimensionChangeHandersRef = useRef<Map<string, PlotDimensionChangeHandler>>(new Map())
-
-    // update the plot dimensions when the container size or margin change
-    useEffect(
-        () => {
-            const newDimensions = plotDimensionsFrom(containerDimensions.width, containerDimensions.height, margin)
-            setDimensions(prevDimensions => {
-                if (dimensionsNotEqual(prevDimensions, newDimensions)) {
-                    for(const handler of plotDimensionChangeHandersRef.current.values()) {
-                        handler(prevDimensions, newDimensions)
-                    }
-                    return newDimensions
-                }
-                return prevDimensions
-            })
-        },
-        [containerDimensions, margin]
-    )
-
-    function updateDimensions(newDimensions: Dimensions) {
-        setDimensions(prevState => {
-            for(const handler of plotDimensionChangeHandersRef.current.values()) {
-                handler(prevState, newDimensions)
-            }
-            return newDimensions
-        })
-    }
-
-    function registerPlotDimensionChangeHandler(handler: PlotDimensionChangeHandler) {
-        const handlerId = crypto.randomUUID()
-        plotDimensionChangeHandersRef.current.set(handlerId, handler)
-        return handlerId
-    }
-
-    function unregisterPlotDimensionChangeHandler(handlerId: string): boolean {
-        return plotDimensionChangeHandersRef.current.delete(handlerId)
-    }
-
-    return <PlotDimensionsContext.Provider
-        value={{
-            plotDimensions: dimensions,
-            margin,
-            updateDimensions,
-            registerPlotDimensionChangeHandler,
-            unregisterPlotDimensionChangeHandler
-        }}
-    >
-        {children}
-    </PlotDimensionsContext.Provider>
-}
+export const PlotDimensionsContext = createContext<UsePlotDimensionsValues | undefined>(undefined)
 
 /**
- * React hook that sets up the React context for the plot-dimension values.
+ * React hook for the plot's dimensions and margins. Must be used within a
+ * `PlotDimensionsProvider` (i.e. within a `<Chart>`).
  * @return The {@link UsePlotDimensionsValues} held in the React context.
+ * @throws Error when used outside a `<PlotDimensionsProvider>`
  */
 export function usePlotDimensions(): UsePlotDimensionsValues {
-    const context = useContext<UsePlotDimensionsValues>(PlotDimensionsContext)
-    const {plotDimensions} = context
-    if (plotDimensions === undefined || plotDimensions === null) {
+    const context = useContext(PlotDimensionsContext)
+    if (context === undefined) {
         throw new Error("usePlotDimensions can only be used when the parent is a <PlotDimensionsProvider/>")
     }
     return context

package/src/app/charts/hooks/useTooltip.tsx

@@ -1,13 +1,5 @@
-import {Series} from "../plots/plot";
-import {TooltipDimensions} from "../tooltips/tooltipUtils";
-import {createContext, JSX, useContext, useRef} from "react";
-
-/**
- * No operation function for use when a default function is needed
- */
-const noop = () => {
-    /* empty on purpose */
-}
+import type {Series} from "../plots/plot";
+import {createContext, useContext} from "react";
 
 /**
  * Base interface for tooltip data that is passed through to the tooltip content provider
@@ -20,20 +12,23 @@ export interface TooltipData<D, M> {
 }
 
 /**
- * A higher-order function that returns a function that provides the tooltip content or
- * `undefined` if no tooltip content is available.
- * @return The tooltip content, or `undefined` if no tooltip content is available.
+ * A function that provides (shows) the tooltip content for the element under the mouse (see
+ * {@link TooltipContent}, which registers one)
  * @param seriesName The name of the series for which the tooltip content is being provided
  * @param time The time (x-value) for which the tooltip content is being provided
  * @param tooltipData The tooltip data
  * @param mouseCoords The mouse coordinates over which the mouse is hovering
  * @param providerId An optional ID of the tooltip content provider.
+ * @template D The type of the data object for the series
+ * @template M The type of the metadata object for the series
  */
 export type TooltipContentProvider<D, M> =
-    (seriesName: string, time: number, tooltipData: TooltipData<D, M>, mouseCoords: [x: number, y: number], providerId?: string) => TooltipDimensions
+    (seriesName: string, time: number, tooltipData: TooltipData<D, M>, mouseCoords: [x: number, y: number], providerId?: string) => void
 
 /**
- * The functions and values exposed through the {@link useTooltip} react hook
+ * The functions and values exposed through the `useTooltip` react hook
+ * @template D The type of the data object for the series
+ * @template M The type of the metadata object for the series
  */
 export type UseTooltipValues<D, M> = {
     /**
@@ -50,62 +45,36 @@ export type UseTooltipValues<D, M> = {
      */
     tooltipContentProvider: () => (TooltipContentProvider<D, M> | undefined)
 
+    /**
+     * Callback that sets the visibility state of the tooltip. This is used to control whether the tooltip is
+     * visible or not.
+     * @param visible Whether the tooltip should be visible or not.
+     */
     setVisibilityState: (visible: boolean) => void
-    visibilityState: boolean
-}
-
-/**
- * The default values for the {@link UseTooltipValues}
- */
-export const defaultTooltipValues = (): UseTooltipValues<any, any> => ({
-    registerTooltipContentProvider: noop,
-    tooltipContentProvider: () => undefined,
-    setVisibilityState: noop,
-    visibilityState: false,
-})
 
-const TooltipContext = createContext<UseTooltipValues<any, any>>(defaultTooltipValues())
-
-export type Props = {
-    children: JSX.Element | Array<JSX.Element>
+    /**
+     * @return Whether the tooltip is currently visible or not.
+     */
+    visibilityState: boolean
 }
 
-/**
- * The tooltip context provider allows registering and retrieving tooltip content providers. When
- * a tooltip content provider is registered with a provider ID, then it must be retrieved with that
- * same provider ID. This allows a chart to have multiple tooltip content providers, depending on
- * the context or types of objects being moused over. When a tooltip content provider is registered
- * without a provider ID, then the default provider ID is used.
- * @param props The properties holding the children
- * @return A JSX element containing the children
- */
-export default function TooltipProvider<D, M>(props: Props): JSX.Element {
-    const {children} = props
-
-    const tooltipContentProviderRef = useRef<TooltipContentProvider<D, M>>(undefined)
-    const visibilityStateRef = useRef<boolean>(false)
-
-    return <TooltipContext.Provider
-        value={{
-            registerTooltipContentProvider: provider => tooltipContentProviderRef.current = provider,
-            tooltipContentProvider: () => tooltipContentProviderRef.current,
-            setVisibilityState: (visible: boolean) => visibilityStateRef.current = visible,
-            visibilityState: visibilityStateRef.current
-        }}
-    >
-        {children}
-    </TooltipContext.Provider>
-}
+// the context is generic over the same type parameters as `UseTooltipValues`, but a context
+// object can't itself carry unbound generics -- `useTooltip` below casts it back to the caller's
+// concrete types, which is safe because `<InteractionProvider/>` is what actually supplies the value
+export const TooltipContext = createContext<unknown>(undefined)
 
 /**
- * React hook that sets up the React context for the mouse values.
+ * React hook for registering, and retrieving, the chart's tooltip content provider, and for the
+ * tooltip's visibility. Must be used within a `<Chart>`.
  * @return The {@link UseTooltipValues} held in the React context.
+ * @throws Error when used outside a `<Chart>`
+ * @template D The type of the data object for the series
+ * @template M The type of the metadata object for the series
  */
 export function useTooltip<D, M>(): UseTooltipValues<D, M> {
-    const context = useContext<UseTooltipValues<D, M>>(TooltipContext)
-    const {registerTooltipContentProvider} = context
-    if (registerTooltipContentProvider === undefined || registerTooltipContentProvider === null) {
-        throw new Error("useTooltip can only be used when the parent is a <TooltipProvider/>")
+    const context = useContext(TooltipContext)
+    if (context === undefined) {
+        throw new Error("useTooltip can only be used within a <Chart/>")
     }
-    return context
+    return context as UseTooltipValues<D, M>
 }