@sproutsocial/seeds-react-data-viz 0.7.32 → 0.15.0

package/dist/esm/chunk-LC3HGWDD.js

@@ -0,0 +1,968 @@
+// src/components/ColorBox/ColorBox.tsx
+import { css } from "styled-components";
+import { Box } from "@sproutsocial/seeds-react-box";
+
+// ../seeds-react-theme-provider/dist/index.mjs
+import "react";
+import {
+  ThemeProvider as BaseThemeProvider,
+  createGlobalStyle
+} from "styled-components";
+import { theme } from "@sproutsocial/seeds-react-theme";
+import { jsx, jsxs } from "react/jsx-runtime";
+var GlobalTokenStyles = createGlobalStyle`
+  :root {
+    --color-container-bg-ai-generated: radial-gradient(
+      circle at bottom left,
+      color-mix(in srgb, #205bc3, transparent 80%) 0%,
+      color-mix(in srgb, #6f5ed3, transparent 80%) 61%,
+      color-mix(in srgb, #f282f5, transparent 80%) 100%
+    ), #f3f4f4;
+  }
+`;
+
+// src/components/ColorBox/ColorBox.tsx
+import "@sproutsocial/seeds-react-theme";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ColorBox = ({
+  display = "inline-block",
+  height = "16px",
+  width = "16px",
+  minWidth = width,
+  borderRadius = "400",
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx2(
+    Box,
+    {
+      ...props,
+      display,
+      height,
+      width,
+      minWidth,
+      borderRadius,
+      css: css`
+          cursor: ${(props2) => props2?.onClick ? "pointer" : "default"};
+        `
+    }
+  );
+};
+
+// src/components/ColorBox/DatavizColorBox.tsx
+import styled from "styled-components";
+import { theme as theme2 } from "@sproutsocial/seeds-react-theme";
+var DatavizColorBox = styled(ColorBox).attrs(
+  ({ colorIndex }) => ({
+    style: {
+      background: getDatavizColor(colorIndex),
+      opacity: getDatavizOpacity(colorIndex)
+    }
+  })
+)``;
+var getDatavizColor = (colorIndex) => theme2.colors.DATAVIZ_COLORS_LIST[colorIndex % theme2.colors.DATAVIZ_COLORS_LIST.length] || "";
+var getDatavizOpacity = (colorIndex) => {
+  const opacitySteps = [1, 0.6, 0.4, 0.2];
+  const opacityStep = Math.floor(colorIndex / theme2.colors.DATAVIZ_COLORS_LIST.length) % opacitySteps.length;
+  return opacitySteps[opacityStep];
+};
+var getDatavizColorWithAlpha = (colorIndex) => {
+  const color = getDatavizColor(colorIndex);
+  const opacity = getDatavizOpacity(colorIndex);
+  if (opacity < 0 || opacity > 1) {
+    return color;
+  }
+  return `${color}${Math.floor(opacity * 255).toString(16).padStart(2, "0")}`;
+};
+
+// src/components/ColorBox/NetworkColorBox.tsx
+import NETWORK_COLORS from "@sproutsocial/seeds-networkcolor";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var NetworkColorBox = ({
+  networkColor,
+  ...props
+}) => {
+  return /* @__PURE__ */ jsx3(ColorBox, { ...props, bg: NETWORK_COLORS[networkColor] });
+};
+
+// src/components/ChartLegend/components/ChartLegendLabel.tsx
+import styled2 from "styled-components";
+import { memo } from "react";
+import { Box as Box2 } from "@sproutsocial/seeds-react-box";
+import { Text } from "@sproutsocial/seeds-react-text";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var StyledBox = styled2(Box2)`
+  list-style: none;
+  display: flex;
+  align-items: center;
+  gap: ${({ theme: theme6 }) => theme6.space[300]};
+`;
+var ChartLegendLabel = memo(
+  function ChartLegendLabel2({
+    children,
+    color = "#CCC",
+    containerBoxProps = {}
+  }) {
+    return /* @__PURE__ */ jsxs2(StyledBox, { ...containerBoxProps, children: [
+      /* @__PURE__ */ jsx4(ColorBox, { bg: color }),
+      /* @__PURE__ */ jsx4(Text, { as: "div", fontSize: 200, color: "text.subtext", children })
+    ] });
+  }
+);
+
+// src/components/ChartLegend/ChartLegend.tsx
+import { memo as memo2 } from "react";
+import { Box as Box3 } from "@sproutsocial/seeds-react-box";
+import { theme as theme3 } from "@sproutsocial/seeds-react-theme";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ChartLegend = memo2(function ChartLegend2({
+  legendLabels,
+  containerBoxProps = {},
+  stacked = false
+}) {
+  return /* @__PURE__ */ jsx5(
+    Box3,
+    {
+      as: "ul",
+      "aria-hidden": "true",
+      display: "flex",
+      justifyContent: "center",
+      flexDirection: stacked ? "column" : "row",
+      flexWrap: "wrap",
+      columnGap: 450,
+      rowGap: 200,
+      m: 0,
+      p: 0,
+      ...containerBoxProps,
+      children: legendLabels.map(({ color, content }, index) => /* @__PURE__ */ jsx5(
+        ChartLegendLabel,
+        {
+          color: color || theme3.colors.DATAVIZ_COLORS_LIST[index],
+          containerBoxProps: { as: "li" },
+          children: content
+        },
+        `chart-legend-label-${index}`
+      ))
+    }
+  );
+});
+
+// src/components/ChartTooltip/ChartTooltip.tsx
+import { memo as memo3 } from "react";
+import styled3 from "styled-components";
+import { Box as Box4 } from "@sproutsocial/seeds-react-box";
+import { jsx as jsx6 } from "react/jsx-runtime";
+var StyledBox2 = styled3(Box4)`
+  .Icon,
+  .logo {
+    stroke: none;
+  }
+`;
+var ChartTooltip = memo3(function ChartTooltip2({
+  children
+}) {
+  return /* @__PURE__ */ jsx6(
+    StyledBox2,
+    {
+      bg: "container.background.base",
+      boxShadow: "medium",
+      border: 500,
+      borderColor: "container.border.base",
+      borderRadius: 500,
+      p: 400,
+      minWidth: 285,
+      children: /* @__PURE__ */ jsx6(Box4, { display: "flex", flexDirection: "column", gap: 350, children })
+    }
+  );
+});
+
+// src/components/ChartTooltip/components/ChartTooltipFooter.tsx
+import { memo as memo4 } from "react";
+import { Box as Box5 } from "@sproutsocial/seeds-react-box";
+import { jsx as jsx7 } from "react/jsx-runtime";
+var ChartTooltipFooter = memo4(
+  function ChartTooltipFooter2({ children }) {
+    return /* @__PURE__ */ jsx7(
+      Box5,
+      {
+        borderTop: 500,
+        borderColor: "container.border.base",
+        mx: -400,
+        mb: -200,
+        px: 400,
+        pt: 350,
+        children
+      }
+    );
+  }
+);
+
+// src/components/ChartTooltip/components/ChartTooltipHeader.tsx
+import { memo as memo5 } from "react";
+import { Box as Box6 } from "@sproutsocial/seeds-react-box";
+import { jsx as jsx8 } from "react/jsx-runtime";
+var ChartTooltipHeader = memo5(
+  function ChartTooltipHeader2({ children }) {
+    return /* @__PURE__ */ jsx8(
+      Box6,
+      {
+        borderBottom: 500,
+        borderColor: "container.border.base",
+        mx: -400,
+        mt: -200,
+        px: 400,
+        pb: 350,
+        children
+      }
+    );
+  }
+);
+
+// src/components/ChartTooltip/components/ChartTooltipPortal.tsx
+import { memo as memo6, useState, useRef, useEffect } from "react";
+import { createPortal } from "react-dom";
+var generateChartTooltipPortalId = (chartId) => `highcharts-custom-tooltip-${chartId}`;
+var ChartTooltipPortal = memo6(
+  function ChartTooltipPortal2({
+    chart,
+    renderContent
+  }) {
+    const isInitialized = useRef(false);
+    const [node, setNode] = useState(null);
+    const [context, setContext] = useState(null);
+    useEffect(() => {
+      const formatter = function() {
+        if (!isInitialized.current) {
+          isInitialized.current = true;
+          chart.tooltip.refresh.apply(chart.tooltip, [this.point]);
+          chart.tooltip.hide(0);
+        }
+        setContext(this);
+        return `<div id="${generateChartTooltipPortalId(
+          chart.index
+        )}" role='tooltip'></div>`;
+      };
+      chart.update({ tooltip: { formatter } });
+    }, [chart]);
+    useEffect(() => {
+      if (context?.series?.chart?.tooltip) {
+        const tooltip = context.series.chart.tooltip;
+        const textElement = tooltip.label.text.element;
+        tooltip.label.box.attr({
+          height: textElement.offsetHeight,
+          width: textElement.offsetWidth
+        });
+        setNode(
+          document.getElementById(generateChartTooltipPortalId(chart.index))
+        );
+      }
+    }, [context, chart.index]);
+    return node && context ? createPortal(renderContent(context), node) : null;
+  }
+);
+
+// src/components/ChartTable/ChartTable.tsx
+import { memo as memo7 } from "react";
+import styled4 from "styled-components";
+import { Text as Text2 } from "@sproutsocial/seeds-react-text";
+import { Table as SeedsTable } from "@sproutsocial/seeds-react-table";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var StyledSeedsTable = styled4(SeedsTable)`
+  tbody tr:last-child {
+    border-bottom: none;
+  }
+  tr:last-child td,
+  tr:last-child th {
+    padding-bottom: 0;
+  }
+  tr:first-child td,
+  tr:first-child th {
+    padding-top: 0;
+  }
+  tr th {
+    padding-left: 0;
+  }
+  tr td:last-child {
+    padding-right: 0;
+  }
+`;
+var StyledSeedsTableRow = styled4(SeedsTable.TableRow)`
+  ${({ $isAppendedRow, theme: theme6 }) => $isAppendedRow ? `border-top: 2px solid ${theme6.colors.container.border.base}` : ""}
+`;
+var ChartTable = memo7(function ChartTable2({
+  rows
+}) {
+  if (!rows || rows.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx9(StyledSeedsTable, { children: /* @__PURE__ */ jsx9(SeedsTable.TableBody, { children: rows.map(({ cells, isAppendedRow }, rowIndex) => {
+    if (!cells || cells.length === 0) {
+      return null;
+    }
+    return /* @__PURE__ */ jsx9(
+      StyledSeedsTableRow,
+      {
+        $isAppendedRow: isAppendedRow,
+        children: cells.map(
+          ({ content, align = "left", colSpan = 1 }, cellIndex) => {
+            const uniqueIdentifier = `chart-tooltip-table-cell-${cellIndex}`;
+            return /* @__PURE__ */ jsx9(
+              SeedsTable.Cell,
+              {
+                id: uniqueIdentifier,
+                scope: cellIndex === 0 ? "row" : void 0,
+                align,
+                colSpan,
+                py: 200,
+                children: /* @__PURE__ */ jsx9(Text2.SmallBodyCopy, { as: "div", children: content })
+              },
+              uniqueIdentifier
+            );
+          }
+        )
+      },
+      `chart-tooltip-table-row-${rowIndex}`
+    );
+  }) }) });
+});
+
+// src/components/ChartTooltip/components/ChartTooltipTable.tsx
+import { memo as memo8 } from "react";
+import { jsx as jsx10 } from "react/jsx-runtime";
+var ChartTooltipTable = memo8(
+  function ChartTooltipTable2({ rows }) {
+    return /* @__PURE__ */ jsx10(ChartTable, { rows });
+  }
+);
+
+// src/components/ChartTooltip/components/ChartTooltipTitle.tsx
+import { memo as memo9 } from "react";
+import { Text as Text3 } from "@sproutsocial/seeds-react-text";
+import { jsx as jsx11 } from "react/jsx-runtime";
+var ChartTooltipTitle = memo9(
+  function ChartTooltipTitle2({ children }) {
+    return /* @__PURE__ */ jsx11(Text3.SmallSubHeadline, { as: "p", children });
+  }
+);
+
+// src/helpers/transformDataToSeries.ts
+var transformDataToSeries = ({
+  data
+}, type) => {
+  const hasCategoricalData = data.some(
+    (series) => series.points.some((point) => typeof point.x === "string")
+  );
+  return data.map((dataItem, dataIndex) => {
+    const points = dataItem.points || [];
+    const dataPoints = points.map((point, pointsIndex) => {
+      let enableMarker = false;
+      const isFirstPoint = pointsIndex === 0;
+      const isLastPoint = pointsIndex === points.length - 1;
+      const previousY = isFirstPoint ? null : points[pointsIndex - 1].y;
+      const nextY = isLastPoint ? null : points[pointsIndex + 1].y;
+      if (isFirstPoint && nextY === null) {
+        enableMarker = true;
+      } else if (isLastPoint && previousY === null) {
+        enableMarker = true;
+      } else if (previousY === null && nextY === null) {
+        enableMarker = true;
+      }
+      return {
+        x: hasCategoricalData ? pointsIndex : point.x,
+        y: point.y,
+        marker: {
+          enabled: enableMarker ? enableMarker : void 0,
+          symbol: enableMarker ? "circle" : void 0
+        },
+        // For categorical data, store the original category name
+        ...hasCategoricalData && { name: point.x }
+      };
+    });
+    return {
+      colorIndex: dataIndex,
+      data: dataPoints,
+      name: dataItem.name,
+      type
+    };
+  });
+};
+
+// src/helpers/transformTimeSeriesTooltipData.ts
+import { theme as theme4 } from "@sproutsocial/seeds-react-theme";
+var transformTimeSeriesTooltipData = ({
+  context,
+  data
+}) => {
+  return (context.series.chart.series || []).map((series, index) => {
+    const pointIndex = context.point.index;
+    const y = series?.points?.[pointIndex]?.y;
+    return {
+      color: data[index]?.styles?.color || theme4.colors.DATAVIZ_COLORS_LIST[index],
+      ...data[index]?.icon ? { icon: data[index]?.icon } : {},
+      name: series.name,
+      value: typeof y === "number" ? y : null
+    };
+  });
+};
+
+// src/helpers/yAxisLabelFormatter.ts
+import { formatDuration } from "@sproutsocial/seeds-react-duration";
+import { formatNumeral } from "@sproutsocial/seeds-react-numeral";
+var yAxisLabelFormatter = ({
+  numberLocale,
+  textLocale,
+  tickPositions,
+  value,
+  currency = "USD",
+  numberFormat = "decimal"
+}) => {
+  const numberValue = Number(value);
+  if (numberValue === 0) {
+    return formatNumeral({
+      locale: numberLocale,
+      number: numberValue
+    });
+  }
+  if (numberFormat === "duration") {
+    return formatDuration({
+      display: "narrow",
+      locale: textLocale,
+      milliseconds: numberValue
+    });
+  }
+  const maxValue = tickPositions && tickPositions.length > 0 ? tickPositions[tickPositions.length - 1] : void 0;
+  const abbreviate = typeof maxValue === "number" && maxValue > 9999 ? 1e3 : true;
+  return formatNumeral({
+    abbreviate,
+    currency,
+    format: numberFormat,
+    locale: numberLocale,
+    number: numberValue
+  });
+};
+
+// src/helpers/xAxisLabelFormatter.ts
+var getDatePartsInTimezone = (date, timezone) => {
+  const formatter = new Intl.DateTimeFormat("en-US", {
+    year: "numeric",
+    month: "numeric",
+    day: "numeric",
+    timeZone: timezone
+  });
+  const parts = formatter.formatToParts(date);
+  return {
+    day: parseInt(parts.find((p) => p.type === "day")?.value ?? "0", 10),
+    month: parseInt(parts.find((p) => p.type === "month")?.value ?? "0", 10),
+    year: parseInt(parts.find((p) => p.type === "year")?.value ?? "0", 10)
+  };
+};
+var xAxisLabelFormatter = ({
+  textLocale,
+  tickPositions = [],
+  unitName,
+  value,
+  // optional
+  timeFormat = "12",
+  timezone = "UTC"
+}) => {
+  if (typeof value === "string") {
+    return `<span>${value}</span>`;
+  }
+  const tickIndex = tickPositions.indexOf(value);
+  const isFirst = tickIndex === 0;
+  const previousValue = tickPositions[tickIndex - 1];
+  const valueDate = new Date(value);
+  const valueParts = getDatePartsInTimezone(valueDate, timezone);
+  const previousValueDate = previousValue ? new Date(previousValue) : void 0;
+  const previousValueParts = previousValueDate ? getDatePartsInTimezone(previousValueDate, timezone) : void 0;
+  let firstPartOptions = {};
+  let secondPartOptions = {};
+  switch (unitName) {
+    case "hour":
+      firstPartOptions = timeFormat === "24" ? { hour: "numeric", minute: "numeric", hour12: false } : { hour: "numeric" };
+      if (isFirst || valueParts.day !== previousValueParts?.day) {
+        secondPartOptions = { day: "numeric", month: "short" };
+      }
+      break;
+    case "day":
+    case "week":
+      firstPartOptions = { day: "numeric" };
+      if (isFirst || valueParts.month !== previousValueParts?.month) {
+        secondPartOptions = { month: "short" };
+      }
+      break;
+    case "month":
+      firstPartOptions = { month: "short" };
+      if (isFirst || valueParts.year !== previousValueParts?.year) {
+        secondPartOptions = { year: "numeric" };
+      }
+      break;
+    case "year":
+      firstPartOptions = { year: "numeric" };
+      break;
+    default:
+      firstPartOptions = {};
+      break;
+  }
+  const firstPart = new Intl.DateTimeFormat(textLocale, {
+    ...firstPartOptions,
+    timeZone: timezone
+  }).format(valueDate);
+  const secondPart = Object.keys(secondPartOptions).length > 0 ? new Intl.DateTimeFormat(textLocale, {
+    ...secondPartOptions,
+    timeZone: timezone
+  }).format(valueDate) : void 0;
+  return `<span>${firstPart}</span>${secondPart ? `<span>${secondPart}</span>` : ""}`;
+};
+
+// src/helpers/isHourlyTimeData.ts
+function isHourlyTimeData(data) {
+  if (!data.length) return false;
+  const xVals = data.flatMap((series) => series.points.map((p) => p.x));
+  if (!xVals.length) return false;
+  if (xVals.some((x) => typeof x === "string")) return false;
+  const dates = xVals.map((x) => {
+    const d = new Date(x);
+    return `${d.getUTCFullYear()}-${d.getUTCMonth()}-${d.getUTCDate()}`;
+  });
+  const uniqueDates = new Set(dates);
+  if (uniqueDates.size !== 1) return false;
+  return xVals.every((x) => {
+    const d = new Date(x);
+    const hour = d.getUTCHours();
+    const minutes = d.getUTCMinutes();
+    const seconds = d.getUTCSeconds();
+    return hour >= 0 && hour <= 23 && minutes === 0 && seconds === 0;
+  });
+}
+
+// src/helpers/isCategoricalHourData.ts
+function isCategoricalHourData(data) {
+  if (!data.length) return false;
+  const xVals = data.flatMap((series) => series.points.map((p) => p.x));
+  if (!xVals.length) return false;
+  if (xVals.some((x) => typeof x !== "string")) return false;
+  const hour12Pattern = /^\d{1,2} (AM|PM)$/;
+  const hour24Pattern = /^([01]?\d|2[0-3]):([0-5]\d)$/;
+  const stringValues = xVals;
+  const allMatch12Hour = stringValues.every((x) => hour12Pattern.test(x));
+  const allMatch24Hour = stringValues.every((x) => hour24Pattern.test(x));
+  return allMatch12Hour || allMatch24Hour;
+}
+
+// src/helpers/getStorybookRandomColor.ts
+var getStorybookRandomColor = () => {
+  const letters = "0123456789ABCDEF";
+  let color = "#";
+  for (let i = 0; i < 6; i++) {
+    color += letters[Math.floor(Math.random() * 16)];
+  }
+  return color;
+};
+
+// src/helpers/getStorybookCategoricalData.ts
+var getStorybookCategoricalData = ({
+  showNulls,
+  showNegativeValues,
+  numberOfSeries,
+  yAxisMax,
+  showCustomColors,
+  showDashedLines,
+  categoryType
+}) => {
+  const categoryOptions = {
+    hours: [
+      "12 AM",
+      "1 AM",
+      "2 AM",
+      "3 AM",
+      "4 AM",
+      "5 AM",
+      "6 AM",
+      "7 AM",
+      "8 AM",
+      "9 AM",
+      "10 AM",
+      "11 AM",
+      "12 PM",
+      "1 PM",
+      "2 PM",
+      "3 PM",
+      "4 PM",
+      "5 PM",
+      "6 PM",
+      "7 PM",
+      "8 PM",
+      "9 PM",
+      "10 PM",
+      "11 PM"
+    ],
+    hours24: [
+      "00:00",
+      "01:00",
+      "02:00",
+      "03:00",
+      "04:00",
+      "05:00",
+      "06:00",
+      "07:00",
+      "08:00",
+      "09:00",
+      "10:00",
+      "11:00",
+      "12:00",
+      "13:00",
+      "14:00",
+      "15:00",
+      "16:00",
+      "17:00",
+      "18:00",
+      "19:00",
+      "20:00",
+      "21:00",
+      "22:00",
+      "23:00"
+    ],
+    days: [
+      "Monday",
+      "Tuesday",
+      "Wednesday",
+      "Thursday",
+      "Friday",
+      "Saturday",
+      "Sunday"
+    ],
+    months: [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ],
+    custom: [
+      "Category A",
+      "Category B",
+      "Category C",
+      "Category D",
+      "Category E"
+    ]
+  };
+  const categories = categoryOptions[categoryType];
+  const numberOfPoints = categories.length;
+  return [...Array(numberOfSeries).keys()].map((seriesIndex) => {
+    let nullsArray = [];
+    if (showNulls) {
+      const nullsArrayLength = Math.floor(numberOfPoints / 5);
+      nullsArray = [...Array(nullsArrayLength)].map(
+        () => Math.floor(Math.random() * numberOfPoints)
+      );
+    }
+    return {
+      points: categories.map((category, pointIndex) => {
+        const showNull = nullsArray && nullsArray.length > 0 ? nullsArray.includes(pointIndex) : false;
+        const randomValue = Math.random();
+        const positiveOrNegativeYAxisMax = showNegativeValues ? randomValue < 0.5 ? -yAxisMax : yAxisMax : yAxisMax;
+        return {
+          x: category,
+          y: showNull ? null : Math.floor(randomValue * positiveOrNegativeYAxisMax)
+        };
+      }),
+      name: `Series ${seriesIndex + 1}`,
+      styles: {
+        color: showCustomColors ? getStorybookRandomColor() : void 0,
+        pattern: showDashedLines ? "dashed" : "solid"
+      }
+    };
+  });
+};
+
+// src/helpers/getStorybookSparseTimelineData.ts
+var getStorybookSparseTimelineData = ({
+  showNulls,
+  showNegativeValues,
+  numberOfSeries,
+  yAxisMax,
+  showCustomColors,
+  showDashedLines,
+  numberOfPoints = 5,
+  timeSpanHours = 24
+}) => {
+  const seriesNames = [
+    "Posts Published",
+    "Comments",
+    "Likes",
+    "Shares",
+    "Clicks",
+    "Views",
+    "Saves",
+    "Reposts",
+    "Mentions",
+    "Reactions"
+  ];
+  const baseDate = /* @__PURE__ */ new Date("2024-01-01T00:00:00Z");
+  const timeSpanMs = timeSpanHours * 60 * 60 * 1e3;
+  return [...Array(numberOfSeries).keys()].map((seriesIndex) => {
+    let nullsArray = [];
+    if (showNulls) {
+      const nullsArrayLength = Math.floor(numberOfPoints / 5);
+      nullsArray = [...Array(nullsArrayLength)].map(
+        () => Math.floor(Math.random() * numberOfPoints)
+      );
+    }
+    const timestamps = [...Array(numberOfPoints)].map(() => {
+      const randomOffset = Math.random() * timeSpanMs;
+      return baseDate.getTime() + randomOffset;
+    }).sort((a, b) => a - b);
+    return {
+      points: timestamps.map((timestamp, pointIndex) => {
+        const showNull = nullsArray && nullsArray.length > 0 ? nullsArray.includes(pointIndex) : false;
+        const randomValue = Math.random();
+        const positiveOrNegativeYAxisMax = showNegativeValues ? randomValue < 0.5 ? -yAxisMax : yAxisMax : yAxisMax;
+        return {
+          x: timestamp,
+          y: showNull ? null : Math.floor(randomValue * positiveOrNegativeYAxisMax)
+        };
+      }),
+      name: seriesNames[seriesIndex] || `Series ${seriesIndex + 1}`,
+      styles: {
+        color: showCustomColors ? getStorybookRandomColor() : void 0,
+        pattern: showDashedLines ? "dashed" : "solid"
+      }
+    };
+  });
+};
+
+// src/styles/chartStyles.ts
+import { css as css2, createGlobalStyle as createGlobalStyle2 } from "styled-components";
+import { theme as theme5 } from "@sproutsocial/seeds-react-theme";
+import "highcharts/css/highcharts.css";
+var GlobalChartStyleOverrides = createGlobalStyle2`
+  // USAGE NOTE:
+  // Put general styles in baseChartStyles instead when possible to avoid excessive global styling.
+  // This global component is only for styles that can't override highcharts defaults when scoped.
+
+  .highcharts-tooltip-container {
+    z-index: 7 !important;
+  }
+  .highcharts-tooltip-box {
+    fill: transparent !important;
+  }
+`;
+var baseChartStyles = css2`
+  --highcharts-background-color: ${({ theme: theme6 }) => theme6.colors.container.background.base};
+
+  // set color variables and map to each series
+  ${({ $colors }) => $colors.map((color, index) => {
+  const chartColor = color || theme5.colors.DATAVIZ_COLORS_LIST[index];
+  return `
+				// map colors to custom assigned colors or fallback to default data viz color rotation
+				--highcharts-color-${index}: ${chartColor};
+
+				// highcharts already accounts for 10 series, but if we have more, we need to add them
+				.highcharts-color-${index} {
+					color: var(--highcharts-color-${index});
+					stroke: var(--highcharts-color-${index});
+					fill: var(--highcharts-color-${index});
+				}`;
+}).join("\n")}
+
+  // set overall chart background color
+  .highcharts-background {
+    fill: ${({ theme: theme6 }) => theme6.colors.container.background.base};
+  }
+
+  g.highcharts-annotation-label {
+    display: none;
+  }
+
+  div.highcharts-annotation-label {
+    top: 0 !important;
+    transform: translateX(-50%); // centers the label on the targeted axis point
+    pointer-events: none; // prevents tooltip hover from being interrupted by this element since it renders after on the dom
+  }
+`;
+var timeSeriesChartStyles = css2`
+  ${baseChartStyles}
+
+  // vertical crosshair styles
+	.highcharts-crosshair {
+    stroke: ${({ theme: theme6 }) => theme6.colors.container.border.decorative.neutral};
+    stroke-width: 1;
+  }
+
+  // axis and gridline styles
+  .highcharts-grid-line {
+    stroke: ${({ theme: theme6 }) => theme6.colors.container.border.base};
+  }
+
+  .highcharts-axis-line {
+    stroke: ${({ theme: theme6 }) => theme6.colors.container.border.base};
+  }
+
+  .highcharts-tick {
+    stroke: none;
+  }
+  .highcharts-xaxis-labels,
+  .highcharts-yaxis-labels {
+    // v1 HTML labels (useHTML: true). v2 SVG label styles live in
+    // charts/shared/styles.ts (axisLabelV2Styles) — don't add v2 rules here.
+    > span {
+      font-family: ${({ theme: theme6 }) => theme6.fontFamily};
+      ${({ theme: theme6 }) => theme6.typography[100]};
+      font-weight: ${({ theme: theme6 }) => theme6.fontWeights.normal};
+      color: ${({ theme: theme6 }) => theme6.colors.text.subtext};
+    }
+  }
+  .highcharts-xaxis-labels {
+    // v1 HTML stacked labels (useHTML: true). v2 SVG stacked-label styles live
+    // in charts/shared/styles.ts (axisLabelV2Styles).
+    > span {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      > span:nth-of-type(2) {
+        font-weight: ${({ theme: theme6 }) => theme6.fontWeights.semibold};
+      }
+    }
+  }
+
+  // we don't want to drop the opacity when another item is hovered
+  .highcharts-series-inactive {
+    opacity: 1;
+  }
+
+  // apply cursor pointer when click functionality is turned on
+  ${({ $hasOnClick }) => $hasOnClick && `
+ 			.highcharts-series,
+ 			.highcharts-point {
+ 				cursor: pointer;
+ 			}
+ 			.highcharts-plot-background,
+ 			.highcharts-crosshair,
+ 			.highcharts-grid-line {
+ 				fill: transparent;
+ 				cursor: pointer;
+ 		}`}
+
+  path.highcharts-plot-line.y-axis-zero-line {
+    stroke: ${({ theme: theme6 }) => theme6.colors.container.border.decorative.neutral};
+  }
+`;
+var lineChartStyles = css2`
+  ${timeSeriesChartStyles}
+
+  // set the line stroke
+	.highcharts-graph {
+    stroke-width: 3;
+  }
+
+  // dashed line styles
+  ${({ $patterns }) => $patterns.map((pattern, index) => {
+  return pattern === "dashed" ? `
+ 					// highcharts already accounts for 10 series, but if we have more, we need to add them
+ 					.highcharts-series-${index} {
+ 						stroke-dasharray: 2, 8;
+ 					}` : "";
+})}
+`;
+var areaChartStyles = css2`
+  ${timeSeriesChartStyles}
+
+  // don't need to show a stroke for the line part of each area
+	.highcharts-graph {
+    stroke-width: 0;
+  }
+
+  // fill areas to full opacity
+  .highcharts-area {
+    fill-opacity: 1;
+  }
+`;
+var donutChartStyles = css2`
+  ${baseChartStyles}
+
+  // remove 250ms fade in/out when hovering over different donut chart slices
+	.highcharts-point {
+    transition: opacity 0s;
+  }
+
+  // remove stroke on donut slices
+  .highcharts-pie-series .highcharts-point {
+    stroke: none;
+  }
+
+  // don't reduce opacity when hovering
+  .highcharts-point-hover {
+    fill-opacity: none;
+  }
+
+  // apply cursor pointer when click functionality is turned on
+  ${({ $hasOnClick }) => $hasOnClick && `
+ 			.highcharts-series,
+ 			.highcharts-point {
+ 				cursor: pointer;
+ 			}
+ 			.highcharts-plot-background,
+ 			.highcharts-crosshair,
+ 			.highcharts-grid-line {
+ 				fill: transparent;
+ 				cursor: pointer;
+ 		}`}
+`;
+
+// src/components/ChartLegend/components/ChartLegendLabelContentWithIcon.tsx
+import { memo as memo10 } from "react";
+import { Box as Box7 } from "@sproutsocial/seeds-react-box";
+import { jsxs as jsxs3 } from "react/jsx-runtime";
+var ChartLegendLabelContentWithIcon = memo10(
+  function ChartLegendLabelContentWithIcon2({
+    children,
+    icon
+  }) {
+    return icon ? /* @__PURE__ */ jsxs3(Box7, { display: "flex", alignItems: "center", gap: 200, children: [
+      icon,
+      children
+    ] }) : children;
+  }
+);
+
+export {
+  ColorBox,
+  DatavizColorBox,
+  getDatavizColor,
+  getDatavizOpacity,
+  getDatavizColorWithAlpha,
+  NetworkColorBox,
+  ChartLegendLabel,
+  ChartLegend,
+  ChartLegendLabelContentWithIcon,
+  ChartTooltip,
+  ChartTooltipFooter,
+  ChartTooltipHeader,
+  generateChartTooltipPortalId,
+  ChartTooltipPortal,
+  ChartTable,
+  ChartTooltipTable,
+  ChartTooltipTitle,
+  transformDataToSeries,
+  transformTimeSeriesTooltipData,
+  yAxisLabelFormatter,
+  xAxisLabelFormatter,
+  isHourlyTimeData,
+  isCategoricalHourData,
+  getStorybookCategoricalData,
+  getStorybookSparseTimelineData,
+  GlobalChartStyleOverrides,
+  baseChartStyles,
+  timeSeriesChartStyles,
+  lineChartStyles,
+  areaChartStyles,
+  donutChartStyles
+};
+//# sourceMappingURL=chunk-LC3HGWDD.js.map