stream-charts 1.2.1 → 2.0.0

package/src/app/charts/d3types.ts

@@ -1,16 +1,45 @@
-// the axis-element type return when calling the ".call(axis)" function
-import {Selection} from "d3";
-import {Datum} from "./series/timeSeries";
+// Canvas replacement for the old SVG-selection type aliases. There's no DOM element tree to hold
+// a d3 `Selection` over anymore, so instead every axis/plot/tracker draws directly into a shared
+// `CanvasRenderingContext2D`, coordinated through the `CanvasContext` below.
 
-export type AxisElementSelection = Selection<SVGGElement, unknown, null, undefined>
-export type SvgSelection = Selection<SVGSVGElement, any, null, undefined>
-export type GSelection = Selection<SVGGElement, any, null, undefined>
-export type LineSelection = Selection<SVGLineElement, any, SVGGElement, undefined>
-export type TextSelection = Selection<SVGTextElement, any, null, undefined>
+/**
+ * Everything a draw-function needs to paint onto the chart's canvas, plus the API for registering
+ * and scheduling redraws. This is what gets threaded through `useChart()` in place of the old
+ * `mainG` (root SVG `<g>` selection) and `container` (root `<svg>` element).
+ */
+export interface CanvasContext {
+    /** unique id for the chart; mirrors the old `chartId` used to namespace SVG element ids */
+    chartId: number
+    /** the backing `<canvas>` DOM element */
+    canvas: HTMLCanvasElement
+    /** the 2D drawing context for the canvas (already scaled for devicePixelRatio) */
+    context2D: CanvasRenderingContext2D
+    /** the current device-pixel-ratio scaling applied to the context */
+    dpr: number
+    /**
+     * Registers a draw function to be invoked on every redraw. Registering under an `id` that's
+     * already in use replaces the previous draw function for that id (so components can safely
+     * re-register on every render without leaking duplicate draws).
+     * @param id A unique handle for this draw function (e.g. `axis-${chartId}-${axisId}`)
+     * @param draw The function to call, every redraw, to paint this element
+     * @param zIndex Controls draw order (lower first); defaults to 0. Use this to keep, e.g.,
+     * the tracker drawing on top of the series, which draw on top of the axes.
+     */
+    register: (id: DrawHandle, draw: DrawFn, zIndex?: number) => void
+    /**
+     * Removes a previously registered draw function so it no longer participates when the canvas
+     * is redrawn.
+     */
+    unregister: (id: DrawHandle) => void
+    /**
+     * Schedules the canvas to be redrawn on the next animation frame. Safe to call many times
+     * within the same frame/tick -- calls are coalesced into a single `requestAnimationFrame`.
+     */
+    requestRedraw: () => void
+}
 
-export type RadialMagnifierSelection = Selection<SVGCircleElement, Datum, null, undefined>
-export type BarMagnifierSelection = Selection<SVGRectElement, Datum, null, undefined>;
-export type MagnifierTextSelection = Selection<SVGTextElement, any, SVGGElement, undefined>
-
-export type TrackerSelection = Selection<SVGLineElement, Datum, null, undefined>
+/** A function that paints something onto the shared canvas context. */
+export type DrawFn = (cc: CanvasContext) => void
 
+/** The id used to register/unregister a draw function with a {@link CanvasContext}. */
+export type DrawHandle = string

package/src/app/charts/datasources/StreamingDataSource.ts

@@ -0,0 +1,214 @@
+import {BehaviorSubject, Observable, Subject, Subscription} from "rxjs";
+import type {ChartData} from "../observables/ChartData";
+import type {BaseSeries} from "../series/baseSeries";
+
+/**
+ * Creates the observable of chart data that a {@link StreamingDataSource} subscribes to when it
+ * starts. Handed the source's *current* series (not the original initial data), so that a source
+ * that is stopped and then started again (Pause -> Run) resumes generating from where the
+ * accumulated data left off, rather than starting over from the initial data.
+ */
+export type DataGenerator<CD extends ChartData, S> = (currentSeries: Array<S>) => Observable<CD>
+
+/**
+ * Owns the ingestion side of a streaming chart: the one subscription to the data generator, and
+ * the series that the incoming data accumulates into.
+ *
+ * A data source is deliberately *not* tied to any React component. The application creates it
+ * (e.g. in a store), starts and stops it (Run/Pause), and hands it to a {@link Chart}. Plots only
+ * ever *read* from it -- its `series`, and its `chartDataUpdatesObservable` notifications, which a
+ * plot subscribes to for exactly as long as it is mounted. That split is what lets data keep accumulating while a
+ * chart is unmounted (e.g. the user navigated to another page) without any subscription bound to
+ * an unmounted plot instance being kept alive, adopted, or torn down later on.
+ *
+ * Unlike earlier designs, there is never more than one subscription to the generator, and it
+ * exists only while the source is running.
+ * @template CD The type of chart data emitted by the generator
+ * @template D The type of datum held in each series
+ * @template S The type of series
+ */
+export interface StreamingDataSource<CD extends ChartData, D, S extends BaseSeries<D> = BaseSeries<D>> {
+    /**
+     * The live series, keyed by series name, in insertion order. Mutated in place as data
+     * arrives (for performance), so readers see new data without the map being replaced.
+     */
+    readonly series: ReadonlyMap<string, S>
+    /**
+     * Whether the source is currently subscribed to its generator
+     */
+    readonly running: boolean
+    /**
+     * Emits each chunk of chart data *after* it has been ingested into {@link series}. Hot: a
+     * subscriber only sees data that arrives after it subscribes (everything before that is
+     * already in {@link series}).
+     */
+    readonly chartDataUpdatesObservable: Observable<CD>
+    /**
+     * Emits whether the source is running, starting with the current value
+     */
+    readonly isRunningObservable: Observable<boolean>
+    /**
+     * @return The series, as an array, in insertion order
+     */
+    seriesList(): Array<S>
+    /**
+     * @return The latest time of any datum in any series (the stream's "ground truth" time), or
+     * `-Infinity` when there is no data
+     */
+    latestTime(): number
+    /**
+     * Subscribes to the generator (a no-op when already running)
+     */
+    start(): void
+    /**
+     * Unsubscribes from the generator (a no-op when not running). Nothing keeps generating data
+     * in the background once this returns.
+     */
+    stop(): void
+    /**
+     * Replaces the generator, e.g. when the data-update period changes. Only allowed while the
+     * source is stopped -- the new generator is used by the next {@link start}.
+     * @param generator The new generator
+     */
+    setGenerator(generator: DataGenerator<CD, S>): void
+    /**
+     * Stops the source and completes its observables. A disposed source can't be started again.
+     */
+    dispose(): void
+}
+
+/**
+ * The lifecycle shared by every kind of data source. Subclasses only supply how a chunk of chart
+ * data is ingested into the series, and how to find the latest time in the series.
+ */
+export abstract class BaseStreamingDataSource<CD extends ChartData, D, S extends BaseSeries<D>>
+    implements StreamingDataSource<CD, D, S> {
+
+    protected readonly seriesMap: Map<string, S>
+
+    private generator: DataGenerator<CD, S>
+    private subscription: Subscription | undefined = undefined
+    private disposed = false
+
+    private readonly updatesSubject = new Subject<CD>()
+    private readonly runningSubject = new BehaviorSubject<boolean>(false)
+
+    readonly chartDataUpdatesObservable: Observable<CD> = this.updatesSubject.asObservable()
+    readonly isRunningObservable: Observable<boolean> = this.runningSubject.asObservable()
+
+    /**
+     * @param initialData The initial series. The source takes ownership of these series and
+     * mutates them in place as data arrives.
+     * @param generator Creates the observable of chart data when the source starts
+     */
+    protected constructor(initialData: Array<S>, generator: DataGenerator<CD, S>) {
+        this.seriesMap = new Map(initialData.map(series => [series.name, series]))
+        this.generator = generator
+    }
+
+    /**
+     * The live series, keyed by series name, in insertion order (see {@link StreamingDataSource.series})
+     * @return The series map (mutated in place as data arrives)
+     */
+    get series(): ReadonlyMap<string, S> {
+        return this.seriesMap
+    }
+
+    /**
+     * Whether the source is currently subscribed to its generator
+     * @return `true` while the source is running; `false` otherwise
+     */
+    get running(): boolean {
+        return this.runningSubject.value
+    }
+
+    /**
+     * @return The series, as an array, in insertion order
+     */
+    seriesList(): Array<S> {
+        return Array.from(this.seriesMap.values())
+    }
+
+    /**
+     * Subscribes to the generator, handing it the current series, so that a restarted source
+     * resumes from the data accumulated so far. Each chunk of data the generator emits is ingested
+     * into the series, and then emitted through {@link chartDataUpdatesObservable}. When the
+     * generator fails or completes, the source stops. A no-op when the source is already running,
+     * or has been disposed.
+     */
+    start(): void {
+        if (this.disposed || this.subscription !== undefined) return
+
+        const subscription = this.generator(this.seriesList()).subscribe({
+            next: data => {
+                this.ingest(data)
+                this.updatesSubject.next(data)
+            },
+            error: error => {
+                console.error("Streaming data source's generator failed; stopping the source", error)
+                this.markStopped()
+            },
+            complete: () => this.markStopped()
+        })
+
+        // the generator may have completed (or failed) synchronously during `subscribe`, in which
+        // case `markStopped` has already run and there is nothing left to hold on to
+        if (!subscription.closed) {
+            this.subscription = subscription
+            this.runningSubject.next(true)
+        }
+    }
+
+    /**
+     * Unsubscribes from the generator (a no-op when not running). Nothing keeps generating data
+     * in the background once this returns.
+     */
+    stop(): void {
+        if (this.subscription === undefined) return
+        this.subscription.unsubscribe()
+        this.markStopped()
+    }
+
+    /**
+     * Replaces the generator, e.g. when the data-update period changes. The new generator is used
+     * by the next {@link start}.
+     * @param generator The new generator
+     * @throws Error when the source is running (the generator can only be replaced while stopped)
+     */
+    setGenerator(generator: DataGenerator<CD, S>): void {
+        if (this.subscription !== undefined) {
+            throw new Error("The data source's generator can only be replaced while the source is stopped")
+        }
+        this.generator = generator
+    }
+
+    /**
+     * Stops the source and completes its observables. A disposed source can't be started again.
+     */
+    dispose(): void {
+        this.stop()
+        this.disposed = true
+        this.updatesSubject.complete()
+        this.runningSubject.complete()
+    }
+
+    /**
+     * @return The latest time of any datum in any series (the stream's "ground truth" time), or
+     * `-Infinity` when there is no data
+     */
+    abstract latestTime(): number
+
+    /**
+     * Adds a chunk of chart data to the series (and applies any data-retention rules)
+     * @param data The chart data emitted by the generator
+     */
+    protected abstract ingest(data: CD): void
+
+    /**
+     * Forgets the generator subscription, and reports that the source stopped (when it was running)
+     */
+    private markStopped(): void {
+        this.subscription = undefined
+        if (this.runningSubject.value) this.runningSubject.next(false)
+    }
+}

package/src/app/charts/datasources/iteratesDataSource.ts

@@ -0,0 +1,122 @@
+import type {IterateChartData} from "../observables/iterates";
+import type {IterateDatum, IterateSeries} from "../series/iterateSeries";
+import {emptySeries} from "../series/baseSeries";
+import {BaseStreamingDataSource, type DataGenerator} from "./StreamingDataSource";
+
+/**
+ * Calculates the current time for a chunk of iterate chart data: the max over the series of the
+ * time of each series' last new point (or 0 when there are no new points). Shared by the data
+ * source (for dropping old data) and the Poincaré plot's view driver (for reporting the current
+ * time), so both agree on what "now" is.
+ * @param data The iterate chart data
+ * @return The current time
+ */
+export function iteratesCurrentTime(data: IterateChartData): number {
+    return Array.from(data.newPoints.values()).reduce(
+        (maxTime, points) => {
+            const seriesMaxTime = points.length > 0 ? points[points.length - 1].time : 0
+            return seriesMaxTime > maxTime ? seriesMaxTime : maxTime
+        },
+        0
+    )
+}
+
+export interface IteratesDataSourceOptions {
+    /**
+     * The initial series, owned (and mutated in place) by the source from here on
+     */
+    initialData: Array<IterateSeries>
+    /**
+     * Creates the observable of chart data each time the source starts
+     */
+    generator: DataGenerator<IterateChartData, IterateSeries>
+    /**
+     * Data older than this (ms), relative to the current time, is dropped as new data arrives.
+     * Defaults to `Infinity` (never drop).
+     */
+    dropDataAfter?: number
+    /**
+     * Called with each series' new data as it arrives
+     */
+    onUpdateData?: (seriesName: string, data: Array<IterateDatum>) => void
+}
+
+/**
+ * A data source for iterate charts (e.g. the Poincaré plot)
+ */
+export class IteratesDataSource extends BaseStreamingDataSource<IterateChartData, IterateDatum, IterateSeries> {
+    private dropDataAfter: number
+    private readonly onUpdateData: ((seriesName: string, data: Array<IterateDatum>) => void) | undefined
+    // the number of points dropped from each series so far (see `droppedCountFor`)
+    private readonly droppedCounts = new Map<string, number>()
+
+    /**
+     * Creates a iterates data source (stopped: call {@link start} to start it)
+     * @param options The initial data, the generator, and the data-retention settings
+     */
+    constructor(options: IteratesDataSourceOptions) {
+        super(options.initialData, options.generator)
+        this.dropDataAfter = options.dropDataAfter ?? Infinity
+        this.onUpdateData = options.onUpdateData
+    }
+
+    /**
+     * Changes how long data is kept; takes effect as the next data arrives
+     * @param dropDataAfter Data older than this (ms) is dropped
+     */
+    setDropDataAfter(dropDataAfter: number): void {
+        this.dropDataAfter = dropDataAfter
+    }
+
+    /**
+     * @return The latest time (the `time` of the last datum) over all the series, or
+     * `-Infinity` when there is no data
+     */
+    /**
+     * The number of points dropped (as too old) from the front of the specified series so far --
+     * so that a point's overall sequence number in its series is this plus its index in the
+     * series' data, even as old points are dropped (e.g. for colorizing the lines by point, see
+     * the `PoincarePlot`'s `lineColorSteps`)
+     * @param seriesName The name of the series
+     * @return The number of points dropped from the series (0 for an unknown series)
+     */
+    droppedCountFor(seriesName: string): number {
+        return this.droppedCounts.get(seriesName) ?? 0
+    }
+
+    latestTime(): number {
+        return this.seriesList().reduce(
+            (tMax, series) => Math.max(tMax, series.last().map(datum => datum.time).getOrElse(tMax)),
+            -Infinity
+        )
+    }
+
+    /**
+     * Adds each series' new points to it, and drops the points that are older than
+     * `dropDataAfter` relative to the chunk's current time (see `iteratesCurrentTime`),
+     * counting them (see {@link droppedCountFor}). New points for a series that isn't in the
+     * source are ignored. Calls `onUpdateData` with each
+     * series' new points.
+     * @param data The chunk of chart data emitted by the generator
+     */
+    protected ingest(data: IterateChartData): void {
+        const currentTime = iteratesCurrentTime(data)
+        data.newPoints.forEach((newData, seriesName) => {
+            // note: as in the original subscription code, data for a series that isn't already in
+            // the source is accepted but not kept
+            const series = this.seriesMap.get(seriesName) || emptySeries<IterateDatum>(seriesName)
+
+            if (this.onUpdateData) this.onUpdateData(seriesName, newData)
+
+            series.data.push(...newData)
+
+            // drop data that is older than the max time-window -- guarded on series.data.length
+            let dropped = 0
+            while (series.data.length > 0 && currentTime - series.data[0].time > this.dropDataAfter) {
+                series.data.shift()
+                dropped++
+            }
+            if (dropped > 0) this.droppedCounts.set(seriesName, this.droppedCountFor(seriesName) + dropped)
+        })
+    }
+}

package/src/app/charts/datasources/ordinalDataSource.ts

@@ -0,0 +1,205 @@
+import type {BaseSeries} from "../series/baseSeries";
+import {emptySeries} from "../series/baseSeries";
+import {calculateOrdinalStats, type OrdinalDatum} from "../series/ordinalSeries";
+import {
+    copyOrdinalDatumExtremum,
+    copyOrdinalValueStats,
+    copyValueStatsForSeries,
+    defaultOrdinalValueStats,
+    initialMaxValueDatum,
+    initialMinValueDatum,
+    type OrdinalChartData,
+    type OrdinalStats,
+    type OrdinalValueStats
+} from "../observables/ordinals";
+import {BaseStreamingDataSource, type DataGenerator} from "./StreamingDataSource";
+
+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>
+}
+
+/**
+ * Calculates the ordinal stats for each of the ordinal series (generally, initial data) and
+ * returns a {@link WindowedOrdinalStats} object
+ * @param series The array of ordinal series
+ * @return A {@link WindowedOrdinalStats} object with the stats for each of the series
+ */
+export function initialOrdinalStats(series: Array<BaseSeries<OrdinalDatum>>): WindowedOrdinalStats {
+    const ordinalStats = calculateOrdinalStats(series)
+    return {
+        ...ordinalStats,
+        windowedValueStatsForSeries: copyValueStatsForSeries(ordinalStats.valueStatsForSeries)
+    }
+}
+
+/**
+ * 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 stats
+ * @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 for the dropped data (the min and max are recalculated from
+ * the data that's left)
+ * @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)
+    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
+}
+
+export interface OrdinalDataSourceOptions {
+    /**
+     * The initial series, owned (and mutated in place) by the source from here on
+     */
+    initialData: Array<BaseSeries<OrdinalDatum>>
+    /**
+     * Creates the observable of chart data each time the source starts
+     */
+    generator: DataGenerator<OrdinalChartData, BaseSeries<OrdinalDatum>>
+    /**
+     * Data older than this (ms), relative to the chart-wide current time, is dropped (and removed
+     * from the windowed stats) as new data arrives. Defaults to `Infinity` (never drop).
+     */
+    dropDataAfter?: number
+    /**
+     * Called with each series' new data as it arrives
+     */
+    onUpdateData?: (seriesName: string, data: Array<OrdinalDatum>) => void
+}
+
+/**
+ * A data source for ordinal charts (e.g. the bar plot). Besides the series, it keeps the lifetime
+ * stats (from the chart data) and the windowed stats (over the data currently held) for each
+ * series, so they keep accumulating while no plot is mounted.
+ */
+export class OrdinalDataSource extends BaseStreamingDataSource<OrdinalChartData, OrdinalDatum, BaseSeries<OrdinalDatum>> {
+    /**
+     * The lifetime and windowed stats, updated in place as data arrives
+     */
+    readonly stats: WindowedOrdinalStats
+
+    private dropDataAfter: number
+    private readonly onUpdateData: ((seriesName: string, data: Array<OrdinalDatum>) => void) | undefined
+
+    /**
+     * Creates a ordinal data source (stopped: call {@link start} to start it)
+     * @param options The initial data, the generator, and the data-retention settings
+     */
+    constructor(options: OrdinalDataSourceOptions) {
+        super(options.initialData, options.generator)
+        this.stats = initialOrdinalStats(options.initialData)
+        this.dropDataAfter = options.dropDataAfter ?? Infinity
+        this.onUpdateData = options.onUpdateData
+    }
+
+    /**
+     * Changes how long data is kept; takes effect as the next data arrives
+     * @param dropDataAfter Data older than this (ms) is dropped
+     */
+    setDropDataAfter(dropDataAfter: number): void {
+        this.dropDataAfter = dropDataAfter
+    }
+
+    /**
+     * @return The latest time (the `time` of the last datum) over all the series, or
+     * `-Infinity` when there is no data
+     */
+    latestTime(): number {
+        return this.seriesList().reduce(
+            (tMax, series) => Math.max(tMax, series.last().map(datum => datum.time).getOrElse(tMax)),
+            -Infinity
+        )
+    }
+
+    /**
+     * Adds each series' new points to it, copies the chunk's lifetime stats, updates the series'
+     * windowed stats for the new points, and then drops the points that are older than
+     * `dropDataAfter` relative to the chart-wide current time (the time of the latest datum over
+     * all series), removing them from the windowed stats too. New points for a series that isn't
+     * in the source are ignored (bar charts have a fixed set of categories). Calls `onUpdateData`
+     * with each series' new points.
+     * @param data The chunk of chart data emitted by the generator
+     */
+    protected ingest(data: OrdinalChartData): void {
+        // the chart-wide current time (the time of the latest datum over all series). When it
+        // isn't a number, the drop comparison below is simply false, so nothing is dropped.
+        const currentTime = data.stats.maxDatum.time.time
+
+        data.newPoints.forEach((newData, name) => {
+            // note: as in the original subscription code, data for a series that isn't already in
+            // the source is accepted but not kept (bar charts have a fixed set of categories)
+            const series = this.seriesMap.get(name) || emptySeries<OrdinalDatum>(name)
+
+            if (this.onUpdateData) this.onUpdateData(name, newData)
+
+            series.data.push(...newData)
+
+            // grab the (lifetime) stats
+            this.stats.minDatum = copyOrdinalDatumExtremum(data.stats.minDatum)
+            this.stats.maxDatum = copyOrdinalDatumExtremum(data.stats.maxDatum)
+            this.stats.valueStatsForSeries = copyValueStatsForSeries(data.stats.valueStatsForSeries)
+
+            // set up for the windowed-stats
+            const lifetimeValueStats = data.stats.valueStatsForSeries.get(name) || defaultOrdinalValueStats()
+            if (!this.stats.windowedValueStatsForSeries.has(name)) {
+                this.stats.windowedValueStatsForSeries.set(name, copyOrdinalValueStats(lifetimeValueStats))
+            }
+
+            // update the windowed-stats for the new points (the dropped points are dealt with below)
+            const windowedValueStats = updatedWindowedValueStatsForNewData(
+                newData,
+                this.stats.windowedValueStatsForSeries.get(name)!
+            )
+            this.stats.windowedValueStatsForSeries.set(name, windowedValueStats)
+
+            // drop data older than the max time-window, holding on to the dropped ones -- guarded
+            // on series.data.length, since the current time is the max across ALL series, so a
+            // single lagging series could otherwise be shifted down to empty
+            const droppedData: Array<OrdinalDatum> = []
+            while (series.data.length > 0 && currentTime - series.data[0].time > this.dropDataAfter) {
+                const dropped = series.data.shift()
+                if (dropped !== undefined) droppedData.push(dropped)
+            }
+
+            // remove the dropped data from the windowed stats
+            if (droppedData.length > 0) {
+                this.stats.windowedValueStatsForSeries.set(
+                    name,
+                    updateWindowedValueStatsForDroppedData(droppedData, windowedValueStats, series)
+                )
+            }
+        })
+    }
+}