@oracle/oraclejet-preact 20.1.4 → 20.1.5

package/es/ReferenceLineArea-53129f72.js

@@ -1,586 +0,0 @@
-/* @oracle/oraclejet-preact: undefined */
-import { jsx, Fragment, jsxs } from 'preact/jsx-runtime';
-import { styles } from './PRIVATE_PlotArea/themes/PlotAreaStyles.css.js';
-import { styles as styles$1 } from './hooks/PRIVATE_useVisDnd/themes/VisDndStyles.css.js';
-import { c as classNames } from './classNames-4e12b00d.js';
-import { u as useColorScheme } from './useColorScheme-c4f6caab.js';
-import { k as isNonCurvedLine, l as getLineAreaSegments, m as getCmdPoints } from './utils-24c54d43.js';
-import { g as getCmdsForLine, f as fixCoord, c as curveThroughPoints } from './lineUtils-87255164.js';
-import { styles as styles$2 } from './PRIVATE_Chart/themes/ChartStyles.css.js';
-import { a as dvtVars } from './themeContract.css-1ffed3bf.js';
-import { u as useUser } from './useUser-06d34d19.js';
-
-function PlotArea({ color, availSpace, cursor, dragOverStyle }) {
-    const dragClass = [];
-    switch (dragOverStyle) {
-        case 'accept':
-            dragClass.push(styles$1.dndDragOverSvgStyle);
-            break;
-        case 'reject':
-            dragClass.push(styles$1.dndRejectedStyle);
-            dragClass.push(styles.plotAreaStyle);
-            break;
-        case 'none':
-            dragClass.push(styles.plotAreaStyle);
-            break;
-    }
-    return (jsx(Fragment, { children: jsx("rect", { ...availSpace, className: classNames(dragClass), style: { fill: dragOverStyle === 'accept' ? undefined : color, cursor } }) }));
-}
-
-function getXAxisLineProps(availSpace, axisPosition, axisLine) {
-    return {
-        x1: axisPosition === 'right' ? availSpace.x + availSpace.width : availSpace.x,
-        x2: axisPosition === 'left' ? availSpace.x : availSpace.x + availSpace.width,
-        y1: axisPosition === 'bottom' ? availSpace.y + availSpace.height : availSpace.y,
-        y2: axisPosition === 'top' ? availSpace.y : availSpace.y + availSpace.height,
-        stroke: axisLine?.lineColor,
-        strokeWidth: axisLine?.lineWidth
-    };
-}
-function getYAxisLineProps(availSpace, axisPosition, isRtl, axisLine) {
-    let x1, x2, y1, y2;
-    if (axisPosition === 'bottom') {
-        x1 = isRtl ? availSpace.x + availSpace.width : availSpace.x;
-        x2 = isRtl ? availSpace.x + availSpace.width : availSpace.x;
-        y1 = availSpace.y;
-        y2 = availSpace.y + availSpace.height;
-    }
-    else {
-        x1 = availSpace.x;
-        x2 = availSpace.x + availSpace.width;
-        y1 = isRtl ? availSpace.y : availSpace.y + availSpace.height;
-        y2 = isRtl ? availSpace.y : availSpace.y + availSpace.height;
-    }
-    return {
-        x1,
-        x2,
-        y1,
-        y2,
-        stroke: axisLine?.lineColor,
-        strokeWidth: axisLine?.lineWidth
-    };
-}
-function getY2AxisLineProps(availSpace, axisPosition, isRtl, axisLine) {
-    let x1, x2, y1, y2;
-    if (axisPosition === 'bottom') {
-        x1 = isRtl ? availSpace.x : availSpace.x + availSpace.width;
-        x2 = isRtl ? availSpace.x : availSpace.x + availSpace.width;
-        y1 = availSpace.y;
-        y2 = availSpace.y + availSpace.height;
-    }
-    else {
-        x1 = availSpace.x;
-        x2 = availSpace.x + availSpace.width;
-        y1 = isRtl ? availSpace.y + availSpace.height : availSpace.y;
-        y2 = isRtl ? availSpace.y + availSpace.height : availSpace.y;
-    }
-    return {
-        x1,
-        x2,
-        y1,
-        y2,
-        stroke: axisLine?.lineColor,
-        strokeWidth: axisLine?.lineWidth
-    };
-}
-function getBaseLineCoords(isHoriz, coord, range1, range2, isYAxis) {
-    let x1, x2, y1, y2;
-    if (isHoriz) {
-        if (isYAxis) {
-            x1 = coord;
-            x2 = coord;
-            y1 = range1;
-            y2 = range2;
-        }
-        else {
-            x1 = range1;
-            x2 = range2;
-            y1 = coord;
-            y2 = coord;
-        }
-    }
-    else {
-        if (isYAxis) {
-            x1 = range1;
-            x2 = range2;
-            y1 = coord;
-            y2 = coord;
-        }
-        else {
-            x1 = coord;
-            x2 = coord;
-            y1 = range1;
-            y2 = range2;
-        }
-    }
-    return { x1, x2, y1, y2 };
-}
-
-const TICK_DEFAULT = {
-    yMajorTick: {
-        isRendered: true
-    },
-    y2MajorTick: {
-        isRendered: false
-    },
-    yMinorTick: {
-        isRendered: false
-    },
-    y2MinorTick: {
-        isRendered: false
-    },
-    xMajorTick: {
-        isRendered: false
-    },
-    xMinorTick: {
-        isRendered: false
-    }
-};
-function Gridlines({ plotArea, yMinorTicks, xMinorTicks, xScale, yScale, y2Scale, isLog, yTicks, y2Ticks, xTicks, yAxisPosition, isDataXAxis, xAxis, yAxis, y2Axis, availSpace, xAxisPosition, isRtl, hasAxisLine, y2MinorTicks, isSplitDualY }) {
-    const isHoriz = yAxisPosition === 'top' || yAxisPosition === 'bottom';
-    const hasY2 = !!y2Axis?.isRendered;
-    const [x1, x2] = xScale.range();
-    const [y1, y2] = hasY2 ? y2Scale.range() : yScale.range();
-    const xAxisBaselineStyle = {
-        stroke: isDataXAxis ? plotArea?.xMajorTick?.baselineColor : plotArea?.xMajorTick?.lineColor,
-        strokeWidth: isDataXAxis ? plotArea?.xMajorTick?.baselineWidth : plotArea?.xMajorTick?.lineWidth
-    };
-    const yAxisBaselineStyle = {
-        stroke: plotArea?.yMajorTick?.baselineColor ?? plotArea?.yMajorTick?.lineColor,
-        strokeWidth: plotArea?.yMajorTick?.baselineWidth ?? plotArea?.yMajorTick?.lineWidth
-    };
-    const y2AxisBaselineStyle = {
-        stroke: plotArea?.y2MajorTick?.baselineColor,
-        strokeWidth: plotArea?.y2MajorTick?.baselineWidth
-    };
-    let yLinesPath = '';
-    let y2LinesPath = '';
-    let xLinesPath = '';
-    let yMinorPath = '';
-    let xMinorPath = '';
-    let y2MinorPath = '';
-    const yMajorTick = { ...TICK_DEFAULT.yMajorTick, ...plotArea?.yMajorTick };
-    const yMinorTick = { ...TICK_DEFAULT.yMinorTick, ...plotArea?.yMinorTick };
-    const y2MinorTick = { ...TICK_DEFAULT.y2MinorTick, ...plotArea?.y2MinorTick };
-    const xMinorTick = { ...TICK_DEFAULT.xMinorTick, ...plotArea?.xMinorTick };
-    const xMajorTick = { ...TICK_DEFAULT.xMajorTick, ...plotArea?.xMajorTick };
-    const y2MajorTick = {
-        ...TICK_DEFAULT.y2MajorTick,
-        isRendered: isSplitDualY,
-        ...plotArea?.y2MajorTick
-    };
-    const isYMinorRendered = yMinorTick?.isRendered === true || isLog;
-    const isY2MinorRendered = y2MinorTick?.isRendered === true || isLog;
-    const isXMajorRendered = xMajorTick?.isRendered === true ||
-        (plotArea?.xMajorTick?.isRendered == undefined && isDataXAxis);
-    const xAxisLineProps = getXAxisLineProps(availSpace, xAxisPosition);
-    const xAxisLineStyle = {
-        stroke: plotArea?.xAxisLine?.lineColor,
-        strokeWidth: plotArea?.xAxisLine?.lineWidth
-    };
-    const yAxisLineStyle = {
-        stroke: plotArea?.yAxisLine?.lineColor,
-        strokeWidth: plotArea?.yAxisLine?.lineWidth
-    };
-    const y2AxisLineStyle = {
-        stroke: plotArea?.y2AxisLine?.lineColor,
-        strokeWidth: plotArea?.y2AxisLine?.lineWidth
-    };
-    const yBaseLine = yAxis?.scale === 'log' ? yTicks[0] : 0;
-    const yBaseLineCoords = getBaseLineCoords(isHoriz, yScale.transform(yBaseLine), x1, x2, true);
-    const y2BaseLine = y2Axis?.scale === 'log' ? y2Ticks[0] : 0;
-    const y2BaseLineCoords = getBaseLineCoords(isHoriz, y2Scale.transform(y2BaseLine), x1, x2, true);
-    const xBaseLine = xAxis?.scale === 'log' ? xTicks[0] : 0;
-    const xBaseLineCoords = getBaseLineCoords(isHoriz, xScale.transform(xBaseLine), y1, y2, false);
-    if (yMajorTick?.isRendered) {
-        for (let i = 0; i < yTicks.length; i++) {
-            if (yTicks[i] === 0) {
-                // zero is skipped for majorTick. baseline is rendered at 0
-                continue;
-            }
-            let y = yScale.transform(yTicks[i]);
-            // last grid line get's clipped due to plot area clippath. Slightly adjust
-            // coord so that it's not clipped.
-            if (i === yTicks.length - 1) {
-                y += isHoriz ? -1 : 1;
-            }
-            yLinesPath += isHoriz ? `M${y},${x1}L${y},${x2}` : `M${x1},${y}L${x2},${y}`;
-        }
-    }
-    if (y2MajorTick?.isRendered) {
-        for (let i = 0; i < y2Ticks.length; i++) {
-            if (yTicks[i] === 0) {
-                // zero is skipped for majorTick. baseline is rendered at 0
-                continue;
-            }
-            let y = y2Scale.transform(y2Ticks[i]);
-            // last grid line get's clipped due to plot area clippath. Slightly adjust
-            // coord so that it's not clipped.
-            if (i === y2Ticks.length - 1) {
-                y += isHoriz ? -1 : 1;
-            }
-            y2LinesPath += isHoriz ? `M${y},${x1}L${y},${x2}` : `M${x1},${y}L${x2},${y}`;
-        }
-    }
-    if (isXMajorRendered) {
-        if (xTicks) {
-            for (let i = 0; i < xTicks.length; i++) {
-                const x = xScale.transform(xTicks[i]);
-                xLinesPath += isHoriz ? `M${y1},${x}L${y2},${x}` : `M${x},${y1}L${x},${y2}`;
-            }
-        }
-    }
-    if (isYMinorRendered || isY2MinorRendered) {
-        for (let i = 0; i < yMinorTicks.length; i++) {
-            const y = yScale.transform(yMinorTicks[i]);
-            yMinorPath += isHoriz ? `M${y},${x1}L${y},${x2}` : `M${x1},${y}L${x2},${y}`;
-        }
-    }
-    if (isY2MinorRendered) {
-        for (let i = 0; i < y2MinorTicks.length; i++) {
-            const y = y2Scale.transform(y2MinorTicks[i]);
-            y2MinorPath += isHoriz ? `M${y},${x1}L${y},${x2}` : `M${x1},${y}L${x2},${y}`;
-        }
-    }
-    if (xMinorTick.isRendered && xMinorTicks) {
-        for (let i = 0; i < xMinorTicks.length; i++) {
-            const x = xScale.transform(xMinorTicks[i]);
-            xMinorPath += isHoriz ? `M${y1},${x}L${y2},${x}` : `M${x},${y1}L${x},${y2}`;
-        }
-    }
-    const colorScheme = useColorScheme();
-    let splitCoords = undefined;
-    if (isSplitDualY) {
-        const ySplitCoord = !isHoriz ? yTicks[0] : yTicks[yTicks.length - 1];
-        const y2SplitCoord = !isHoriz ? y2Ticks[y2Ticks.length - 1] : y2Ticks[0];
-        const splitCoord = (yScale.transform(ySplitCoord) + y2Scale.transform(y2SplitCoord)) / 2;
-        splitCoords = getBaseLineCoords(isHoriz, splitCoord + (isHoriz ? -1 : 1) * 0.5, x1, x2, true);
-    }
-    /*
-    Render order:
-    1. Gridlines: y and y2 are same because of aligned ticks.
-        a. majorTick: y -> x
-        b. minorTick y -> x
-    2. Axislines → Baselines, with each in the order: y2 → y → x
-  */
-    return (jsxs(Fragment, { children: [yMajorTick?.isRendered && (jsx("path", { d: yLinesPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.majorTickLineStyles,
-                    yMajorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    yMajorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: hasY2 ? y2MajorTick.lineColor : yMajorTick.lineColor,
-                    strokeWidth: hasY2 ? y2MajorTick.lineWidth : yMajorTick.lineWidth
-                } })), y2MajorTick?.isRendered && (jsx("path", { d: y2LinesPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.majorTickLineStyles,
-                    y2MajorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    y2MajorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: y2MajorTick.lineColor,
-                    strokeWidth: y2MajorTick.lineWidth
-                } })), isXMajorRendered && (jsx("path", { d: xLinesPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.majorTickLineStyles,
-                    xMajorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    xMajorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: xMajorTick.lineColor,
-                    strokeWidth: xMajorTick.lineWidth
-                } })), isYMinorRendered && (jsx("path", { d: yMinorPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.minorTickLineStyles,
-                    colorScheme === 'light'
-                        ? styles.lightMinorTickLineStroke
-                        : styles.darkMinorTickLineStroke,
-                    yMinorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    yMinorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: hasY2 ? y2MinorTick.lineColor : yMinorTick?.lineColor,
-                    strokeWidth: hasY2 ? y2MinorTick.lineWidth : yMinorTick?.lineWidth
-                } })), isY2MinorRendered && (jsx("path", { d: y2MinorPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.minorTickLineStyles,
-                    colorScheme === 'light'
-                        ? styles.lightMinorTickLineStroke
-                        : styles.darkMinorTickLineStroke,
-                    y2MinorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    y2MinorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: y2MinorTick?.lineColor,
-                    strokeWidth: y2MinorTick?.lineWidth
-                } })), xMinorTick.isRendered && (jsx("path", { d: xMinorPath, className: classNames([
-                    styles.noPointerEvents,
-                    styles.minorTickLineStyles,
-                    colorScheme === 'light'
-                        ? styles.lightMinorTickLineStroke
-                        : styles.darkMinorTickLineStroke,
-                    xMinorTick?.lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    xMinorTick?.lineStyle === 'dotted' ? styles.dottedLine : undefined
-                ]), style: {
-                    stroke: xMinorTick?.lineColor,
-                    strokeWidth: xMinorTick?.lineWidth
-                } })), ((isDataXAxis && plotArea?.y2AxisLine?.isRendered !== false) ||
-                plotArea?.y2AxisLine?.isRendered) && (jsx("line", { ...getY2AxisLineProps(availSpace, xAxisPosition, isRtl), class: styles.axisLineStyle, style: y2AxisLineStyle })), ((isDataXAxis && plotArea?.yAxisLine?.isRendered !== false) ||
-                plotArea?.yAxisLine?.isRendered) && (jsx("line", { ...getYAxisLineProps(availSpace, xAxisPosition, isRtl), class: styles.axisLineStyle, style: yAxisLineStyle })), hasAxisLine && plotArea?.xAxisLine?.isRendered !== false && (jsx("line", { ...xAxisLineProps, class: styles.axisLineStyle, style: xAxisLineStyle })), y2MajorTick?.isRendered && (jsx("line", { ...y2BaseLineCoords, class: styles.axisLineStyle, style: y2AxisBaselineStyle })), yMajorTick?.isRendered && (jsx("line", { ...yBaseLineCoords, className: classNames([
-                    styles.axisLineStyle,
-                    yMajorTick.baselineStyle === 'dashed' || yMajorTick.lineStyle === 'dashed'
-                        ? styles.dashedLine
-                        : undefined,
-                    yMajorTick.baselineStyle === 'dotted' || yMajorTick.lineStyle === 'dotted'
-                        ? styles.dottedLine
-                        : undefined
-                ]), style: yAxisBaselineStyle })), xMajorTick?.isRendered && (jsx("line", { ...xBaseLineCoords, class: styles.axisLineStyle, style: xAxisBaselineStyle })), isSplitDualY && splitCoords ? (jsx("line", { ...splitCoords, class: styles.axisLineStyle, style: yAxisBaselineStyle })) : null] }));
-}
-
-function LineSeries({ color, isHorizontal, lineType = 'straight', lineStyle, lineWidth = 3, lineColor, isHighlighted, lineSegmentCoords, seriesIndex, groupWidth, isRtl, timeAxisType, plotAreaClipPathId, variant = 'normal', accessibleLabel, activeId, id }) {
-    const style = {
-        stroke: lineColor || color,
-        strokeDasharray: lineStyle === 'dotted' ? 3 : lineStyle === 'dashed' ? 6 : undefined,
-        strokeWidth: lineWidth,
-        fill: 'none'
-    };
-    return variant === 'refLine' ? (jsx(Fragment, { children: lineSegmentCoords.map((value) => {
-            if (value.length < 2) {
-                return;
-            }
-            const cmds = getCmdsForLine(value, lineType, isHorizontal, groupWidth, isRtl, timeAxisType);
-            return isNonCurvedLine(lineType) ? (jsx("g", { "clip-path": `url(#${plotAreaClipPathId})`, "aria-label": accessibleLabel, id: activeId, children: cmds.split(' ').map((cmd) => (jsx("polyline", { points: cmd, style: style, "shape-rendering": 'crispEdges', class: classNames([
-                        isHighlighted ? undefined : styles$2.dimmed,
-                        variant === 'refLine' ? styles$2.refLine : undefined
-                    ]), "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refLine' }))) })) : lineType === 'curved' ? (jsx("path", { "aria-label": accessibleLabel, id: activeId, d: cmds, "clip-path": `url(#${plotAreaClipPathId})`, style: style, "shape-rendering": 'crispEdges', class: classNames([
-                    isHighlighted ? undefined : styles$2.dimmed,
-                    variant === 'refLine' ? styles$2.refLine : undefined
-                ]), "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refLine' })) : undefined;
-        }) })) : (jsx(Fragment, { children: lineSegmentCoords.map((value) => {
-            if (value.length < 2) {
-                return;
-            }
-            const cmds = getCmdsForLine(value, lineType, isHorizontal, groupWidth, isRtl, timeAxisType);
-            return isNonCurvedLine(lineType) ? (jsx("g", { "clip-path": `url(#${plotAreaClipPathId})`, "aria-label": accessibleLabel, id: activeId, children: cmds.split(' ').map((cmd) => (jsx("polyline", { points: cmd, style: style, class: classNames([isHighlighted ? undefined : styles$2.dimmed]), "data-oj-private-series-index": seriesIndex, "data-oj-private-object": 'line' }))) })) : lineType === 'curved' ? (jsx("path", { d: cmds, "aria-label": accessibleLabel, id: activeId, "clip-path": `url(#${plotAreaClipPathId})`, style: style, class: classNames([isHighlighted ? undefined : styles$2.dimmed]), "data-oj-private-series-index": seriesIndex, "data-oj-private-object": 'line' })) : undefined;
-        }) }));
-}
-
-function VariedLineRefObj({ id, xScale, yScale, items, orientation = 'horizontal', lineColor, lineWidth, groups = [], xStartIndex = 0, xEndIndex = 0, isLog = false, seriesIndex = 0, lineStyle, accessibleLabel, activeId }) {
-    if (!items || items.length === 0 || !xScale || !yScale) {
-        return null;
-    }
-    const isHorizontal = orientation === 'horizontal';
-    const valueCoords = getLineAreaSegments(yScale, xScale, items.map((item) => item.value), xStartIndex, xEndIndex, isLog, groups, 0, (_, gIndex) => ({ id: `${id}_${gIndex}`, ...items[gIndex] }));
-    return (jsx(LineSeries, { id: id, activeId: activeId, accessibleLabel: accessibleLabel, lineStyle: lineStyle, lineType: "straight", lineWidth: lineWidth, color: lineColor, variant: "refLine", lineSegmentCoords: valueCoords, isHorizontal: isHorizontal, isHighlighted: false, seriesIndex: seriesIndex }));
-}
-
-/**
- * @license
- * Copyright (c) 2008 %CURRENT_YEAR%, Oracle and/or its affiliates.
- * Licensed under The Universal Permissive License (UPL), Version 1.0
- * as shown at https://oss.oracle.com/licenses/upl/
- * @ignore
- */
-/**
- * Returns a straight area path command.
- * @param {array} lineSegmentCoords Polyline top points array.
- * @param {array} bottomCoords Polyline bottom points array.
- * @return {string} Straight area path commands.
- */
-function getNonCurveAreaPath(lineSegmentCoords, bottomCoords, areaType, isHoriz, isRtl, groupWidth, timeAxisType) {
-    // Create the path data string
-    const highCoords = getCmdPoints(lineSegmentCoords, areaType, isHoriz, isRtl, groupWidth, timeAxisType, true).split(',');
-    const lowCoords = getCmdPoints(bottomCoords, areaType, isHoriz, isRtl, groupWidth, timeAxisType, true).split(',');
-    // Reverse the lowArray
-    const revLowArray = [];
-    for (let i = 0; i < lowCoords.length; i += 2) {
-        revLowArray.unshift(lowCoords[i], lowCoords[i + 1]);
-    }
-    return revLowArray.concat(highCoords);
-}
-/**
- * Returns a curved area path command, based on cubic hermite splines, that goes through the points in the points array.
- * @param {array} lineSegmentCoords Polyline top points array.
- * @param {array} bottomCoords Polyline bottom points array.
- * @param {boolean} connectWithLine Whether the first point is reached using lineTo. Otherwise, moveTo is used.
- * @param {string} splineType The spline type.
- * @return {string} Curved area path commands.
- */
-function getCurveAreaPath(lineSegmentCoords, bottomCoords, connectWithLine, splineType, isBottomSegmentCurved) {
-    let pathData;
-    if (lineSegmentCoords.length > 0) {
-        if (!isBottomSegmentCurved) {
-            pathData =
-                curveThroughPoints(lineSegmentCoords, connectWithLine, splineType) +
-                    [...bottomCoords]
-                        .reverse()
-                        .map((bottomCoord) => {
-                        return `L ${bottomCoord[0]} ${bottomCoord[1]}`;
-                    })
-                        .join(' ') +
-                    'Z';
-        }
-        else {
-            pathData =
-                curveThroughPoints(lineSegmentCoords, false, splineType) +
-                    ' ' +
-                    curveThroughPoints([...bottomCoords].reverse(), true, splineType) +
-                    ' Z';
-        }
-    }
-    return pathData;
-}
-function getCmdsForArea(lineSegmentCoords, bottomCoords, areaType, isHoriz, isBottomSegmentCurved, isRtl, groupWidth, timeAxisType) {
-    const l = lineSegmentCoords.map((coord) => fixCoord(coord, isHoriz));
-    const b = bottomCoords.map((coord) => fixCoord(coord, isHoriz));
-    if (areaType === 'curved') {
-        return getCurveAreaPath(l, b, false, isHoriz ? 'mh' : 'mv', isBottomSegmentCurved);
-    }
-    else {
-        return getNonCurveAreaPath(lineSegmentCoords, bottomCoords, areaType, isHoriz, isRtl, groupWidth, timeAxisType).join(' ');
-    }
-}
-
-function AreaSeries({ yScale, lineType = 'straight', color, isHorizontal, isLog, areaColorOpacity, lineSegments, bottomCoords, isHighlighted, isBottomSegmentCurved, seriesIndex, groupWidth, isRtl, timeAxisType, plotAreaClipPathId, variant = 'normal', accessibleLabel, activeId, id }) {
-    const style = {
-        fill: color,
-        opacity: isHighlighted
-            ? areaColorOpacity
-            : `calc(${dvtVars.dimmedOpacity} * ${areaColorOpacity})`
-    };
-    return (jsx("g", { "clip-path": `url(#${plotAreaClipPathId})`, "aria-label": accessibleLabel, id: activeId, children: lineSegments.map((lineSegment) => {
-            if (lineSegment.length < 2) {
-                return;
-            }
-            let baseCoords;
-            if (bottomCoords) {
-                // custom bottom coords. eg: top of last series in stacked area
-                baseCoords = bottomCoords;
-            }
-            else {
-                // TODO: make this more generic when we support apps setting baseline
-                // for log assume domain min is the baseline, otherwise use 0 baseline
-                const baselineCoord = yScale.transform(isLog ? yScale.domain()[0] : 0);
-                baseCoords = [
-                    [lineSegment[0][0], baselineCoord],
-                    [lineSegment[lineSegment.length - 1][0], baselineCoord]
-                ];
-            }
-            const cmds = getCmdsForArea(lineSegment, baseCoords, lineType, isHorizontal, isBottomSegmentCurved, isRtl, groupWidth, timeAxisType);
-            return variant === 'refArea' ? (isNonCurvedLine(lineType) ? (jsx("polygon", { points: cmds, style: style, "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refArea', className: styles$2.refArea })) : lineType === 'curved' ? (jsx("path", { d: cmds, style: style, "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refArea', className: styles$2.refArea })) : undefined) : isNonCurvedLine(lineType) ? (jsx("polygon", { points: cmds, style: style, "data-oj-private-series-index": seriesIndex, "data-oj-private-object": 'area' })) : lineType === 'curved' ? (jsx("path", { d: cmds, style: style, "data-oj-private-series-index": seriesIndex, "data-oj-private-object": 'area' })) : undefined;
-        }) }));
-}
-
-function VariedAreaRefObj({ id, xScale, yScale, items, orientation = 'horizontal', areaColor, areaOpacity, groups = [], xStartIndex = 0, xEndIndex = 0, isLog = false, seriesIndex = 0, activeId, accessibleLabel }) {
-    const { direction } = useUser();
-    const isHorizontal = orientation === 'horizontal';
-    const isRtl = direction === 'rtl';
-    if (!items || items.length === 0 || !xScale || !yScale) {
-        return null;
-    }
-    // Get coordinates for top and bottom of the area
-    const topCoords = getLineAreaSegments(yScale, xScale, items.map((item) => item.high), xStartIndex, xEndIndex, isLog, groups, 0, (_, gIndex) => ({ id: `${id}_top_${gIndex}`, ...items[gIndex] }));
-    const bottomCoords = getLineAreaSegments(yScale, xScale, items.map((item) => item.low), xStartIndex, xEndIndex, isLog, groups, 0, (_, gIndex) => ({ id: `${id}_bottom_${gIndex}`, ...items[gIndex] })).flat();
-    return (jsx(Fragment, { children: jsx(AreaSeries, { id: id, activeId: activeId, accessibleLabel: accessibleLabel, yScale: yScale, lineType: "straight", color: areaColor, variant: "refArea", isHorizontal: isHorizontal, areaColorOpacity: areaOpacity, isBottomSegmentCurved: false, bottomCoords: bottomCoords, lineSegments: topCoords, isLog: isLog, isHighlighted: false, seriesIndex: seriesIndex, isRtl: isRtl }) }));
-}
-
-function ConstantLineRefObj({ id, xScale, yScale, value, orientation = 'horizontal', lineColor, lineWidth, lineStyle, accessibleLabel, isXRef, activeId }) {
-    if (value === undefined || !xScale || !yScale) {
-        return null;
-    }
-    const targetScale = isXRef ? xScale : yScale;
-    const spanningScale = isXRef ? yScale : xScale;
-    const pos = targetScale.transform(value);
-    const [span1, span2] = spanningScale.range();
-    if (typeof pos !== 'number' || isNaN(pos)) {
-        return null;
-    }
-    // Determine horizontal or vertical line
-    const isHorizontalLine = (orientation === 'vertical' && !isXRef) || (orientation === 'horizontal' && isXRef);
-    const path = isHorizontalLine
-        ? `M${span1},${pos}L${span2},${pos}` // Horizontal line
-        : `M${pos},${span1}L${pos},${span2}`; // Vertical line
-    const contrastPath = isHorizontalLine
-        ? `M${span1},${pos + 1}L${span2},${pos + 1}` // Horizontal line
-        : `M${pos + 1},${span1}L${pos + 1},${span2}`; // Vertical line
-    return (jsxs("g", { children: [jsx("path", { id: activeId, d: path, "aria-label": accessibleLabel, "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refLine', role: "img", "shape-rendering": "crispEdges", className: classNames([
-                    lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    lineStyle === 'dotted' ? styles.dottedLine : undefined,
-                    styles$2.refLine
-                ]), style: {
-                    stroke: lineColor,
-                    strokeWidth: lineWidth
-                } }), jsx("path", { id: activeId, d: contrastPath, "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refLine', "shape-rendering": "crispEdges", className: classNames([
-                    lineStyle === 'dashed' ? styles.dashedLine : undefined,
-                    lineStyle === 'dotted' ? styles.dottedLine : undefined,
-                    styles$2.contrastBorder
-                ]), style: {
-                    stroke: lineColor,
-                    strokeWidth: lineWidth
-                } })] }));
-}
-
-function ConstantAreaRefObj({ id, xScale, yScale, low, high, orientation = 'horizontal', areaColor, accessibleLabel, isXRef, activeId }) {
-    if (!xScale || !yScale) {
-        return null;
-    }
-    const targetScale = isXRef ? xScale : yScale;
-    const spanningScale = isXRef ? yScale : xScale;
-    const domain = targetScale.domain();
-    const clampedLow = low !== undefined
-        ? Math.max(low, Math.min(domain[0], domain[1]))
-        : Math.min(domain[0], domain[1]);
-    const clampedHigh = high !== undefined
-        ? Math.min(high, Math.max(domain[0], domain[1]))
-        : Math.max(domain[0], domain[1]);
-    const pos1 = targetScale.transform(clampedLow);
-    const pos2 = targetScale.transform(clampedHigh);
-    const [span1, span2] = spanningScale.range();
-    if (typeof pos1 !== 'number' || typeof pos2 !== 'number' || isNaN(pos1) || isNaN(pos2)) {
-        return null;
-    }
-    // Determine if we're drawing horizontal or vertical area
-    const isHorizontalArea = (orientation === 'vertical' && !isXRef) || (orientation === 'horizontal' && isXRef);
-    const rectProps = isHorizontalArea
-        ? {
-            x: Math.min(span1, span2),
-            y: Math.min(pos1, pos2),
-            width: Math.abs(span2 - span1),
-            height: Math.max(1, Math.abs(pos2 - pos1))
-        }
-        : {
-            x: Math.min(pos1, pos2),
-            y: Math.min(span1, span2),
-            width: Math.max(1, Math.abs(pos2 - pos1)),
-            height: Math.abs(span2 - span1)
-        };
-    return (jsx("rect", { ...rectProps, id: activeId, "aria-label": accessibleLabel, "data-oj-private-ref-obj-id": id, "data-oj-private-object": 'refArea', role: "img", className: classNames([styles$2.refArea]), style: {
-            fill: areaColor
-        } }));
-}
-
-function ReferenceLineArea(props) {
-    const { id, type = 'line', color, lineWidth, orientation = 'horizontal', areaOpacity, items, xScale, yScale, groups = [], xStartIndex = 0, xEndIndex = 0, isLog = false, seriesIndex = 0, isXRef, lineStyle, activeId, accessibleLabel } = props;
-    const hasItems = items && items.length > 0;
-    //if required scales are missing
-    if (!xScale || !yScale || (hasItems && isXRef)) {
-        return null;
-    }
-    const isArea = type === 'area';
-    // Which component to use based on whether it has items (varied) or single values (constant)
-    if (hasItems) {
-        if (isArea) {
-            return (jsx(VariedAreaRefObj, { id: id, xScale: xScale, yScale: yScale, items: items, orientation: orientation, areaColor: color, areaOpacity: areaOpacity, groups: groups, xStartIndex: xStartIndex, accessibleLabel: accessibleLabel, activeId: activeId, xEndIndex: xEndIndex, isLog: isLog, seriesIndex: seriesIndex }));
-        }
-        else {
-            return (jsx(VariedLineRefObj, { id: id, xScale: xScale, yScale: yScale, items: items, orientation: orientation, lineColor: color, lineStyle: lineStyle, lineWidth: lineWidth, groups: groups, xStartIndex: xStartIndex, xEndIndex: xEndIndex, accessibleLabel: accessibleLabel, activeId: activeId, isLog: isLog, seriesIndex: seriesIndex }));
-        }
-    }
-    else {
-        if (isArea) {
-            return (jsx(ConstantAreaRefObj, { id: id, xScale: xScale, yScale: yScale, low: props.low, high: props.high, orientation: orientation, areaColor: color, accessibleLabel: accessibleLabel, activeId: activeId, isXRef: isXRef }));
-        }
-        else {
-            return (jsx(ConstantLineRefObj, { id: id, xScale: xScale, yScale: yScale, value: props.value, orientation: orientation, lineColor: color, lineStyle: lineStyle, lineWidth: lineWidth, accessibleLabel: accessibleLabel, activeId: activeId, isXRef: isXRef }));
-        }
-    }
-}
-
-export { AreaSeries as A, Gridlines as G, LineSeries as L, PlotArea as P, ReferenceLineArea as R };
-//# sourceMappingURL=ReferenceLineArea-53129f72.js.map