stream-charts 1.0.0 → 1.1.0

package/dist/src/app/charts/axes/OrdinalAxisRange.js

@@ -0,0 +1,100 @@
+import { BaseAxisRange } from "./BaseAxisRange";
+/**
+ * An immutable ordinal-axis range that holds the current range and the original (no zoom) range.
+ * Create an instance using the {@link OrdinalAxisRange.from} factory method.
+ */
+export class OrdinalAxisRange extends BaseAxisRange {
+    constructor(start, end, originalStart = start, originalEnd = end) {
+        super(start, end, originalStart, originalEnd);
+    }
+    /**
+     * Factory function for creating a new ordinal-axis range instance.
+     * @param start The start of the axis-range.
+     * @param end The end of the axis-range.
+     * @param [originalStart=start] The optional original start of the axis-range (e.g. before any zooming or panning.
+     * Defaults to the start value if not specified.)
+     * @param [originalEnd=end] The optional original end of the axis-range (e.g. before any zooming or panning.
+     * Defaults to the end value if not specified.)
+     * @return A new continuous-axis range instance.
+     */
+    static from(start, end, originalStart = start, originalEnd = end) {
+        return new OrdinalAxisRange(start, end, originalStart, originalEnd);
+    }
+    /**
+     * Scales the axis-range by the specified scale factor from the specified value. The equations
+     * are written so that the zooming (scaling) occurs at the specified value, and expands/contracts equally
+     * from that value. This operation does not modify the original range.
+     * @param factor The scale factor
+     * @param value The value from which to scale the interval
+     * @return A new continuous-axis range with updated values
+     */
+    scale(factor, value) {
+        const scaledInterval = this.scaledRange(factor, value);
+        return new OrdinalAxisRange(scaledInterval.start, scaledInterval.end, this.original.start, this.original.end);
+    }
+    /**
+     * Scales the axis-range by the specified scale factor from the specified value, while keeping
+     * the range within the constraints (start, end). The equations are written so that the zooming
+     * (scaling) occurs at the specified value, and expands/contracts equally from that value.
+     * @param factor The scale factor
+     * @param value The value from which to scale the interval
+     * @param constraint The minimum and maximum values that range bounds can be
+     * @return A new continuous-axis range with updated values
+     */
+    constrainedScale(factor, value, constraint) {
+        const scaledInterval = this.scaledRange(factor, value);
+        const [min, max] = constraint;
+        return new OrdinalAxisRange(Math.min(min, scaledInterval.start), Math.max(max, scaledInterval.end), this.original.start, this.original.end);
+    }
+    /**
+     * Translates the axis-range by the specified amount
+     * @param amount The amount by which to translate the axis-range
+     * @param [constraint=[-Infinity, Infinity]] Optional constraint interval in which the axis range must be within
+     * @return An updated {@link OrdinalAxisRange} that has been translated by the specified amount
+     */
+    translate(amount, constraint = [-Infinity, Infinity]) {
+        const [cs, ce] = constraint;
+        // when either of the constraints is infinite, or the pan keeps the new axis range
+        // within the origin axis range (i.e. zoomed in and the panned), then allow the pan,
+        // otherwise don't update
+        if ((!isFinite(cs) && !isFinite(ce)) || (this.current.start + amount >= cs && this.current.end + amount <= ce)) {
+            return new OrdinalAxisRange(this.current.start + amount, this.current.end + amount, this.original.start, this.original.end);
+        }
+        return new OrdinalAxisRange(this.current.start, this.current.end, this.original.start, this.original.end);
+    }
+    /**
+     * Assumes that the original ranges start at 0 and end at the width or height of the plot. Calculates the
+     * new range based on the change in dimensions and the previous range. And calculates the new original range
+     * based on the change in the dimensions.
+     * @param beforeDimension The width or height before the change in dimensions
+     * @param afterDimension The width or height after the change in dimensions
+     * @return An updated {@link OrdinalAxisRange} that has been zoomed based on the change in
+     * the dimensions.
+     */
+    zoom(beforeDimension, afterDimension) {
+        const [start, end] = this.current.asTuple();
+        const delta = (end - start) * (afterDimension - beforeDimension) / beforeDimension;
+        const lowerBound = start / (end - start) * delta + start;
+        const upperBound = end / (end - start) * delta + end;
+        return new OrdinalAxisRange(lowerBound, upperBound, 0, afterDimension);
+    }
+    /**
+     * Updates the axis-range with the new start and end values, leaving the original range unchanged.
+     * @param start The new start of the axis-range
+     * @param end The new end of the axis range
+     * @return The updated axis-range type, with all other values unchanged.
+     */
+    update(start, end) {
+        return new OrdinalAxisRange(start, end, this.original.start, this.original.end);
+    }
+    /**
+     * Updates the original range with the new start and end values.
+     * @param start The new value for the start of the original range
+     * @param end The new value for the end of the original range
+     * @return The updated original range.
+     */
+    updateOriginal(start, end) {
+        return new OrdinalAxisRange(this.current.start, this.current.end, start, end);
+    }
+}
+//# sourceMappingURL=OrdinalAxisRange.js.map

package/dist/src/app/charts/axes/OrdinalAxisRange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrdinalAxisRange.js","sourceRoot":"","sources":["../../../../../src/app/charts/axes/OrdinalAxisRange.ts"],"names":[],"mappings":"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"}

package/dist/src/app/charts/axes/OrdinalAxisRange.test.js

@@ -0,0 +1,48 @@
+import { OrdinalAxisRange } from './OrdinalAxisRange';
+describe('scaleOrdinalBounds', () => {
+    function validateRanges(actualRanges, expectedRanges) {
+        const { current: actualRange, original: actualOriginal } = actualRanges;
+        expect(actualRange.start).toBeCloseTo(expectedRanges.current.start);
+        expect(actualRange.end).toBeCloseTo(expectedRanges.current.end);
+        expect(actualOriginal.start).toBe(expectedRanges.original.start);
+        expect(actualOriginal.end).toBe(expectedRanges.original.end);
+    }
+    function calculateScale(ranges) {
+        return ranges.currentDistance / ranges.originalDistance;
+    }
+    /**
+     * Ranges before and after zoom should have the same scale as calculated by the
+     * measure of the zoomed range divided by the measure of the original range.
+     * @param previousRanges The ranges before the zoom
+     * @param currentRanges The ranges after the zoom
+     */
+    function validateScale(previousRanges, currentRanges) {
+        expect(Math.abs(calculateScale(previousRanges) - calculateScale(currentRanges))).toBeLessThan(1e-10);
+    }
+    it('should scale bounds and original bounds the same when they are both the same', () => {
+        const expectedRange = OrdinalAxisRange.from(0, 200, 0, 200);
+        const range = OrdinalAxisRange.from(0, 100, 0, 100);
+        const zoomedRange = range.zoom(100, 200);
+        validateRanges(zoomedRange, expectedRange);
+        validateScale(range, zoomedRange);
+    });
+    it('should scale bounds and original bounds when ordinal axis is zoomed by 10 percent', () => {
+        const expectedRange = OrdinalAxisRange.from(-55, 220, 0, 110);
+        const range = OrdinalAxisRange.from(-50, 200, 0, 100);
+        const zoomedRange = range.zoom(100, 110);
+        validateRanges(zoomedRange, expectedRange);
+    });
+    it('should scale bounds and original bounds when ordinal axis is zoomed by 500 percent', () => {
+        const expectedRange = OrdinalAxisRange.from(-250, 1000, 0, 500);
+        const range = OrdinalAxisRange.from(-50, 200, 0, 100);
+        const zoomedRange = range.zoom(100, 500);
+        validateRanges(zoomedRange, expectedRange);
+    });
+    it('should scale bounds and original bounds when ordinal axis is zoomed by 10 percent and ends are same', () => {
+        const expectedRange = OrdinalAxisRange.from(-750, 500, 0, 500);
+        const range = OrdinalAxisRange.from(-150, 100, 0, 100);
+        const zoomedRange = range.zoom(100, 500);
+        validateRanges(zoomedRange, expectedRange);
+    });
+});
+//# sourceMappingURL=OrdinalAxisRange.test.js.map

package/dist/src/app/charts/axes/OrdinalAxisRange.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"OrdinalAxisRange.test.js","sourceRoot":"","sources":["../../../../../src/app/charts/axes/OrdinalAxisRange.test.ts"],"names":[],"mappings":"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"}

package/dist/src/app/charts/axes/axes.d.ts

@@ -0,0 +1,391 @@
+import { Dimensions, Margin } from "../styling/margins";
+import { ContinuousAxisRange } from "./ContinuousAxisRange";
+import { Axis, ScaleBand, ScaleContinuousNumeric, ZoomTransform } from "d3";
+import { AxisElementSelection, SvgSelection } from "../d3types";
+import { AxesState } from "./AxesState";
+import { AxesAssignment } from "../plots/plot";
+import { BaseSeries } from "../series/baseSeries";
+import { OrdinalAxisRange } from "./OrdinalAxisRange";
+import { BaseAxisRange } from "./BaseAxisRange";
+import { AxisInterval } from "./AxisInterval";
+/**
+ * Holds the style for the axis tick labels
+ */
+export type AxisTickStyle = {
+    font: AxesFont;
+    rotation: number;
+    useAutoRotation: boolean;
+};
+/**
+ * Factory function to create a default AxisTickStyle with the default font,
+ * no rotation, and no auto-rotation.
+ */
+export declare function defaultAxisTickStyle(): AxisTickStyle;
+/**
+ * Holds the font information for the axis labels
+ */
+export interface AxesFont {
+    size: number;
+    color: string;
+    family: string;
+    weight: number;
+}
+/**
+ * Factory function to create a default AxesFont with the default font size, color,
+ * family, and weight.
+ */
+export declare function defaultAxesFont(): AxesFont;
+/**
+ * Holds the style information for a series in a chart
+ */
+export interface SeriesStyle {
+    color: string;
+    highlightColor: string;
+    margin?: number;
+}
+/**
+ * Holds the style information for a series line-style in a chart.
+ */
+export interface SeriesLineStyle extends SeriesStyle {
+    lineWidth: number;
+    highlightWidth: number;
+}
+/**
+ * Factory function to create a default SeriesLineStyle with the default color, line width,
+ * highlight color, and highlight width.
+ */
+export declare function defaultLineStyle(): SeriesLineStyle;
+/**
+ * The base interface that all Axes must implement. Each axis must have a unique ID,
+ * a location (top, bottom, left, right), and d3 SVG selection for the axis.
+ */
+export interface BaseAxis {
+    axisId: string;
+    location: AxisLocation;
+    selection: AxisElementSelection;
+}
+/**
+ * Represents a continuous numeric axis.
+ */
+export interface ContinuousNumericAxis extends BaseAxis {
+    /**
+     * A d3 scale for a continuous numeric axis.
+     */
+    scale: ScaleContinuousNumeric<number, number>;
+    /**
+     * A d3 axis generator for a continuous numeric axis.
+     */
+    generator: Axis<number | {
+        valueOf(): number;
+    }>;
+    /**
+     * Updates the axis based on the specified domain and plot dimensions.
+     * @param domain The interval representing the domain of the axis.
+     * @param plotDimensions The dimensions of the plot (without the margins).
+     * @param margin The margins for the plot
+     */
+    update: (domain: AxisInterval, plotDimensions: Dimensions, margin: Margin) => void;
+}
+/**
+ * Represents an ordinal string axis.
+ */
+export interface OrdinalStringAxis extends BaseAxis {
+    /**
+     * A d3 scale for an ordinal string axis.
+     */
+    scale: ScaleBand<string>;
+    /**
+     * A d3 axis generator for an ordinal string axis.
+     */
+    generator: Axis<string>;
+    /**
+     * The size of each category on the axis.
+     */
+    categorySize: number;
+    /**
+     * Updates the axis based on the specified domain and plot dimensions.
+     * @param range An interval representing the range of the axis.
+     * @param originalRange An interval representing the original range of the axis (before zooming or panning).
+     * @param plotDimensions The dimensions of the plot (without the margins).
+     * @param margin The margins for the plot
+     * @return The number of pixels for each category on the axis.
+     */
+    update: (range: AxisInterval, originalRange: AxisInterval, plotDimensions: Dimensions, margin: Margin) => number;
+}
+/**
+ * Enumerates the possible locations of an axis.
+ */
+export declare enum AxisLocation {
+    Left = 0,
+    Right = 1,
+    Bottom = 2,
+    Top = 3
+}
+/**
+ * Adds a clip area for the chart to the specified SVG element. The clip-area is given
+ * an `id` of `clip-series-<chart_id>`, which because the chart ID should be unique, makes
+ * this unique as well
+ * @param chartId The ID of the chart to which the clip area is to be added
+ * @param axisId The ID of the axis to which the clip area is to be added
+ * @param svg The SVG element to which the clip area is to be added
+ * @param location The location of the axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The margins around the plot
+ * @return The ID of the clip-path
+ */
+export declare function setClipPath(chartId: number, axisId: string, svg: SvgSelection, location: AxisLocation, plotDimensions: Dimensions, margin: Margin): string;
+/**
+ * Adds a category axis to the specified location. When the location is top or bottom,
+ * the category axis represents the x-axis. When the location is left or right, then the
+ * category axis represents the y-axis.
+ * @param chartId The unique ID of the chart to which this axis belongs
+ * @param axisId A unique ID for the axis
+ * @param svg The SVG selection (d3)
+ * @param location The location of the axis
+ * @param categories An array holding the category names
+ * @param axisLabel The axis label
+ * @param axesLabelFont The font for the axis label
+ * @param axisTickStyle Styling information for the ticks (e.g. font, rotation, etc)
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margin
+ * @param setAxisRangeFor Lambda that sets the axis range for the specified axis
+ * @param setOriginalAxisRangeFor Lambda that sets the original axis range for the specified axis
+ * @return A category axis
+ */
+export declare function addOrdinalStringAxis(chartId: number, axisId: string, svg: SvgSelection, location: AxisLocation, categories: Array<string>, axisLabel: string, axesLabelFont: AxesFont, axisTickStyle: AxisTickStyle, plotDimensions: Dimensions, margin: Margin, setAxisRangeFor: (axisId: string, range: AxisInterval) => void, setOriginalAxisRangeFor: (axisId: string, range: AxisInterval) => void): OrdinalStringAxis;
+/**
+ * Adds a new x-axis to the SVG element at the specified location
+ * @param chartId The ID of the chart
+ * @param axisId The ID of the axis
+ * @param svg The SVG selection to which to add the axis
+ * @param plotDimensions The dimensions of the plot
+ * @param location The location of the axis
+ * @param scaleGenerator The higher-order function that returns the axis d3 "scale" function
+ * @param domain The axis range (start, end)
+ * @param axesLabelFont The font for the axis labels
+ * @param margin The plot margins for the border of main SVG group
+ * @param axisLabel The label for the axis
+ * @param setAxisRangeFor A callback used to set the axis range
+ * @return A {@link ContinuousNumericAxis} based on the arguments to this function
+ */
+export declare function addContinuousNumericXAxis(chartId: number, axisId: string, svg: SvgSelection, plotDimensions: Dimensions, location: AxisLocation.Bottom | AxisLocation.Top, scaleGenerator: ScaleContinuousNumeric<number, number>, domain: [minValue: number, maxValue: number], axesLabelFont: AxesFont, margin: Margin, axisLabel: string, setAxisRangeFor: (axisId: string, timeRange: AxisInterval) => void): ContinuousNumericAxis;
+/**
+ * Adds a new y-axis to the SVG element at the specified location
+ * @param chartId The ID of the chart
+ * @param axisId The ID of the axis
+ * @param svg The SVG selection to which to add the axis
+ * @param plotDimensions The dimensions of the plot
+ * @param location The location of the axis
+ * @param scaleGenerator The higher-order function that returns the axis d3 "scale" function
+ * @param domain The axis range (start, end)
+ * @param axesLabelFont The font for the axis labels
+ * @param margin The plot margins for the border of main SVG group
+ * @param axisLabel The label for the axis
+ * @param setAxisRangeFor A callback used to set the axis range
+ * @return A {@link ContinuousNumericAxis} based on the arguments to this function
+ */
+export declare function addContinuousNumericYAxis(chartId: number, axisId: string, svg: SvgSelection, plotDimensions: Dimensions, location: AxisLocation.Left | AxisLocation.Right, scaleGenerator: ScaleContinuousNumeric<number, number>, domain: [minValue: number, maxValue: number], axesLabelFont: AxesFont, margin: Margin, axisLabel: string, setAxisRangeFor: (axisId: string, range: AxisInterval) => void): ContinuousNumericAxis;
+/**
+ * Calculates a unique ID for the axis based on the location and chart ID
+ * @param chartId The unique ID of the chart
+ * @param location The axis location (i.e. top, bottom, left, right)
+ * @return A unique ID for the axis
+ */
+export declare function labelIdFor(chartId: number, location: AxisLocation): string;
+/**
+ * The result of a zoom action
+ */
+export interface ZoomResult<AR extends BaseAxisRange> {
+    range: AR;
+    zoomFactor: number;
+}
+/**
+ * Called when the user uses the scroll wheel (or scroll gesture) to zoom in or out. Zooms in/out
+ * at the location of the mouse when the scroll wheel or gesture was applied, while ensure that
+ * the range (start, end) is contained within the constraint (min, max).
+ * @param transform The d3 zoom transformation information
+ * @param x The x-position of the mouse when the scroll wheel or gesture is used
+ * @param axis The axis being zoomed
+ * @param range The current range for the axis being zoomed
+ * @param constraint The minimum and maximum value the scaled range can have
+ * @return The updated range and the new zoom factor
+ */
+export declare function calculateConstrainedZoomFor(transform: ZoomTransform, x: number, axis: ContinuousNumericAxis, range: ContinuousAxisRange, constraint: [min: number, max: number]): ZoomResult<ContinuousAxisRange>;
+/**
+ * Calculates the zoom for an ordinal axis.
+ * @param transform The d3 zoom transformation information
+ * @param x The x-position of the mouse when the scroll wheel or gesture is used
+ * @param range The current range for the axis being zoomed
+ * @param constraint The minimum and maximum value the scaled range can have
+ * @return A ZoomResult holding the updated range and the new zoom factor
+ */
+export declare function calculateOrdinalConstrainedZoomFor(transform: ZoomTransform, x: number, range: OrdinalAxisRange, constraint: [min: number, max: number]): ZoomResult<OrdinalAxisRange>;
+/**
+ * Adjusts the range and updates the plot when the plot is dragged to the left or right
+ * @param delta The amount that the plot is dragged
+ * @param axis The axis being zoomed
+ * @param range The current range for the axis being zoomed
+ * @param [constrainToOriginalRange=false] When set to `true` then the pan requires that the axis
+ * range remains a subset of the origin axis range; when `false` the pan allows and range
+ * @return The updated range
+ */
+export declare function calculatePanFor(delta: number, axis: ContinuousNumericAxis, range: ContinuousAxisRange, constrainToOriginalRange?: boolean): ContinuousAxisRange;
+export declare function calculateOrdinalPanFor(delta: number, range: OrdinalAxisRange, plotDimensions: Dimensions, constrainToOriginalRange?: boolean): OrdinalAxisRange;
+/**
+ * Accepts the series, the assignment of the series to axes, and the current x-axes state, and
+ * returns an array of the distinct axis IDs that cover all the series in the plot.
+ *
+ * @param series The array of series
+ * @param axisAssignments A map association a series name with its axis assignments
+ * @param axesState The current axis state
+ * @return an array of the distinct axes that cover all the series in the plot
+ */
+export declare function axesForSeriesGen<D, A extends BaseAxis>(series: Array<BaseSeries<D>>, axisAssignments: Map<string, AxesAssignment>, axesState: AxesState<A>): Array<string>;
+/**
+ * Higher-order function that generates a handler for pan events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, axis-range update function, and the current state of the x-axes. This
+ * function returns a handler function. And this handler function adjusts the time-range when the plot is dragged
+ * to the left or right. After calling the handler function, the plot needs to be updated as well, and this is
+ * left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param axesForSeries The distinct axes that cover all the series
+ * @param margin The plot margin
+ * @param setAxisRangeFor Function for setting the new axis-range for a specific axis
+ * @param axesState The current state of the x-axes or y-axes
+ * @param [constrainToOriginalRange=false] Optional argument, that when set to `true`, constrains the
+ * axis range to remain in the origin axis range; when `false` the axis range is unconstrained
+ * @return A handler function for pan events
+ */
+export declare function panHandler(axesForSeries: Array<string>, margin: Margin, setAxisRangeFor: (axisId: string, axisRange: AxisInterval) => void, axesState: AxesState<ContinuousNumericAxis>, constrainToOriginalRange?: boolean): (x: number, plotDimensions: Dimensions, ranges: Map<string, ContinuousAxisRange>) => void;
+/**
+ * Higher-order function that generates a handler for pan events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, axis-range update function, and the current state of the x-axes. This
+ * function returns a handler function. And this handler function adjusts the time-range when the plot is dragged
+ * to the left or right. After calling the handler function, the plot needs to be updated as well, and this is
+ * left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param axesForSeries The distinct axes that cover all the series
+ * @param margin The plot margin
+ * @param setAxisRangeFor Function for setting the new axis-range for a specific axis
+ * @param axesState The current state of the x-axes or y-axes
+ * @param [constrainToOriginalRange=false] Optional argument, that when set to `true`, constrains the
+ * axis range to remain in the origin axis range; when `false` the axis range is unconstrained
+ * @return A handler function for pan events
+ */
+export declare function ordinalPanHandler(axesForSeries: Array<string>, margin: Margin, setAxisRangeFor: (axisId: string, axisRange: AxisInterval) => void, axesState: AxesState<OrdinalStringAxis>, constrainToOriginalRange?: boolean): (x: number, plotDimensions: Dimensions, series: Array<string>, ranges: Map<string, OrdinalAxisRange>) => void;
+/**
+ * Higher-order function that generates a handler for pan events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, time-range update function, and the current state of the x-axes. This
+ * function returns a handler function. And this handler function adjusts the time-range when the plot is dragged
+ * to the left or right. After calling the handler function, the plot needs to be updated as well, and this is
+ * left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param xAxesForSeries The distinct x-axes that cover all the series
+ * @param yAxesForSeries The distinct y-axes that cover all the series
+ * @param margin The plot margin
+ * @param setAxisRange Function for setting the new time-range for a specific axis
+ * @param xAxesState The current state of the x-axes
+ * @param yAxesState The current state of the y-axes
+ * @param [constrainToOriginalRange=true] Optional argument, that when set to `true`, constrains the
+ * axis range to remain in the origin axis range; when `false` the axis range is unconstrained
+ * @return A handler function for pan events
+ */
+export declare function panHandler2D(xAxesForSeries: Array<string>, yAxesForSeries: Array<string>, margin: Margin, setAxisRange: (axisId: string, axisRange: AxisInterval) => void, xAxesState: AxesState<ContinuousNumericAxis>, yAxesState: AxesState<ContinuousNumericAxis>, constrainToOriginalRange?: boolean): (x: number, y: number, plotDimensions: Dimensions, series: Array<string>, xRanges: Map<string, ContinuousAxisRange>, yRanges: Map<string, ContinuousAxisRange>) => void;
+/**
+ * Higher-order function that generates a handler for zoom events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, range update function, and the current state of the x- or y-axes. This
+ * function returns a handler function. And this handler function adjusts the range when the plot is zoomed.
+ * After calling the handler function, the plot needs to be updated as well, and this is left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param axesForSeries The distinct axes that cover all the series
+ * @param margin The plot margin
+ * @param setRangeFor Function for setting the new time-range for a specific axis
+ * @param axesState The current state of the x- or y-axes
+ * @param scaleExtent The minimum and maximum allowed scale factors
+ * @return A handler function for pan events
+ */
+export declare function continuousAxisZoomHandler(axesForSeries: Array<string>, margin: Margin, setRangeFor: (axisId: string, range: AxisInterval) => void, axesState: AxesState<ContinuousNumericAxis>, scaleExtent?: [min: number, max: number]): (transform: ZoomTransform, x: number, plotDimensions: Dimensions, ranges: Map<string, ContinuousAxisRange>) => void;
+/**
+ * Higher-order function that generates a handler for zoom events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, range update function, and the current state of the x- or y-axes. This
+ * function returns a handler function. And this handler function adjusts the range when the plot is zoomed.
+ * After calling the handler function, the plot needs to be updated as well, and this is left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param axesForSeries The distinct axes that cover all the series
+ * @param margin The plot margin
+ * @param setRangeFor Function for setting the new time-range for a specific axis
+ * @param setOriginalRangeFor Function for setting the new original range for a specific axis
+ * @param axesState The current state of the x- or y-axes
+ * @param scaleExtent The minimum and maximum allowed scale factors
+ * @return A handler function for pan events
+ */
+export declare function ordinalAxisZoomHandler(axesForSeries: Array<string>, margin: Margin, setRangeFor: (axisId: string, range: AxisInterval) => void, setOriginalRangeFor: (axisId: string, range: AxisInterval) => void, axesState: AxesState<OrdinalStringAxis>, scaleExtent?: [min: number, max: number]): (transform: ZoomTransform, x: number, plotDimensions: Dimensions, ranges: Map<string, OrdinalAxisRange>) => void;
+/**
+ * Higher-order function that generates a handler for zoom events, given the distinct series IDs that cover all
+ * the axes in the chart, the margin, range update function, and the current state of the x- or y-axes. This
+ * function returns a handler function. And this handler function adjusts the time-range when the plot is zoomed.
+ * After calling the handler function, the plot needs to be updated as well, and this is left for the caller.
+ *
+ * Please note that the function generated by this function has side effects -- it updates the axes ranges.
+ *
+ * @param xAxesForSeries The distinct x-axes that cover all the series
+ * @param yAxesForSeries The distinct y-axes that cover all the series
+ * @param margin The plot margin
+ * @param setRangeFor Function for setting the new time-range for a specific axis
+ * @param xAxesState The current state of the x-axes
+ * @param yAxesState The current state of the y-axes
+ * @param scaleExtent The smallest and largest scale factors allowed
+ * @return A handler function for pan events
+ */
+export declare function axesZoomHandler(xAxesForSeries: Array<string>, yAxesForSeries: Array<string>, margin: Margin, setRangeFor: (axisId: string, range: AxisInterval) => void, xAxesState: AxesState<ContinuousNumericAxis>, yAxesState: AxesState<ContinuousNumericAxis>, scaleExtent: [min: number, max: number]): (transform: ZoomTransform, mousePosition: [x: number, y: number], plotDimensions: Dimensions, xRanges: Map<string, ContinuousAxisRange>, yRanges: Map<string, ContinuousAxisRange>) => void;
+/**
+ * Calculates the axis-ranges for each of the continuous numeric axes in the map
+ * @param axes The map containing the axes and their associated IDs
+ * @return a map associating the axis IDs to their continuous axis-range
+ */
+export declare function continuousAxisRanges(axes: Map<string, ContinuousNumericAxis>): Map<string, ContinuousAxisRange>;
+/**
+ * Calculates the axis-ranges for each of the ordinal axes in the map
+ * @param axes The map containing the axes and their associated IDs
+ * @param originalRange The original range of the axis
+ * @return a map associating the axis IDs to their ordinal axis-range
+ */
+export declare function ordinalAxisRanges(axes: Map<string, OrdinalStringAxis>, originalRange: AxisInterval): Map<string, OrdinalAxisRange>;
+/**
+ * Calculates the axis interval (start, end) for each of the axis
+ * @param axes The axes representing the time
+ * @return A map associating each axis with a (start, end) interval
+ */
+export declare function continuousAxisIntervals(axes: Map<string, ContinuousNumericAxis>): Map<string, AxisInterval>;
+/**
+ * Calculates the axis interval (start, end) for each of the axis
+ * @param axes The axes representing the time
+ * @return A map associating each axis with a (start, end) interval
+ */
+export declare function ordinalAxisIntervals(axes: Map<string, OrdinalStringAxis>): Map<string, {
+    interval: AxisInterval;
+    categories: Array<string>;
+}>;
+/**
+ * Returns the bounds on the specified continuous numeric axes
+ * @param axes A map associating an axis ID with a {@link ContinuousNumericAxis}
+ * @return A map associating each specified axis ID with the interval covered (bounds) by the axis
+ */
+export declare function continuousRange(axes: Map<string, ContinuousNumericAxis>): Map<string, ContinuousAxisRange>;
+/**
+ * Returns the bounds on the specified continuous numeric axes
+ * @param axes A map associating an axis ID with a {@link OrdinalStringAxis}
+ * @param originalRange The original range of the axis
+ * @return A map associating each specified axis ID with the interval covered (bounds) by the axis
+ */
+export declare function ordinalRange(axes: Map<string, OrdinalStringAxis>, originalRange: AxisInterval): Map<string, OrdinalAxisRange>;