@oracle/oraclejet-preact 20.0.3 → 20.1.0

package/es/ProgressCircle-bce87dad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressCircle-bce87dad.js","sources":["../../src/UNSAFE_ProgressCircle/ProgressCircle.tsx"],"sourcesContent":["/**\n * @license\n * Copyright (c) %FIRST_YEAR% %CURRENT_YEAR%, Oracle and/or its affiliates.\n * Licensed under The Universal Permissive License (UPL), Version 1.0\n * as shown at https://oss.oracle.com/licenses/upl/\n * @ignore\n */\nimport type { ComponentChildren, ComponentProps, JSX } from 'preact';\nimport { classNames } from '#utils/UNSAFE_classNames';\nimport { CircleWrapper, CircleInner } from '#PRIVATE_Meter';\nimport { getProgressClipPath } from '#utils/PRIVATE_meterUtils';\nimport { useTranslationBundle } from '#hooks/UNSAFE_useTranslationBundle';\nimport type { BundleType } from '#resources/nls/bundle';\nimport type { UnpackSignals } from '@oracle/oraclejet-internal-utilities/attributeUtils';\nimport { useComponentTheme } from '#hooks/UNSAFE_useComponentTheme';\nimport {\n  ProgressCircleStyles,\n  ProgressCircleVariantOptions\n} from './themes/ProgressCircleStyles.css';\nimport { ProgressCircleRedwoodTheme } from './themes/redwood/ProgressCircleTheme';\ntype ariaPropsType = ComponentProps<typeof CircleWrapper>['ariaProps'];\ntype IntrinsicProps = Pick<UnpackSignals<JSX.IntrinsicElements['div']>, 'class'>;\n\ntype ProgressCircleProps = IntrinsicProps & {\n  /**\n   * Specifies the id of the progress circle.  If the progress circle is being used to describe the loading process of a particular region\n   * of the page, then the aria-describedby attribute of the region must point to the id of the ProgressCircle\n   */\n  id?: UnpackSignals<JSX.IntrinsicElements['div']>['id'];\n  /**\n   * The value of the progress circle.  If the value is 'indeterminate', an indeterminate progress circle will be shown.\n   */\n  value?: 'indeterminate' | number;\n\n  /**\n   * The maximum value of the progress circle.\n   */\n  max?: number;\n  /**\n   * The size of the progress circle. The default value of this property is theme driven.\n   */\n  size?: 'sm' | 'md' | 'lg';\n\n  /**\n   * A label to be used for accessibility purposes when value is set to 'indeterminate'. This will be used for the aria-valuetext of the DOM element.\n   */\n  'aria-valuetext'?: string;\n  /**\n   * Specifies the children.\n   */\n  children?: ComponentChildren;\n  /**\n   * A label to be used for accessibility purposes. This will be used for the aria-label of the DOM element.\n   */\n  'aria-label'?: string;\n\n  /**\n   * One or more ids (separated by spaces) of elements that label the progress bar. This will be used for the aria-labelledby of the DOM element.\n   */\n  'aria-labelledby'?: string;\n};\n/**\n * A progress circle allows the user to visualize the progression of an extended computer operation.\n */\nexport function ProgressCircle({ value, max, ...otherProps }: ProgressCircleProps) {\n  return value === 'indeterminate' ? (\n    <IndeterminateProgressCircle {...otherProps}></IndeterminateProgressCircle>\n  ) : (\n    <DeterminateProgressCircle value={value} max={max} {...otherProps}></DeterminateProgressCircle>\n  );\n}\n\ntype IndeterminateProps = Omit<ProgressCircleProps, 'value' | 'max'>;\n\nconst IndeterminateProgressCircle = ({ id, size, ...props }: IndeterminateProps) => {\n  const {\n    classes,\n    styles: { indeterminate }\n  } = useComponentTheme<ProgressCircleVariantOptions, ProgressCircleStyles>(\n    ProgressCircleRedwoodTheme,\n    {\n      size,\n      type: 'indeterminate'\n    }\n  );\n\n  const translations = useTranslationBundle<BundleType>('@oracle/oraclejet-preact');\n  const ariaProps: ariaPropsType = {\n    'aria-valuetext': props['aria-valuetext'] || translations.progressIndeterminate(),\n    'aria-label': props['aria-label'],\n    'aria-labelledby': props['aria-labelledby'],\n    role: 'progressbar'\n  };\n  return (\n    <CircleWrapper id={id} ariaProps={ariaProps} class={classes}>\n      <CircleInner class={indeterminate} />\n    </CircleWrapper>\n  );\n};\n\ntype DeterminateProps = Omit<ProgressCircleProps, 'aria-valuetext'> & {\n  value?: number;\n};\n\nconst DeterminateProgressCircle = ({\n  value = 0,\n  max = 100,\n  id,\n  size,\n  ...props\n}: DeterminateProps) => {\n  const {\n    classes,\n    styles: { determinate, track, valueStyle }\n  } = useComponentTheme<ProgressCircleVariantOptions, ProgressCircleStyles>(\n    ProgressCircleRedwoodTheme,\n    {\n      size\n    }\n  );\n\n  const percentage = Math.min(Math.max(0, value / max), 1);\n  const clipPath = getProgressClipPath(percentage);\n\n  const ariaProps: ariaPropsType = {};\n  ariaProps['aria-valuemin'] = value != null ? 0 : undefined;\n  ariaProps['aria-valuemax'] = value != null ? max : undefined;\n  ariaProps['aria-valuenow'] = value != null ? value : undefined;\n  ariaProps['role'] = 'progressbar';\n  (ariaProps['aria-label'] = props['aria-label']),\n    (ariaProps['aria-labelledby'] = props['aria-labelledby']);\n  return (\n    <CircleWrapper id={id} ariaProps={ariaProps} class={classes}>\n      <CircleInner class={classNames([determinate, track])} />\n      <CircleInner class={classNames([determinate, valueStyle])} clipPath={clipPath} />\n    </CircleWrapper>\n  );\n};\n"],"names":["_jsx","_jsxs"],"mappings":"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"}

package/es/RadioItem-94909632.js

@@ -11,7 +11,7 @@ import { u as useId } from './useId-03dbfdf0.js';
 import './TabbableModeContext-7d8ad946.js';
 import { u as useTabbableMode } from './useTabbableMode-090ed4b5.js';
 import { u as useInteractionStyle } from './useInteractionStyle-99e32c23.js';
-import { u as useTranslationBundle } from './useTranslationBundle-4822502f.js';
+import { u as useTranslationBundle } from './useTranslationBundle-bc6e0896.js';
 import { u as useCheckboxRadioContext } from './CheckboxRadioContext-fe425383.js';
 import { S as SvgCheck } from './Check-ac39fe00.js';
 import { S as SvgRadioButtonOff } from './RadioButtonOff-e005ab12.js';
@@ -22,16 +22,16 @@ import './UserAssistanceStyles.styles.css';
 import './UNSAFE_UserAssistance/themes/redwood/UserAssistanceBaseTheme.styles.css';
 import './UNSAFE_UserAssistance/themes/redwood/UserAssistanceVariants.css.js';
 import 'preact/hooks';
-import './Flex-03129963.js';
+import './Flex-fc483125.js';
 import './MessageBannerStyles.styles.css';
 import './UNSAFE_MessageBanner/themes/redwood/MessageBannerBaseTheme.styles.css';
 import './UNSAFE_MessageBanner/themes/redwood/MessageBannerVariants.css.js';
 import 'preact';
-import './LayerHost-7931b424.js';
+import './LayerHost-3cf255a6.js';
 import './TooltipContentStyles.styles.css';
 import './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentBaseTheme.styles.css';
 import './hooks/UNSAFE_useTooltip/themes/redwood/TooltipContentVariants.css.js';
-import './tooltipUtils-af0abd38.js';
+import './tooltipUtils-90fb656f.js';
 import './IconStyle.styles.css';
 import { g as getClientHints } from './clientHints-a42b510c.js';
 import './IconButton-7f91481c.js';
@@ -44,12 +44,12 @@ import './ComponentMessageStyles.styles.css';
 import './UNSAFE_ComponentMessage/themes/redwood/ComponentMessageBaseTheme.styles.css';
 import './UNSAFE_ComponentMessage/themes/redwood/ComponentMessageVariants.css.js';
 import './InputGroupContext-20bdbd6e.js';
-import './Popup-992b6c27.js';
+import './Popup-22d51095.js';
 import './UNSAFE_Separator/themes/SeparatorStyles.css.js';
 import './LabelStyles.styles.css';
 import './UNSAFE_Label/themes/redwood/LabelBaseTheme.styles.css';
 import './UNSAFE_Label/themes/redwood/LabelVariants.css.js';
-import { I as IconUserAssistance } from './IconUserAssistance-61978211.js';
+import { I as IconUserAssistance } from './IconUserAssistance-6abc7837.js';
 import { radioIconVars } from './UNSAFE_RadioItem/themes/RadioIconContract.css.js';
 import { RadioIconRedwoodTheme } from './UNSAFE_RadioItem/themes/redwood/RadioIconTheme.js';
 import { RadioRedwoodTheme } from './UNSAFE_RadioItem/themes/redwood/RadioTheme.js';

package/es/ReadonlyTextFieldInput-106ce959.js

@@ -8,7 +8,7 @@ import './FormFieldContext-47ca0c20.js';
 import { u as useFormFieldContext } from './useFormFieldContext-daf7a676.js';
 import './TabbableModeContext-7d8ad946.js';
 import { u as useTabbableMode } from './useTabbableMode-090ed4b5.js';
-import { u as useTranslationBundle } from './useTranslationBundle-4822502f.js';
+import { u as useTranslationBundle } from './useTranslationBundle-bc6e0896.js';
 import { c as classNames } from './classNames-4e12b00d.js';
 import { t as textInterpolations } from './textAlign-ad252afa.js';
 import { m as mergeInterpolations } from './mergeInterpolations-30cd9a69.js';

package/es/ReferenceLineArea-cc72b070.js

@@ -0,0 +1,586 @@
+/* @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-67245285.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-e543b73c.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-cc72b070.js.map