stream-charts 1.0.1 → 1.1.1

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

@@ -0,0 +1,1046 @@
+import { ContinuousAxisRange } from "./ContinuousAxisRange";
+import * as d3 from "d3";
+import { noop } from "../utils";
+import { OrdinalAxisRange } from "./OrdinalAxisRange";
+import { AxisInterval } from "./AxisInterval";
+/**
+ * Factory function to create a default AxisTickStyle with the default font,
+ * no rotation, and no auto-rotation.
+ */
+export function defaultAxisTickStyle() {
+    return {
+        font: defaultAxesFont(),
+        rotation: 0,
+        useAutoRotation: false
+    };
+}
+/**
+ * Factory function to create a default AxesFont with the default font size, color,
+ * family, and weight.
+ */
+export function defaultAxesFont() {
+    return {
+        size: 12,
+        color: '#d2933f',
+        weight: 300,
+        family: 'sans-serif'
+    };
+}
+/**
+ * Factory function to create a default SeriesLineStyle with the default color, line width,
+ * highlight color, and highlight width.
+ */
+export function defaultLineStyle() {
+    return {
+        color: '#008aad',
+        lineWidth: 1,
+        highlightColor: '#008aad',
+        highlightWidth: 3,
+    };
+}
+/**
+ * Enumerates the possible locations of an axis.
+ */
+export var AxisLocation;
+(function (AxisLocation) {
+    // y-axes
+    AxisLocation[AxisLocation["Left"] = 0] = "Left";
+    AxisLocation[AxisLocation["Right"] = 1] = "Right";
+    // x-axes
+    AxisLocation[AxisLocation["Bottom"] = 2] = "Bottom";
+    AxisLocation[AxisLocation["Top"] = 3] = "Top";
+})(AxisLocation || (AxisLocation = {}));
+/*
+        axis clip path definition
+ */
+/**
+ * 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 function setClipPath(chartId, axisId, svg, location, plotDimensions, margin) {
+    const clipPathId = `chart-clip-path-${chartId}-${axisId}`;
+    // calculate the width and height of the clip-area for the axis
+    const width = location === AxisLocation.Left ? margin.right :
+        location === AxisLocation.Right ? margin.left :
+            plotDimensions.width;
+    const height = location === AxisLocation.Top ? margin.top + 1 :
+        location === AxisLocation.Bottom ? margin.bottom - 1 :
+            plotDimensions.height;
+    // remove the old clipping region and add a new one with the updated plot dimensions
+    svg.select(`#${clipPathId}-defs`).remove();
+    svg
+        .append('defs')
+        .attr('id', `${clipPathId}-defs`)
+        .append("clipPath")
+        .attr("id", clipPathId)
+        .append("rect")
+        .attr("x", 0)
+        .attr("y", location === AxisLocation.Bottom ? -1 : -margin.top)
+        .attr("width", width)
+        .attr("height", height);
+    return clipPathId;
+}
+/*
+        category axes
+ */
+/**
+ * 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 function addOrdinalStringAxis(chartId, axisId, svg, location, categories, axisLabel, axesLabelFont, axisTickStyle, plotDimensions, margin, setAxisRangeFor, setOriginalAxisRangeFor) {
+    switch (location) {
+        case AxisLocation.Top:
+        case AxisLocation.Bottom:
+            return addOrdinalStringXAxis(chartId, axisId, svg, location, categories, axisLabel, axesLabelFont, axisTickStyle, plotDimensions, margin, setAxisRangeFor, setOriginalAxisRangeFor);
+        case AxisLocation.Left:
+        case AxisLocation.Right:
+            return addOrdinalStringYAxis(chartId, axisId, svg, location, categories, axisLabel, axesLabelFont, axisTickStyle, plotDimensions, margin, setAxisRangeFor, setOriginalAxisRangeFor);
+    }
+}
+/**
+ * Adds a category axis representing the x-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
+ */
+function addOrdinalStringXAxis(chartId, axisId, svg, location, categories, axisLabel, axesLabelFont, axisTickStyle, plotDimensions, margin, setAxisRangeFor, setOriginalAxisRangeFor) {
+    const scale = d3.scaleBand()
+        .domain(categories)
+        .range([0, plotDimensions.width]);
+    const categorySize = scale.bandwidth();
+    // create and add the axes
+    const generator = location === AxisLocation.Bottom ? d3.axisBottom(scale) : d3.axisTop(scale);
+    const clipPathId = setClipPath(chartId, axisId, svg, location, plotDimensions, margin);
+    const selection = svg
+        .append('g')
+        .attr('id', `x-axis-selection-${chartId}-${axisId}`)
+        .attr("clip-path", `url(#${clipPathId})`)
+        .classed('x-axis', true)
+        .attr('transform', `translate(${margin.left}, ${yTranslation(location, plotDimensions, margin)})`)
+        .call(generator);
+    // rotate the tick-labels by the specified amount (in degrees)
+    let maxTickLabelHeight = 0;
+    const { font, rotation } = axisTickStyle;
+    selection
+        .selectAll("text")
+        .style("text-anchor", "end")
+        .each(function () {
+        const degrees = location === AxisLocation.Bottom ? -rotation : rotation;
+        const radians = degrees * Math.PI / 180;
+        const { width, height, x, y } = this.getBBox();
+        const xOrigin = x + width;
+        const yOrigin = location === AxisLocation.Bottom ? y + height / 2 : y + height / 2;
+        d3.select(this)
+            .attr("transform", () => `translate(${width * Math.cos(radians) / 2}, 0) rotate(${degrees}, ${xOrigin}, ${yOrigin})`);
+        const newHeight = Math.abs(width * Math.sin(radians));
+        if (newHeight > maxTickLabelHeight) {
+            maxTickLabelHeight = newHeight;
+        }
+    });
+    svg
+        .append('text')
+        .attr('id', labelIdFor(chartId, location))
+        .style('text-anchor', 'middle')
+        // when the axis is at the top, want the label to hang from the top (y=0) of the plot
+        .attr('dominant-baseline', location === AxisLocation.Top ? "hanging" : "baseline")
+        .attr('font-size', font.size)
+        .attr('fill', font.color)
+        .attr('font-family', font.family)
+        .attr('font-weight', font.weight)
+        .text(axisLabel);
+    const axis = { axisId, selection, location, scale, generator, categorySize, update: () => categorySize };
+    return Object.assign(Object.assign({}, axis), { update: (range, originalRange, plotDimensions, margin) => {
+            const categorySize = updateOrdinalStringXAxis(chartId, axis, svg, location, categories, range, axesLabelFont, plotDimensions, margin);
+            setAxisRangeFor(axisId, range);
+            setOriginalAxisRangeFor(axisId, originalRange);
+            return categorySize;
+        } });
+}
+/**
+ * Adds a category axis representing 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
+ */
+function addOrdinalStringYAxis(chartId, axisId, svg, location, categories, axisLabel, axesLabelFont, axisTickStyle, plotDimensions, margin, setAxisRangeFor, setOriginalAxisRangeFor) {
+    const scale = d3.scaleBand()
+        .domain(categories)
+        .range([0, plotDimensions.height]);
+    const categorySize = scale.bandwidth();
+    // create and add the axes
+    const generator = location === AxisLocation.Left ? d3.axisLeft(scale) : d3.axisRight(scale);
+    const selection = svg
+        .append('g')
+        .attr('id', `y-axis-selection-${chartId}`)
+        .attr('class', 'y-axis')
+        .attr('transform', `translate(${xTranslation(location, plotDimensions, margin)}, ${margin.top})`)
+        .call(generator);
+    // rotate the tick-labels by the specified amount (in degrees)
+    const { font, rotation } = axisTickStyle;
+    selection
+        .selectAll("text")
+        .style("text-anchor", "end")
+        .each(function () {
+        const degrees = location === AxisLocation.Left ? -rotation : rotation;
+        const { width, height, x, y } = this.getBBox();
+        const xTranslation = location === AxisLocation.Left ? 0 : width;
+        const xOrigin = x + width;
+        const yOrigin = location === AxisLocation.Left ? y + height / 2 : y + height / 2;
+        d3.select(this)
+            .attr("transform", () => `translate(${xTranslation}, 0) rotate(${degrees}, ${xOrigin}, ${yOrigin})`);
+    });
+    svg
+        .append('text')
+        .attr('id', labelIdFor(chartId, location))
+        .attr('text-anchor', 'middle')
+        .attr('font-size', font.size)
+        .attr('fill', font.color)
+        .attr('font-family', font.family)
+        .attr('font-weight', font.weight)
+        .attr('transform', `translate(${ordinalLabelXTranslation(location, plotDimensions, margin, axesLabelFont)}, ${ordinalLabelYTranslation(location, plotDimensions, margin)}) rotate(-90)`)
+        .text(axisLabel);
+    const axis = { axisId, selection, location, scale, generator, categorySize, update: () => categorySize };
+    return Object.assign(Object.assign({}, axis), { update: (range, originalRange, plotDimensions, margin) => {
+            const categorySize = updateOrdinalStringYAxis(chartId, axis, svg, location, categories, range, axesLabelFont, plotDimensions, margin);
+            setAxisRangeFor(axisId, range);
+            setOriginalAxisRangeFor(axisId, originalRange);
+            return categorySize;
+        } });
+}
+/**
+ * Updates the category axis representing the x-axis, calculates and returns the
+ * number of pixels for each category on the x-axis.
+ * @param chartId The unique ID of the chart to which this axis belongs
+ * @param axis The category axis to be updated
+ * @param svg The SVG selection (d3)
+ * @param location The location of the axis
+ * @param names An array holding the category names
+ * @param axesLabelFont The font for the axis label
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margin
+ * @param range The range of the axis (e.g., start and end) in pixels
+ * @param axesLabelFont The font for the axis label
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margin
+ * adjust the axis label location when needed
+ * @return The number of pixels for each category
+ */
+function updateOrdinalStringXAxis(chartId, axis, svg, location, names, // domain (categories)
+range, // range (pixels)
+axesLabelFont, plotDimensions, margin) {
+    const updatedRange = AxisInterval.from(Math.min(range.start, 0), Math.max(range.end, plotDimensions.width));
+    axis.scale = axis.scale
+        .domain(names)
+        .range(updatedRange.asTuple());
+    axis.categorySize = axis.scale.bandwidth();
+    const clipPathId = setClipPath(chartId, axis.axisId, svg, location, plotDimensions, margin);
+    axis.selection = axis.selection
+        .attr('transform', `translate(${margin.left}, ${yTranslation(location, plotDimensions, margin)})`)
+        .attr("clip-path", `url(#${clipPathId})`)
+        .call(axis.generator);
+    const xLabelTranslation = ordinalLabelXTranslation(location, plotDimensions, margin, axesLabelFont);
+    const yLabelTranslation = ordinalLabelYTranslation(location, plotDimensions, margin);
+    svg
+        .select(`#${labelIdFor(chartId, location)}`)
+        .attr('transform', `translate(${xLabelTranslation}, ${yLabelTranslation})`);
+    return axis.categorySize;
+}
+/**
+ * Updates the category axis representing the y-axis, calculates and returns the
+ * number of pixels for each category on the y-axis.
+ * @param chartId The unique ID of the chart to which this axis belongs
+ * @param axis The category axis to be updated
+ * @param svg The SVG selection (d3)
+ * @param location The location of the axis
+ * @param names An array holding the category names
+ * @param range The range of the axis (e.g. start and end)
+ * @param axesLabelFont The font for the axis label
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margin
+ * @param axesLabelFont The font for the axis label
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margin
+ * @return The number of pixels for each category
+ */
+function updateOrdinalStringYAxis(chartId, axis, svg, location, names, // domain
+range, // range
+axesLabelFont, plotDimensions, margin) {
+    const updatedRange = AxisInterval.from(Math.min(range.start, 0), Math.max(range.end, plotDimensions.height));
+    axis.scale = axis.scale
+        .domain(names)
+        .range(updatedRange.asTuple());
+    axis.categorySize = axis.scale.bandwidth();
+    axis.selection = axis.selection
+        .attr('transform', `translate(${xTranslation(location, plotDimensions, margin)}, ${margin.top})`)
+        .call(axis.generator);
+    svg
+        .select(`#${labelIdFor(chartId, location)}`)
+        .attr('transform', `translate(${ordinalLabelXTranslation(location, plotDimensions, margin, axesLabelFont)}, ${ordinalLabelYTranslation(location, plotDimensions, margin)}) rotate(-90)`);
+    return axis.categorySize;
+}
+/**
+ * Calculates the number of pixels by which to translate the label in the x-direction for the axis.
+ * The calculation uses the dimensions and margins of the plot, the location of the
+ * axis, and the font for the label.
+ * @param location The axis location (i.e. top, bottom, left, right)
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The margins for the plot
+ * @param axesLabelFont The font for the axis label
+ * @return The number of pixels to translate the label in the x-direction
+ */
+function ordinalLabelXTranslation(location, plotDimensions, margin, axesLabelFont) {
+    switch (location) {
+        case AxisLocation.Left:
+        case AxisLocation.Right:
+            return location === AxisLocation.Left ?
+                axesLabelFont.size :
+                margin.left + plotDimensions.width + margin.right - axesLabelFont.size;
+        case AxisLocation.Top:
+        case AxisLocation.Bottom:
+            return (plotDimensions.width + margin.left + margin.right) / 2;
+    }
+}
+/**
+ * Calculates the number of pixels by which to translate the label in the y-direction the axis.
+ * The calculation uses the dimensions and margins of the plot, the location of the
+ * axis, and the font for the label.
+ * @param location The axis location (i.e. top, bottom, left, right)
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The margins for the plot
+ * @return The number of pixels to translate the label for the y-direction
+ */
+function ordinalLabelYTranslation(location, plotDimensions, margin) {
+    switch (location) {
+        case AxisLocation.Left:
+        case AxisLocation.Right:
+            return (margin.top + margin.bottom + plotDimensions.height) / 2;
+        case AxisLocation.Top:
+            return 0;
+        case AxisLocation.Bottom:
+            return margin.top + margin.bottom + plotDimensions.height;
+    }
+}
+/*
+    continuous numeric axes
+ */
+/**
+ * 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 function addContinuousNumericXAxis(chartId, axisId, svg, plotDimensions, location, scaleGenerator, domain, axesLabelFont, margin, axisLabel, setAxisRangeFor) {
+    const scale = scaleGenerator.domain(domain).range([0, plotDimensions.width]);
+    const selection = svg
+        .append('g')
+        .attr('transform', `translate(${margin.left}, ${yTranslation(location, plotDimensions, margin)})`);
+    svg
+        .append('text')
+        .attr('id', labelIdFor(chartId, location))
+        .style('text-anchor', 'middle')
+        // when the axis is at the top, want the label to hang from the top (y=0) of the plot
+        .style('dominant-baseline', location === AxisLocation.Top ? "hanging" : "baseline")
+        .style('font-size', axesLabelFont.size)
+        .style('fill', axesLabelFont.color)
+        .style('font-family', axesLabelFont.family)
+        .style('font-weight', axesLabelFont.weight)
+        .attr('transform', `translate(${margin.left + plotDimensions.width / 2}, ${continuousLabelYTranslation(location, plotDimensions, margin)})`)
+        .text(axisLabel);
+    const axis = {
+        axisId,
+        location,
+        selection,
+        scale,
+        generator: location === AxisLocation.Bottom ? d3.axisBottom(scale) : d3.axisTop(scale),
+        update: noop
+    };
+    return Object.assign(Object.assign({}, axis), { update: (domain, plotDimensions, margin) => {
+            updateLinearXAxis(domain, axisLabel, chartId, svg, axis, plotDimensions, margin, location);
+            setAxisRangeFor(axisId, domain);
+        } });
+}
+/**
+ * Updates the x-axis with the new domain and axis label
+ * @param domain The new (start, end) range of the axis
+ * @param label The new label for the axis
+ * @param chartId The ID of the chart
+ * @param svg The SVG selection of which the axis is a child node
+ * @param axis The x-axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margins for the border of main SVG group
+ * @param location The location of the axis (i.e. top, bottom, left, right)
+ */
+function updateLinearXAxis(domain, label, chartId, svg, axis, plotDimensions, margin, location) {
+    axis.scale.domain(domain.asTuple()).range([0, plotDimensions.width]);
+    axis.selection
+        .attr('transform', `translate(${margin.left}, ${yTranslation(location, plotDimensions, margin)})`)
+        .call(axis.generator);
+    svg
+        .select(`#${labelIdFor(chartId, location)}`)
+        .attr('transform', `translate(${margin.left + plotDimensions.width / 2}, ${continuousLabelYTranslation(location, plotDimensions, margin)})`)
+        .text(label);
+}
+/**
+ * The number of pixels to translate the x-axis label to the right
+ * @param location The location of the x-axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margins for the border of main SVG group
+ * @return The number of pixels to translate the x-axis label to the right
+ */
+function continuousLabelYTranslation(location, plotDimensions, margin) {
+    return location === AxisLocation.Bottom ? plotDimensions.height + margin.top + margin.bottom : 0;
+}
+/**
+ * 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 function addContinuousNumericYAxis(chartId, axisId, svg, plotDimensions, location, scaleGenerator, domain, axesLabelFont, margin, axisLabel, setAxisRangeFor) {
+    const scale = scaleGenerator
+        .domain(domain)
+        .range([Math.max(margin.bottom, plotDimensions.height), 0]);
+    const selection = svg
+        .append('g')
+        .attr('class', 'y-axis')
+        .attr('transform', `translate(${xTranslation(location, plotDimensions, margin)}, ${margin.top})`);
+    svg
+        .append('text')
+        .attr('id', labelIdFor(chartId, location))
+        .attr('text-anchor', 'start')
+        .attr('font-size', axesLabelFont.size)
+        .attr('fill', axesLabelFont.color)
+        .attr('font-family', axesLabelFont.family)
+        .attr('font-weight', axesLabelFont.weight)
+        .attr('transform', `translate(${continuousLabelXTranslation(location, plotDimensions, margin, axesLabelFont)}, ${margin.top + plotDimensions.height / 2}) rotate(-90)`)
+        .text(axisLabel);
+    const axis = {
+        axisId,
+        location,
+        selection,
+        scale,
+        generator: location === AxisLocation.Left ? d3.axisLeft(scale) : d3.axisRight(scale),
+        update: noop
+    };
+    return Object.assign(Object.assign({}, axis), { update: (domain, plotDimensions, margin) => {
+            updateLinearYAxis(domain, axisLabel, chartId, svg, axis, plotDimensions, margin, axesLabelFont, location);
+            setAxisRangeFor(axisId, domain);
+        } });
+}
+/**
+ * Updates the y-axis with the new domain and axis label
+ * @param domain The new (start, end) range of the axis
+ * @param label The new label for the axis
+ * @param chartId The ID of the chart
+ * @param svg The SVG selection of which the axis is a child node
+ * @param axis The y-axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margins for the border of main SVG group
+ * @param axesLabelFont The font for the axis label
+ * @param location The location of the axis (i.e. top, bottom, left, right)
+ */
+function updateLinearYAxis(domain, label, chartId, svg, axis, plotDimensions, margin, axesLabelFont, location) {
+    axis.scale.domain(domain.asTuple()).range([Math.max(margin.bottom, plotDimensions.height), 0]);
+    axis.selection
+        .attr('transform', `translate(${xTranslation(location, plotDimensions, margin)}, ${margin.top})`)
+        .call(axis.generator);
+    svg
+        .select(`#${labelIdFor(chartId, location)}`)
+        .attr('transform', `translate(${continuousLabelXTranslation(location, plotDimensions, margin, axesLabelFont)}, ${margin.top + plotDimensions.height / 2}) rotate(-90)`)
+        .text(label);
+}
+/**
+ * The number of pixels to translate the y-axis label down
+ * @param location The location of the y-axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margins for the border of main SVG group
+ * @param axesLabelFont The font for the axis label
+ * @return The number of pixels to translate the y-axis label down
+ */
+function continuousLabelXTranslation(location, plotDimensions, margin, axesLabelFont) {
+    return location === AxisLocation.Left ?
+        axesLabelFont.size :
+        margin.left + plotDimensions.width + margin.right - axesLabelFont.size;
+}
+/*
+    common axis functions
+ */
+/**
+ * Calculates the number of pixels by which to translate the x-axis.
+ * @param location The axis location (i.e. top, bottom, left, right)
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The margins for the plot
+ * @return The number of pixels to translate the x-axis
+ */
+function xTranslation(location, plotDimensions, margin) {
+    return location === AxisLocation.Left ? margin.left : margin.left + plotDimensions.width;
+}
+/**
+ * The number of pixels to translate the x-axis to the right
+ * @param location The location of the x-axis
+ * @param plotDimensions The dimensions of the plot
+ * @param margin The plot margins for the border of main SVG group
+ * @return The number of pixels to translate the y-axis to the down
+ */
+function yTranslation(location, plotDimensions, margin) {
+    return location === AxisLocation.Bottom ?
+        plotDimensions.height + margin.top :
+        margin.top;
+}
+/**
+ * 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 function labelIdFor(chartId, location) {
+    switch (location) {
+        case AxisLocation.Left:
+        case AxisLocation.Right:
+            return `stream-chart-y-axis-${location}-label-${chartId}`;
+        case AxisLocation.Top:
+        case AxisLocation.Bottom:
+            return `stream-chart-x-axis-${location}-label-${chartId}`;
+    }
+}
+// /**
+//  * todo this can be generalized to any continuous numeric axis, replace x with value
+//  * 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.
+//  * @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
+//  * @return The updated range and the new zoom factor
+//  */
+// // export function calculateZoomFor<AR extends BaseAxisRange>(
+// export function calculateZoomFor(
+//     transform: ZoomTransform,
+//     x: number,
+//     axis: ContinuousNumericAxis,
+//     range: ContinuousAxisRange,
+// ): ZoomResult<ContinuousAxisRange> {
+//     const time = axis.generator.scale<ScaleLinear<number, number>>().invert(x);
+//     return {
+//         range: range.scale(transform.k, time),
+//         zoomFactor: transform.k
+//     } as ZoomResult<ContinuousAxisRange>
+// }
+/**
+ * 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 function calculateConstrainedZoomFor(transform, x, axis, range, constraint) {
+    const domainValue = axis.generator.scale().invert(x);
+    return {
+        range: range.constrainedScale(transform.k, domainValue, constraint),
+        zoomFactor: transform.k
+    };
+}
+/**
+ * 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 function calculateOrdinalConstrainedZoomFor(transform, x, range, constraint) {
+    const updatedRange = range.constrainedScale(transform.k, x, constraint);
+    const k = range.original.equals(updatedRange.original) ? 1 : transform.k;
+    return {
+        range: updatedRange,
+        zoomFactor: k
+    };
+}
+/*
+    panning
+ */
+/**
+ * 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 function calculatePanFor(delta, axis, range, constrainToOriginalRange = false) {
+    const scale = axis.generator.scale();
+    const value = scale(range.current.start);
+    if (value !== undefined) {
+        const deltaValue = scale.invert(value + delta) - range.current.start;
+        const constraint = constrainToOriginalRange ?
+            range.original.asTuple() :
+            [-Infinity, Infinity];
+        return range.translate(-deltaValue, constraint);
+    }
+    return range;
+}
+export function calculateOrdinalPanFor(delta, range, plotDimensions, constrainToOriginalRange = false) {
+    const constraint = constrainToOriginalRange ?
+        range.original.asTuple() :
+        [-Infinity, Infinity];
+    // only allow panning if the plot dimensions (i.e. [0, width]) is in the current axis range
+    // todo deal with the fact that this could be a pan of the y-axis
+    if (range.current.start + delta > 0 || range.current.end + delta < plotDimensions.width) {
+        return range;
+    }
+    return range.translate(delta, constraint);
+}
+/*
+
+ */
+/**
+ * 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 function axesForSeriesGen(series, axisAssignments, axesState) {
+    return series.map(srs => srs.name)
+        // grab the x-axis assigned to the series, or use the default x-axis if not
+        // assignment has been made
+        .map(name => { var _a; return ((_a = axisAssignments.get(name)) === null || _a === void 0 ? void 0 : _a.xAxis) || axesState.axisDefaultId().getOrElse(""); })
+        // de-dup the array of axis IDs so that we don't end up applying the pan or zoom
+        // transformation more than once
+        .reduce((accum, axisId) => {
+        if (!accum.find(id => id === axisId)) {
+            accum.push(axisId);
+        }
+        return accum;
+    }, []);
+}
+/**
+ * Pans the axis range by the specified amount.
+ * @param delta The pan amount in the axis specified for the series
+ * @param axesForSeries The names of the axes of a dimension (x or y)
+ * @param axesState The state for the axes of a dimension
+ * @param ranges The current ranges for the axes of a dimension
+ * @param setAxisRange Function for setting the new time-range for a specific axis
+ * @param plotDimensions The current plot dimensions (width, height)
+ * @param margin The plot margin
+ * @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
+ */
+function panAxes(delta, axesForSeries, axesState, ranges, setAxisRange, plotDimensions, margin, constrainToOriginalRange = true) {
+    axesForSeries.forEach(axisId => {
+        axesState.axisFor(axisId).ifPresent((axis) => {
+            const currentRange = ranges.get(axisId);
+            if (currentRange) {
+                // calculate the change in the axis-range based on the pixel change from the drag event
+                const range = calculatePanFor(delta, axis, currentRange, constrainToOriginalRange);
+                // update the time-range for the axis
+                ranges.set(axisId, range);
+                setAxisRange(axisId, range.current);
+                // update the axis' time-range
+                axis.update(range.current.copy(), plotDimensions, margin);
+            }
+        });
+    });
+}
+/**
+ * Pans the axis range by the specified amount.
+ * @param delta The pan amount in the axis specified for the series
+ * @param axesForSeries The names of the axes of a dimension (x or y)
+ * @param axesState The state for the axes of a dimension
+ * @param ranges The current ranges for the axes of a dimension
+ * @param setAxisRange Function for setting the new time-range for a specific axis
+ * @param plotDimensions The current plot dimensions (width, height)
+ * @param margin The plot margin
+ * @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
+ */
+function ordinalPanAxes(delta, axesForSeries, axesState, ranges, setAxisRange, plotDimensions, margin, constrainToOriginalRange = false) {
+    axesForSeries.forEach(axisId => {
+        axesState.axisFor(axisId).ifPresent(axis => {
+            const currentRange = ranges.get(axisId);
+            if (currentRange && axis) {
+                // calculate the change in the axis-range based on the pixel change from the drag event
+                const range = calculateOrdinalPanFor(delta, currentRange, plotDimensions, constrainToOriginalRange);
+                // update the time-range for the axis
+                ranges.set(axisId, range);
+                setAxisRange(axisId, range.current);
+                // update the axis' time-range
+                axis.update(range.current, range.original, plotDimensions, margin);
+            }
+        });
+    });
+}
+/**
+ * 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 function panHandler(axesForSeries, margin, setAxisRangeFor, axesState, constrainToOriginalRange = false) {
+    /**
+     * Adjusts the time-range and updates the plot when the plot is dragged to the left or right
+     * @param deltaX The amount that the plot is dragged
+     * @param plotDimensions The dimensions of the plot
+     * @param series An array of series names
+     * @param ranges A map holding the axis ID and its associated time range
+     */
+    return (delta, plotDimensions, ranges) => {
+        // return (delta: number, plotDimensions: Dimensions, series: Array<string>, ranges: Map<string, ContinuousAxisRange>) => {
+        // run through the axis IDs, adjust their domain, and update the time-range set for that axis
+        panAxes(delta, axesForSeries, axesState, ranges, setAxisRangeFor, plotDimensions, margin, constrainToOriginalRange);
+        // hey, don't forget to update the plot with the new time-ranges in the code calling this... :)
+    };
+}
+/**
+ * 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 function ordinalPanHandler(axesForSeries, margin, setAxisRangeFor, axesState, constrainToOriginalRange = false) {
+    /**
+     * Adjusts the time-range and updates the plot when the plot is dragged to the left or right
+     * @param deltaX The amount that the plot is dragged
+     * @param plotDimensions The dimensions of the plot
+     * @param series An array of series names
+     * @param ranges A map holding the axis ID and its associated time range
+     */
+    return (delta, plotDimensions, series, ranges) => {
+        // run through the axis IDs, adjust their domain, and update the time-range set for that axis
+        ordinalPanAxes(delta, axesForSeries, axesState, ranges, setAxisRangeFor, plotDimensions, margin, constrainToOriginalRange);
+        // hey, don't forget to update the plot with the new ranges in the code calling this... :)
+    };
+}
+/**
+ * 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 function panHandler2D(xAxesForSeries, yAxesForSeries, margin, setAxisRange, xAxesState, yAxesState, constrainToOriginalRange = true) {
+    /**
+     * Adjusts the time-range and updates the plot when the plot is dragged to the left or right
+     * @param deltaX The amount that the plot is dragged
+     * @param plotDimensions The dimensions of the plot
+     * @param series An array of series names
+     * @param ranges A map holding the axis ID and its associated time range
+     */
+    return (deltaX, deltaY, plotDimensions, series, xRanges, yRanges) => {
+        // run through the x- and y-axes and update them by delta, within the original bounds
+        panAxes(deltaX, xAxesForSeries, xAxesState, xRanges, setAxisRange, plotDimensions, margin, constrainToOriginalRange);
+        panAxes(deltaY, yAxesForSeries, yAxesState, yRanges, setAxisRange, plotDimensions, margin, constrainToOriginalRange);
+        // hey, don't forget to update the plot with the new time-ranges in the code calling this... :)
+    };
+}
+/**
+ * Calculates the zoom for the specified axis and updates the axis and the axis ranges
+ * @param value The x- or y-coordinate of the mouse
+ * @param axisId
+ * @param margin The plot margin
+ * @param setRangeFor Function for setting the new time-range for a specific axis * @param scaleExtent The smallest and largest scale factors allowed
+ * @param axesState
+ * @param ranges A map associating axis IDs with axis ranges
+ * @param scaleExtent The smallest and largest scale factors allowed
+ * @param transform The d3 zoom transformation information
+ * @param plotDimensions The dimensions of the plot
+ */
+function calcZoomAndUpdate(value, axisId, margin, setRangeFor, axesState, ranges, scaleExtent, transform, plotDimensions) {
+    const [, zoomMax] = scaleExtent;
+    axesState.axisFor(axisId).ifPresent(axis => {
+        const range = ranges.get(axisId);
+        if (range && axis) {
+            // calculate the constraint for the zoom
+            const constraint = isFinite(zoomMax) ?
+                [range.original.start * zoomMax, range.original.end * zoomMax] :
+                [0, Infinity];
+            const zoom = calculateConstrainedZoomFor(transform, value, axis, range, constraint);
+            // update the axis range
+            ranges.set(axisId, zoom.range);
+            setRangeFor(axisId, zoom.range.current);
+            // update the axis' range
+            axis.update(zoom.range.current, plotDimensions, margin);
+        }
+    });
+}
+function calcOrdinalZoomAndUpdate(value, axisId, margin, setRangeFor, setOriginalRangeFor, axesState, ranges, scaleExtent, transform, plotDimensions) {
+    const [, zoomMax] = scaleExtent;
+    axesState.axisFor(axisId).ifPresent(axis => {
+        const range = ranges.get(axisId);
+        if (range && axis) {
+            // calculate the constraint for the zoom
+            // const [originalStart, originalEnd] = range.original
+            const constraint = isFinite(zoomMax) ?
+                [range.original.start * zoomMax, range.original.end * zoomMax] :
+                [range.original.start, range.original.end];
+            const zoom = calculateOrdinalConstrainedZoomFor(transform, value, range, constraint);
+            // update the axis range
+            ranges.set(axisId, zoom.range);
+            setRangeFor(axisId, zoom.range.current);
+            const origRange = AxisInterval.from(0, plotDimensions.width);
+            setOriginalRangeFor(axisId, origRange);
+            // update the axis' range
+            axis.update(zoom.range.current, origRange, plotDimensions, margin);
+        }
+    });
+}
+/**
+ * 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 function continuousAxisZoomHandler(axesForSeries, margin, setRangeFor, axesState, scaleExtent = [0, Infinity]) {
+    /**
+     * 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.
+     * @param transform The d3 zoom transformation information
+     * @param x The x-position of the mouse when the scroll wheel or gesture is used
+     * @param plotDimensions The dimensions of the plot
+     * @param ranges A map holding the axis ID and its associated time-range
+     */
+    return (transform, x, plotDimensions, ranges) => {
+        // run through the axis IDs, adjust their domain, and update the time-range set for that axis
+        axesForSeries.forEach(axisId => calcZoomAndUpdate(x, axisId, margin, setRangeFor, axesState, ranges, scaleExtent, transform, plotDimensions));
+        // hey, don't forget to update the plot with the new time-ranges in the code calling this... :)
+    };
+}
+/**
+ * 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 function ordinalAxisZoomHandler(axesForSeries, margin, setRangeFor, setOriginalRangeFor, axesState, scaleExtent = [0, Infinity]) {
+    /**
+     * 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.
+     * @param transform The d3 zoom transformation information
+     * @param x The x-position of the mouse when the scroll wheel or gesture is used
+     * @param plotDimensions The dimensions of the plot
+     * @param ranges A map holding the axis ID and its associated time-range
+     */
+    return (transform, x, plotDimensions, ranges) => {
+        // run through the axis IDs, adjust their domain, and update the time-range set for that axis
+        axesForSeries.forEach(axisId => calcOrdinalZoomAndUpdate(x, axisId, margin, setRangeFor, setOriginalRangeFor, axesState, ranges, scaleExtent, transform, plotDimensions));
+        // hey, don't forget to update the plot with the new time-ranges in the code calling this... :)
+    };
+}
+/**
+ * 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 function axesZoomHandler(xAxesForSeries, yAxesForSeries, margin, setRangeFor, xAxesState, yAxesState, scaleExtent) {
+    /**
+     * 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.
+     * @param transform The d3 zoom transformation information
+     * @param mousePosistion The position of the mouse when the scroll wheel or gesture is used
+     * @param plotDimensions The dimensions of the plot
+     * @param ranges A map holding the axis ID and its associated time-range
+     */
+    return (transform, mousePosition, plotDimensions, xRanges, yRanges) => {
+        // run through the axis IDs, adjust their domain, and update the time-range set for that axis
+        const [x, y] = mousePosition;
+        xAxesForSeries.forEach(id => calcZoomAndUpdate(x, id, margin, setRangeFor, xAxesState, xRanges, scaleExtent, transform, plotDimensions));
+        yAxesForSeries.forEach(id => calcZoomAndUpdate(y, id, margin, setRangeFor, yAxesState, yRanges, scaleExtent, transform, plotDimensions));
+        // hey, don't forget to update the plot with the new time-ranges in the code calling this... :)
+    };
+}
+/**
+ * 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 function continuousAxisRanges(axes) {
+    return continuousRange(axes);
+}
+/**
+ * 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 function ordinalAxisRanges(axes, originalRange) {
+    return ordinalRange(axes, originalRange);
+}
+/**
+ * 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 function continuousAxisIntervals(axes) {
+    return new Map(Array.from(axes.entries())
+        .map(([id, axis]) => {
+        const [start, end] = axis.scale.domain();
+        return [id, AxisInterval.from(start, end)];
+    }));
+}
+/**
+ * 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 function ordinalAxisIntervals(axes) {
+    return new Map(Array.from(axes.entries())
+        .map(([id, axis]) => {
+        const [start, end] = axis.scale.range();
+        return [id, { interval: AxisInterval.from(start, end), categories: axis.scale.domain() }];
+    }));
+}
+/**
+ * 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 function continuousRange(axes) {
+    return new Map(Array.from(axes.entries())
+        .map(([id, axis]) => {
+        const [start, end] = axis.scale.domain();
+        return [id, ContinuousAxisRange.from(start, end)];
+    }));
+}
+/**
+ * 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 function ordinalRange(axes, originalRange) {
+    return new Map(Array.from(axes.entries())
+        .map(([id, _]) => [id, OrdinalAxisRange.from(originalRange.start, originalRange.end)]));
+}
+//# sourceMappingURL=axes.js.map