stream-charts 1.2.1 → 2.0.0

package/src/app/charts/subscriptions/subscriptions.ts

@@ -1,635 +0,0 @@
-import {bufferTime, map, mergeAll, mergeWith} from "rxjs/operators";
-import {continuousAxisRanges, ContinuousNumericAxis, ordinalAxisRanges, OrdinalStringAxis} from "../axes/axes";
-import {Datum, TimeSeries} from "../series/timeSeries";
-import {interval, Observable, Subscription} from "rxjs";
-import {TimeSeriesChartData} from "../series/timeSeriesChartData";
-import {AxesAssignment} from "../plots/plot";
-import {AxesState} from "../axes/AxesState";
-import {BaseSeries, emptySeries} from "../series/baseSeries";
-import {IterateChartData} from "../observables/iterates";
-import {IterateDatum, IterateSeries} from "../series/iterateSeries";
-import {
-    copyOrdinalDatumExtremum,
-    copyOrdinalValueStats,
-    copyValueStatsForSeries,
-    defaultOrdinalValueStats,
-    initialMaxValueDatum,
-    initialMinValueDatum,
-    OrdinalChartData,
-    OrdinalStats,
-    OrdinalValueStats
-} from "../observables/ordinals";
-import {ChartData} from "../observables/ChartData";
-import {OrdinalDatum} from "../series/ordinalSeries";
-import {RefObject} from "react";
-import {AxisInterval} from "../axes/AxisInterval";
-import {Optional} from "result-fn";
-import {OrdinalAxisRange} from "../axes/OrdinalAxisRange";
-import {ContinuousAxisRange} from "../axes/ContinuousAxisRange";
-
-export enum TimeWindowBehavior { SCROLL, SQUEEZE }
-
-/**
- * Creates a subscription to the series observable with the data stream. This is common code
- * shared by the plots.
- * @param seriesObservable The series observable holding the stream of chart data
- * @param onSubscribe Callback for when the observable is subscribed to
- * @param windowingTime Basically the update time when data is collected and then rendered
- * @param axisAssignments The assignment of the series to their x- and y-axes
- * @param xAxesState The current state of the x-axis
- * @param onUpdateData Callback for when data is updated
- * @param dropDataAfter Limits the amount of data stored. Any data older than this value (ms) will
- * be dropped on the next update
- * @param updateTimingAndPlot The callback function to update the plot and timing
- * @param seriesMap The series-name and the associated series
- * @param setCurrentTime Callback to update the current time based on the streamed data
- * @param timeWindowBehavior Whether to scroll the time axis or squeeze it
- * @param initialTimes The initial times for each axis, a map(axis_id -> initial_time)
- * @return A subscription to the observable (for cancelling and the likes)
- */
-export function subscriptionTimeSeriesFor(
-    seriesObservable: Observable<TimeSeriesChartData>,
-    onSubscribe: (subscription: Subscription) => void,
-    windowingTime: number,
-    axisAssignments: Map<string, AxesAssignment>,
-    xAxesState: AxesState<ContinuousNumericAxis>,
-    onUpdateData: ((seriesName: string, data: Array<Datum>) => void) | undefined,
-    dropDataAfter: number,
-    updateTimingAndPlot: (ranges: Map<string, ContinuousAxisRange>) => void,
-    seriesMap: Map<string, TimeSeries>,
-    setCurrentTime: (axisId: string, end: number) => void,
-    timeWindowBehavior: TimeWindowBehavior = TimeWindowBehavior.SCROLL,
-    initialTimes: Map<string, number> = new Map<string, number>(),
-): Subscription {
-    const subscription = seriesObservable
-        .pipe(bufferTime(windowingTime))
-        .subscribe(dataList => {
-            dataList.forEach(data => {
-                // grab the time-windows for the x-axes
-                const timesWindows = continuousAxisRanges(xAxesState.axes as Map<string, ContinuousNumericAxis>);
-
-                //
-                // calculate the max times for each x-axis, which is the max time over all the
-                // series assigned to an x-axis
-
-                // get the series associated with each axis (Map<axis_id, [series_names]>)
-                const axesSeries = associatedSeriesForXAxes(data, axisAssignments, xAxesState)
-
-                // add each new point to it's corresponding series, the new points
-                // is a map(series_name -> new_point[])
-                data.newPoints.forEach((newData, name) => {
-                    // grab the current series associated with the new data
-                    const series = seriesMap.get(name) || emptySeries(name)
-
-                    // update the handler with the new data point
-                    if (onUpdateData) onUpdateData(name, newData)
-
-                    // add the new data to the series
-                    series.data.push(...newData)
-
-                    // calculate the current time for the series' assigned x-axis (which may end up
-                    // just being the default) based on the max time for the series, and the overall
-                    // max time
-                    const axisId = axisAssignments.get(name)?.xAxis || xAxesState.axisDefaultId().getOrElse("");
-                    const currentAxisTime = axesSeries.get(axisId)
-                        ?.reduce(
-                            (tMax, seriesName) => Math.max(data.maxTimes.get(seriesName) || data.maxTime, tMax),
-                            -Infinity
-                        ) || data.maxTime
-
-                    if (currentAxisTime !== undefined) {
-                        // drop data that is older than the max time-window
-                        while (currentAxisTime - series.data[0].time > dropDataAfter) {
-                            series.data.shift()
-                        }
-
-                        // update the time range for the x-axis, and if the time range
-                        // needs to be updated, then recalculate the time range for the
-                        // axis, update the time windows, and call the setCurrentTime
-                        // callback to update the current time for the caller
-                        const range = timesWindows.get(axisId)
-                        const [startTime, endTime] = Optional.ofNullable(range?.current)
-                            .map(interval => interval.asTuple())
-                            .getOrElse([0, 0])
-                        if (range !== undefined && endTime < currentAxisTime) {
-                            const timeWindow = endTime - startTime
-                            const timeRange = ContinuousAxisRange.from(
-                                // 0,
-                                timeWindowBehavior === TimeWindowBehavior.SQUEEZE && initialTimes.get(axisId) !== undefined ?
-                                    initialTimes.get(axisId)! :
-                                    Math.max(0, currentAxisTime - timeWindow),
-                                Math.max(currentAxisTime, timeWindow)
-                            )
-                            timesWindows.set(axisId, timeRange)
-                            setCurrentTime(axisId, endTime) // callback
-                        }
-                    }
-                })
-
-                // update the data
-                updateTimingAndPlot(timesWindows)  // callback
-            })
-        })
-
-    // provide the subscription to the caller
-    onSubscribe(subscription)   // callback
-
-    return subscription
-}
-
-/**
- * **Function has side effects on the Series (for performance).**
- *
- * Creates a subscription to the series observable with the data stream. The common code is
- * shared by the plots.
- * @param seriesObservable The series observable holding the stream of chart data
- * @param onSubscribe Callback for when the observable is subscribed to
- * @param windowingTime Basically the update time when data is collected and then rendered
- * @param axisAssignments The assignment of the series to their x- and y-axes
- * @param xAxesState The current state of the x-axis
- * @param onUpdateData Callback for when data is updated
- * @param dropDataAfter Limits the amount of data stored. Any data older than this value (ms) will
- * be dropped on the next update
- * @param updateTimingAndPlot The callback function to update the plot and timing
- * @param seriesMap The series-name and the associated series
- * @param setCurrentTime Callback to update the current time based on the streamed data
- * @param cadencePeriod The number of milliseconds between time updates
- * @return A subscription to the observable (for cancelling and the likes)
- */
-export function subscriptionTimeSeriesWithCadenceFor(
-    seriesObservable: Observable<TimeSeriesChartData>,
-    onSubscribe: (subscription: Subscription) => void,
-    windowingTime: number,
-    axisAssignments: Map<string, AxesAssignment>,
-    xAxesState: AxesState<ContinuousNumericAxis>,
-    onUpdateData: ((seriesName: string, data: Array<Datum>) => void) | undefined,
-    dropDataAfter: number,
-    updateTimingAndPlot: (ranges: Map<string, ContinuousAxisRange>) => void,
-    seriesMap: Map<string, TimeSeries>,
-    setCurrentTime: (axisId: string, end: number) => void,
-    cadencePeriod: number
-): Subscription {
-    const maxTime = Array.from(seriesMap.entries())
-        .reduce(
-            (tMax, [, series]) => Math.max(tMax, series.last().map(datum => datum.time).getOrElse(tMax)),
-            -Infinity
-        )
-    const cadence = interval(cadencePeriod)
-        .pipe(
-            map(value => ({
-                currentTime: value * cadencePeriod,
-                    maxTime: value * cadencePeriod,
-                    maxTimes: new Map(),
-                    newPoints: new Map()
-                } as TimeSeriesChartData)
-            )
-        )
-
-    const subscription = seriesObservable
-        .pipe(
-            mergeWith(cadence),
-            bufferTime(windowingTime),
-            mergeAll(),
-        )
-        .subscribe(data => {
-            // grab the time-windows for the x-axes
-            const timesWindows = continuousAxisRanges(xAxesState.axes as Map<string, ContinuousNumericAxis>)
-
-            if (data.currentTime !== undefined) {
-                xAxesState.axisIds().forEach(axisId => {
-                    const range = timesWindows.get(axisId)
-                    if (range !== undefined && data.currentTime !== undefined) {
-                        const [startTime, endTime] = range.current.asTuple()
-                        const timeWindow = endTime - startTime
-                        // const timeWindow = measureOf(range.current)
-                        const timeRange = ContinuousAxisRange.from(
-                            Math.max(0, Math.max(endTime, data.currentTime + maxTime) - timeWindow),
-                            Math.max(Math.max(endTime, data.currentTime + maxTime), timeWindow)
-                        )
-                        timesWindows.set(axisId, timeRange)
-                        setCurrentTime(axisId, data.currentTime + maxTime)
-                    }
-                })
-            }
-
-            if (data.newPoints.size === 0) {
-                updateTimingAndPlot(timesWindows)
-                return
-            }
-
-            // determine which series belong to each x-axis
-            const axesSeries = associatedSeriesForXAxes(data, axisAssignments, xAxesState)
-
-            // add each new point to it's corresponding series, the new points
-            // is a map(series_name -> new_point[])
-            data.newPoints.forEach((newData, name) => {
-                // grab the current series associated with the new data
-                const series = seriesMap.get(name) || emptySeries(name);
-
-                // update the handler with the new data point
-                if (onUpdateData) onUpdateData(name, newData);
-
-                // add the new data to the series
-                series.data.push(...newData);
-
-                // drop data when specified
-                const axisId = axisAssignments.get(name)?.xAxis || xAxesState.axisDefaultId().getOrElse("")
-                const currentAxisTime = axesSeries.get(axisId)
-                    ?.reduce(
-                        (tMax, seriesName) => Math.max(data.maxTimes.get(seriesName) || data.maxTime, tMax),
-                        -Infinity
-                    ) || data.maxTime
-                if (currentAxisTime !== undefined) {
-                    // drop data that is older than the max time-window
-                    while (currentAxisTime - series.data[0].time > dropDataAfter) {
-                        series.data.shift()
-                    }
-                }
-            })
-
-            // update the data
-            updateTimingAndPlot(timesWindows)
-        })
-
-    // provide the subscription to the caller
-    onSubscribe(subscription)
-
-    return subscription
-}
-
-/**
- * Creates a subscription to the series observable with the data stream. The common code is
- * shared by the plots.
- * @param seriesObservable The series observable holding the stream of chart data
- * @param onSubscribe Callback for when the observable is subscribed to
- * @param windowingTime Basically the update time when data is collected and then rendered
- * @param xAxesState The current state of the x-axis
- * @param yAxesState The current state of the y-axis
- * @param onUpdateData Callback for when data is updated
- * @param dropDataAfter Limits the amount of data stored. Any data older than this value (ms) will
- * be dropped on the next update
- * @param updateRangesAndPlot The callback function to update the plot
- * @param seriesMap The series-name and the associated series
- * @param updateCurrentTime Callback to update the current time based on the streamed data
- * @return A subscription to the observable (for cancelling and the likes)
- */
-export function subscriptionIteratesFor(
-    seriesObservable: Observable<IterateChartData>,
-    onSubscribe: (subscription: Subscription) => void,
-    windowingTime: number,
-    xAxesState: AxesState<ContinuousNumericAxis>,
-    yAxesState: AxesState<ContinuousNumericAxis>,
-    onUpdateData: ((seriesName: string, data: Array<IterateDatum>) => void) | undefined,
-    dropDataAfter: number,
-    updateRangesAndPlot: () => void,
-    seriesMap: Map<string, IterateSeries>,
-    updateCurrentTime: (time: number) => void
-): Subscription {
-    // maintains the x and y-axis ranges based on the original domain of the axes
-    const xAxesRanges = new Map<string, ContinuousAxisRange>(Array.from(xAxesState.axes.entries())
-        .map(([id, axis]) => {
-            const [start, end] = (axis as ContinuousNumericAxis).scale.domain()
-            return [id, ContinuousAxisRange.from(start, end)]
-        }))
-    const yAxesRanges = new Map<string, ContinuousAxisRange>(Array.from(yAxesState.axes.entries())
-        .map(([id, axis]) => {
-            const [start, end] = (axis as ContinuousNumericAxis).scale.domain()
-            return [id, ContinuousAxisRange.from(start, end)]
-        }))
-
-    /**
-     * Updates the original axis range with new domain values, while maintaining the original
-     * domain values.
-     * @param originals The original axis ranges
-     * @param axes The current axes
-     */
-    function updateRange(originals: Map<string, ContinuousAxisRange>, axes: Map<string, ContinuousNumericAxis>): void {
-        axes.forEach((axis, id) => {
-            const [start, end] = axis.scale.domain()
-            const original: ContinuousAxisRange = originals.get(id) || ContinuousAxisRange.from(start, end)
-            originals.set(id, original.update(start, end))
-        })
-    }
-
-    const subscription = seriesObservable
-        .pipe(bufferTime(windowingTime))
-        .subscribe(dataList => {
-            dataList.forEach(data => {
-                // calculate the bounds for each of the x- and y-axes
-                updateRange(xAxesRanges, xAxesState.axes  as Map<string, ContinuousNumericAxis>)
-                updateRange(yAxesRanges, yAxesState.axes  as Map<string, ContinuousNumericAxis>)
-
-                // add each new point to its corresponding series, the newPoints object
-                // is a map(series_name -> new_point[])
-                data.newPoints.forEach((newData, seriesName) => {
-                    // grab the current series associated with the new data
-                    const series = seriesMap.get(seriesName) || emptySeries(seriesName)
-
-                    // update the handler with the new data points
-                    if (onUpdateData) onUpdateData(seriesName, newData)
-
-                    // add the new data to the series
-                    series.data.push(...newData)
-
-                    // calculate and update the current time, which will be that max time of the
-                    // f[n+1](x) values (y-axis)
-                    const currentTime = Array.from(data.newPoints.values())
-                        .reduce((maxTime, currentSeries) => {
-                            const seriesMaxTime = currentSeries.length > 0 ? currentSeries[currentSeries.length-1].time : 0
-                            if (seriesMaxTime > maxTime) {
-                                return seriesMaxTime
-                            }
-                            return maxTime
-                        }, 0)
-
-                    updateCurrentTime(currentTime)
-
-                    // drop data that is older than the max time-window
-                    while (currentTime - series.data[0].time > dropDataAfter) {
-                        series.data.shift()
-                    }
-
-                })
-
-                // update the data
-                const xRange = xAxesRanges.get(xAxesState.axisDefaultId().getOrElse(""))
-                const yRange = yAxesRanges.get(yAxesState.axisDefaultId().getOrElse(""))
-                if (xRange !== undefined && yRange !== undefined) {
-                    updateRangesAndPlot()
-                }
-            })
-        })
-
-    // provide the subscription to the caller
-    onSubscribe(subscription)
-
-    return subscription
-}
-
-export interface WindowedOrdinalStats extends OrdinalStats {
-    /**
-     * A map associating each series to stats about that series (e.g. map(series_name -> stats))
-     */
-    windowedValueStatsForSeries: Map<string, OrdinalValueStats>
-}
-
-/**
- * Creates a subscription to the series observable with the data stream. The common code is
- * shared by the plots.
- * @param seriesObservable The series observable holding the stream of chart data
- * @param onSubscribe Callback for when the observable is subscribed to
- * @param windowingTime Basically the update time when data is collected and then rendered
- * @param axisAssignments The assignment of the series to their x- and y-axes
- * @param yAxesState The current state of the x-axis
- * @param onUpdateData Callback for when data is updated
- * @param dropDataAfter Limits the amount of data stored. Any data older than this value (ms) will
- * be dropped on the next update
- * @param updateTimingAndPlot The callback function to update the plot and timing
- * @param seriesMap The series-name and the associated series
- * @param ordinalStatsRef The statistics about the data in the chart and about each series
- * @param setCurrentTime Callback to update the current time based on the streamed data
- * @param originalRange The original range of the axes
- * @return A subscription to the observable (for cancelling and the likes)
- */
-export function subscriptionOrdinalXFor(
-    seriesObservable: Observable<OrdinalChartData>,
-    onSubscribe: (subscription: Subscription) => void,
-    windowingTime: number,
-    axisAssignments: Map<string, AxesAssignment>,
-    yAxesState: AxesState<OrdinalStringAxis>,
-    onUpdateData: ((seriesName: string, data: Array<OrdinalDatum>) => void) | undefined,
-    dropDataAfter: number,
-    updateTimingAndPlot: (ranges: Map<string, OrdinalAxisRange>) => void,
-    seriesMap: Map<string, BaseSeries<OrdinalDatum>>,
-    ordinalStatsRef: RefObject<WindowedOrdinalStats>,
-    setCurrentTime: (currentTime: number) => void,
-    originalRange: AxisInterval,
-): Subscription {
-
-    /**
-     * First of two functions to calculate the current ordinal stats for the current time window. This
-     * function updates the windowed stats for the new data.
-     * @param newData The new data for that series
-     * @param windowedStats The current windowed ordinal value status
-     * @return The windowed ordinal value stats updated for the new data
-     */
-    function updatedWindowedValueStatsForNewData(newData: Array<OrdinalDatum>, windowedStats: OrdinalValueStats): OrdinalValueStats {
-        const updatedStats = copyOrdinalValueStats(windowedStats)
-        updatedStats.count += newData.length
-        const newSum = newData.reduce((total, datum) => total + datum.value, 0)
-        updatedStats.sum += newSum
-        updatedStats.sumSquared += newSum * newSum
-        updatedStats.mean = (updatedStats.count > 0) ? updatedStats.sum / updatedStats.count : NaN
-        updatedStats.min = newData.reduce((min, datum) => datum.value < min.value ? datum : min, updatedStats.min)
-        updatedStats.max = newData.reduce((max, datum) => datum.value > max.value ? datum : max, updatedStats.max)
-        return updatedStats
-    }
-
-    /**
-     * Second of two functions to calculate the current ordinal stats for the current time window. This
-     * function updates the windowed stats by for the dropped data
-     * @param droppedData An array of datum that was dropped from the time window
-     * @param windowedStats The current windowed ordinal value stats
-     * @param series An array of series holding all the current data in the time-window
-     * @return The windowed ordinal value stats updated for the dropped data
-     */
-    function updateWindowedValueStatsForDroppedData(
-        droppedData: Array<OrdinalDatum>,
-        windowedStats: OrdinalValueStats,
-        series: BaseSeries<OrdinalDatum>
-    ): OrdinalValueStats {
-        const updatedStats = copyOrdinalValueStats(windowedStats)
-        // calculate the windowed stats based on the dropped data
-        updatedStats.count -= droppedData.length
-        const droppedSum = droppedData.reduce((total, datum) => total + datum.value, 0)
-        updatedStats.sum -= droppedSum
-        updatedStats.sumSquared -= droppedSum * droppedSum
-        updatedStats.mean = (updatedStats.count > 0) ? updatedStats.sum / updatedStats.count : NaN
-        updatedStats.min = series.data.reduce((min, datum) => datum.value < min.value ? datum : min, initialMinValueDatum())
-        updatedStats.max = series.data.reduce((max, datum) => datum.value > max.value ? datum : max, initialMaxValueDatum())
-        return updatedStats
-    }
-
-    //
-    // beginning of the subscription function
-    //
-    const subscription = seriesObservable
-        .pipe(bufferTime(windowingTime))
-        .subscribe(dataList => {
-            dataList.forEach((data: OrdinalChartData) => {
-                // grab the axis ranges for the y-axes
-                const yAxisRanges = ordinalAxisRanges(
-                    yAxesState.axes as Map<string, OrdinalStringAxis>,
-                    originalRange
-                );
-
-                //
-                // calculate the max times for each x-axis, which is the max time over all the
-                // series assigned to an x-axis
-
-                // get the series associated with each y-axis (Map<axis_id, [series_names]>)
-                const axesSeries = associatedSeriesForYAxes(data, axisAssignments, yAxesState)
-
-                // add each new point to it's corresponding series, the new points
-                // is a map(series_name -> new_point[])
-                data.newPoints.forEach((newData, name) => {
-                    // grab the current series associated with the new data
-                    const series = seriesMap.get(name) || emptySeries(name)
-
-                    // update the handler with the new data point
-                    if (onUpdateData) onUpdateData(name, newData)
-
-                    // add the new data to the series
-                    series.data.push(...newData)
-
-                    // grab the stats
-                    ordinalStatsRef.current.minDatum = copyOrdinalDatumExtremum(data.stats.minDatum)
-                    ordinalStatsRef.current.maxDatum = copyOrdinalDatumExtremum(data.stats.maxDatum)
-                    ordinalStatsRef.current.valueStatsForSeries = copyValueStatsForSeries(data.stats.valueStatsForSeries)
-
-                    // set up for the windowed-stats
-                    const lifetimeValueStats = data.stats.valueStatsForSeries.get(name) || defaultOrdinalValueStats()
-                    if (!ordinalStatsRef.current.windowedValueStatsForSeries.has(name)) {
-                        ordinalStatsRef.current.windowedValueStatsForSeries.set(name, copyOrdinalValueStats(lifetimeValueStats))
-                        // ordinalStatsRef.current.windowedValueStatsForSeries.set(name, defaultOrdinalValueStats())
-                    }
-
-                    // update the windowed-stats for the new points (later will deal with datum
-                    // that were dropped)
-                    const updatedStats = ordinalStatsRef.current.windowedValueStatsForSeries.get(name)!
-                    const windowedValueStats = updatedWindowedValueStatsForNewData(newData, updatedStats)
-                    ordinalStatsRef.current.windowedValueStatsForSeries.set(name, windowedValueStats)
-
-                    // calculate the current value for the series' assigned y-axis (which may end up
-                    // just being the default) based on the max time for the series, and the overall
-                    // max time
-                    const axisId = axisAssignments.get(name)?.yAxis || yAxesState.axisDefaultId().getOrElse("");
-                    const currentTime = axesSeries.get(axisId)
-                        ?.reduce(
-                            (tMax, _) => Math.max(data.stats.maxDatum.time.time, tMax),
-                            -Infinity
-                        ) || NaN
-                    setCurrentTime(currentTime)
-
-                    if (currentTime !== undefined) {
-                        // drop data that is older than the max time-window, holding on to the dropped ones
-                        let droppedData: Array<OrdinalDatum> = []
-                        while (currentTime - series.data[0].time > dropDataAfter) {
-                            const dropped = series.data.shift()
-                            if (dropped !== undefined) {
-                                droppedData.push(dropped)
-                            }
-                        }
-
-                        // calculate the windowed stats based on the dropped data
-                        if (droppedData.length > 0) {
-                            ordinalStatsRef.current.windowedValueStatsForSeries.set(
-                                name,
-                                updateWindowedValueStatsForDroppedData(droppedData, windowedValueStats, series)
-                            )
-                        }
-
-                        // // update the time range for the x-axis, and if the time range
-                        // // needs to be updated, then recalculate the time range for the
-                        // // axis, update the time windows, and call the setCurrentTime
-                        // // callback to update the current time for the caller
-                        // const range = yAxisRanges.get(axisId)
-                        // if (range !== undefined && range.end < currentAxisTime) {
-                        //     const timeWindow = range.end - range.start
-                        //     const timeRange = continuousAxisRangeFor(
-                        //         // 0,
-                        //         timeWindowBehavior === TimeWindowBehavior.SQUEEZE && initialTimes.get(axisId) !== undefined ?
-                        //             initialTimes.get(axisId)! :
-                        //             Math.max(0, currentAxisTime - timeWindow),
-                        //         Math.max(currentAxisTime, timeWindow)
-                        //     )
-                        //     yAxisRanges.set(axisId, timeRange)
-                        //     setCurrentTime(axisId, timeRange.end) // callback
-                        // }
-                    }
-                })
-
-                // // grab the stats
-                // ordinalStatsRef.current.minDatum = copyOrdinalDatumExtremum(data.stats.minDatum)
-                // ordinalStatsRef.current.maxDatum = copyOrdinalDatumExtremum(data.stats.maxDatum)
-                // ordinalStatsRef.current.valueStatsForSeries = copyValueStatsForSeries(data.stats.valueStatsForSeries)
-
-                // update the data
-                updateTimingAndPlot(yAxisRanges)  // callback
-            })
-        })
-
-    // provide the subscription to the caller
-    onSubscribe(subscription)   // callback
-
-    return subscription
-}
-
-/**
- * Determines which series are assigned to which x-axes, and returns a map holding the
- * x-axis names and their associated list of series
- * @param data The chart data
- * @param axisAssignments A map holding the  series names and its associated x-axis and y-axis names
- * @param xAxesState Holds information about the axis and how it is displayed
- * @return A map holding the x-axis names the names of the series associated with the axis.
- */
-function associatedSeriesForXAxes(
-    data: TimeSeriesChartData,
-    axisAssignments: Map<string, AxesAssignment>,
-    xAxesState: AxesState<ContinuousNumericAxis>
-): Map<string, Array<string>> {
-    return associatedSeriesFor(
-        assignment => assignment?.xAxis || xAxesState.axisDefaultId().getOrElse(""),
-        data,
-        axisAssignments
-    )
-}
-
-/**
- * Determines which series are assigned to which y-axes, and returns a map holding the
- * x-axis names and their associated list of series
- * @param data The chart data
- * @param axisAssignments A map holding the  series names and its associated x-axis and y-axis names
- * @param yAxesState Holds information about the axis and how it is displayed
- * @return A map holding the y-axis names the names of the series associated with the axis.
- */
-function associatedSeriesForYAxes(
-    data: ChartData,
-    axisAssignments: Map<string, AxesAssignment>,
-    yAxesState: AxesState<OrdinalStringAxis>
-): Map<string, Array<string>> {
-    return associatedSeriesFor(
-        assignment => assignment?.yAxis || yAxesState.axisDefaultId().getOrElse(""),
-        data,
-        axisAssignments
-    )
-}
-
-/**
- * Determines which series are assigned to which axes, and returns a map holding the
- * axis names and their associated list of series. The extractor function returns the axis ID
- * for the series and is responsible for return the x-axis ID or the y-axis ID depending
- * on the context of the call.
- * @param axisIdExtractor A function that accepts the {@link AxesAssignment} and returns the axis ID
- * @param data The chart data
- * @param axisAssignments A map holding the  series names and its associated x-axis and y-axis names
- * @return A map holding the axis names the names of the series associated with the axis.
- */
-function associatedSeriesFor(
-    axisIdExtractor: (assignment?: AxesAssignment) => string,
-    data: ChartData,
-    axisAssignments: Map<string, AxesAssignment>
-): Map<string, Array<string>> {
-    return Array
-        .from(data.seriesNames)
-        .reduce(
-            (assignedSeries, seriesName) => {
-                const id = axisIdExtractor(axisAssignments.get(seriesName))
-                const series = assignedSeries.get(id) || []
-                series.push(seriesName)
-                assignedSeries.set(id, series)
-                return assignedSeries
-            },
-            new Map<string, Array<string>>()
-        )
-}