@coinbase/cds-web 8.66.1 → 9.0.0-rc.1

package/esm/visualizations/chart/utils/path.js

@@ -0,0 +1,254 @@
+import { area as d3Area, curveBumpX, curveBumpY, curveCatmullRom, curveLinear, curveLinearClosed, curveMonotoneX, curveMonotoneY, curveNatural, curveStep, curveStepAfter, curveStepBefore, line as d3Line } from 'd3-shape';
+import { getPointOnScale, projectPoints } from './point';
+import { isCategoricalScale } from './scale';
+
+/**
+ * Default enter transition for path-based components (Line, Area).
+ * `{ type: 'tween', duration: 0.5 }`
+ */
+export const defaultPathEnterTransition = {
+  type: 'tween',
+  duration: 0.5
+};
+/**
+ * Get the d3 curve function for a path.
+ * See https://d3js.org/d3-shape/curve
+ * @param curve - The curve type. Defaults to 'linear'.
+ * @param layout - The chart layout. Defaults to 'vertical'.
+ * @returns The d3 curve function.
+ */
+export const getPathCurveFunction = function () {
+  let curve = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'linear';
+  let layout = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'vertical';
+  switch (curve) {
+    case 'catmullRom':
+      return curveCatmullRom;
+    case 'monotone':
+      // For vertical layout, X is the independent axis (category/index), so use MonotoneX
+      // For horizontal layout, Y is the independent axis (category/index), so use MonotoneY
+      return layout !== 'horizontal' ? curveMonotoneX : curveMonotoneY;
+    case 'natural':
+      return curveNatural;
+    case 'step':
+      return curveStep;
+    case 'stepBefore':
+      return curveStepBefore;
+    case 'stepAfter':
+      return curveStepAfter;
+    case 'bump':
+      // For vertical layout, X is the independent axis (category/index), so use BumpX
+      // For horizontal layout, Y is the independent axis (category/index), so use BumpY
+      return layout !== 'horizontal' ? curveBumpX : curveBumpY;
+    case 'linearClosed':
+      return curveLinearClosed;
+    case 'linear':
+    default:
+      return curveLinear;
+  }
+};
+
+/**
+ * Generates an SVG line path string from data using chart scale functions.
+ *
+ * @example
+ * ```typescript
+ * const chartScale = getChartScale({ chartRect, domain, range, xScale, yScale });
+ * const path = getLinePath({ data: [1, 2, 3], chartScale, curve: 'bump' });
+ * ```
+ */
+export const getLinePath = _ref => {
+  var _pathGenerator;
+  let {
+    data,
+    curve = 'bump',
+    xScale,
+    yScale,
+    xData,
+    yData,
+    connectNulls,
+    layout = 'vertical'
+  } = _ref;
+  if (data.length === 0) {
+    return '';
+  }
+  const curveFunction = getPathCurveFunction(curve, layout);
+  const dataPoints = projectPoints({
+    data,
+    xScale,
+    yScale,
+    xData,
+    yData,
+    layout
+  });
+
+  // When connectNulls is true, filter out null values before rendering
+  // When false, use defined() to create gaps in the line
+  const filteredPoints = connectNulls ? dataPoints.filter(d => d !== null) : dataPoints;
+  const pathGenerator = d3Line().x(d => d.x).y(d => d.y).curve(curveFunction).defined(d => connectNulls || d !== null);
+  return (_pathGenerator = pathGenerator(filteredPoints)) !== null && _pathGenerator !== void 0 ? _pathGenerator : '';
+};
+
+/**
+ * Generates an SVG area path string from data using chart scale functions.
+ * Supports both single values (area from baseline to value) and tuples ([baseline, value]).
+ *
+ * @example
+ * ```typescript
+ * // Single values - area from baseline to value
+ * const area = getAreaPath({
+ *   data: [1, 2, 3],
+ *   xScale,
+ *   yScale,
+ * });
+ *
+ * // Range values - area from low to high
+ * const rangeArea = getAreaPath({
+ *   data: [[0, 3], [2, 4], [1, 5]],
+ *   xScale,
+ *   yScale,
+ *   curve: 'monotone'
+ * });
+ * ```
+ */
+export const getAreaPath = _ref2 => {
+  let {
+    data,
+    curve = 'bump',
+    xScale,
+    yScale,
+    xData,
+    yData,
+    connectNulls,
+    layout = 'vertical'
+  } = _ref2;
+  if (data.length === 0) {
+    return '';
+  }
+  const curveFunction = getPathCurveFunction(curve, layout);
+  const categoryAxisIsX = layout !== 'horizontal';
+
+  // Determine baseline from the value scale
+  const valueScale = categoryAxisIsX ? yScale : xScale;
+  const domain = valueScale.domain();
+  const min = Math.min(...domain);
+  const normalizedData = data.map(item => {
+    if (item === null) {
+      return null;
+    }
+    if (Array.isArray(item)) {
+      if (item.length >= 2 && typeof item[0] === 'number' && typeof item[1] === 'number') {
+        return [item[0], item[1]];
+      }
+      return null;
+    }
+    if (typeof item === 'number') {
+      return [min, item];
+    }
+    return null;
+  });
+  const dataPoints = normalizedData.map((range, index) => {
+    if (range === null) {
+      return {
+        x: 0,
+        y: 0,
+        low: null,
+        high: null,
+        isValid: false
+      };
+    }
+
+    // Determine the position along the independent (index) axis
+    let indexValue = index;
+    const indexScale = categoryAxisIsX ? xScale : yScale;
+    const indexData = categoryAxisIsX ? xData : yData;
+    if (!isCategoricalScale(indexScale) && indexData && indexData[index] !== undefined) {
+      indexValue = indexData[index];
+    }
+    const pos = getPointOnScale(indexValue, indexScale);
+    const low = getPointOnScale(range[0], valueScale);
+    const high = getPointOnScale(range[1], valueScale);
+    return {
+      x: categoryAxisIsX ? pos : 0,
+      y: !categoryAxisIsX ? pos : 0,
+      low,
+      high,
+      isValid: true
+    };
+  });
+
+  // When connectNulls is true, filter out invalid points before rendering
+  // When false, use defined() to create gaps in the area
+  const filteredPoints = connectNulls ? dataPoints.filter(d => d.isValid) : dataPoints;
+  const areaGenerator = d3Area();
+  if (categoryAxisIsX) {
+    areaGenerator.x(d => d.x).y0(d => {
+      var _d$low;
+      return (_d$low = d.low) !== null && _d$low !== void 0 ? _d$low : 0;
+    }).y1(d => {
+      var _d$high;
+      return (_d$high = d.high) !== null && _d$high !== void 0 ? _d$high : 0;
+    });
+  } else {
+    areaGenerator.y(d => d.y).x0(d => {
+      var _d$low2;
+      return (_d$low2 = d.low) !== null && _d$low2 !== void 0 ? _d$low2 : 0;
+    }).x1(d => {
+      var _d$high2;
+      return (_d$high2 = d.high) !== null && _d$high2 !== void 0 ? _d$high2 : 0;
+    });
+  }
+  areaGenerator.curve(curveFunction).defined(d => connectNulls || d.isValid && d.low != null && d.high != null);
+  const result = areaGenerator(filteredPoints);
+  return result !== null && result !== void 0 ? result : '';
+};
+
+/**
+ * Converts line coordinates to an SVG path string.
+ * Useful for rendering axis lines and tick marks.
+ *
+ * @example
+ * ```typescript
+ * const path = lineToPath(0, 0, 100, 100);
+ * // Returns: "M 0 0 L 100 100"
+ * ```
+ */
+export const lineToPath = (x1, y1, x2, y2) => {
+  return "M".concat(x1, ",").concat(y1, " L").concat(x2, ",").concat(y2);
+};
+
+/**
+ * Creates an SVG path string for a rectangle with selective corner rounding.
+ * Useful for creating bars in charts with optional rounded corners.
+ *
+ * @example
+ * ```typescript
+ * // Simple rectangle bar
+ * const barPath = getBarPath(10, 20, 50, 100, 0, false, false);
+ *
+ * // Bar with rounded top corners
+ * const roundedPath = getBarPath(10, 20, 50, 100, 8, true, false);
+ * ```
+ */
+export const getBarPath = function (x, y, width, height, radius, roundTop, roundBottom) {
+  let layout = arguments.length > 7 && arguments[7] !== undefined ? arguments[7] : 'vertical';
+  const isVerticalLayout = layout === 'vertical';
+  const roundBothSides = roundTop && roundBottom;
+  const r = Math.min(radius, width / 2, roundBothSides ? height / 2 : height);
+  const rTL = isVerticalLayout ? roundTop ? r : 0 : roundBottom ? r : 0;
+  const rTR = isVerticalLayout ? roundTop ? r : 0 : roundTop ? r : 0;
+  const rBR = isVerticalLayout ? roundBottom ? r : 0 : roundTop ? r : 0;
+  const rBL = isVerticalLayout ? roundBottom ? r : 0 : roundBottom ? r : 0;
+
+  // Build path with selective rounding
+  let path = "M ".concat(x + rTL, " ").concat(y);
+  path += " L ".concat(x + width - rTR, " ").concat(y);
+  path += " A ".concat(rTR, " ").concat(rTR, " 0 0 1 ").concat(x + width, " ").concat(y + rTR);
+  path += " L ".concat(x + width, " ").concat(y + height - rBR);
+  path += " A ".concat(rBR, " ").concat(rBR, " 0 0 1 ").concat(x + width - rBR, " ").concat(y + height);
+  path += " L ".concat(x + rBL, " ").concat(y + height);
+  path += " A ".concat(rBL, " ").concat(rBL, " 0 0 1 ").concat(x, " ").concat(y + height - rBL);
+  path += " L ".concat(x, " ").concat(y + rTL);
+  path += " A ".concat(rTL, " ").concat(rTL, " 0 0 1 ").concat(x + rTL, " ").concat(y);
+  path += ' Z';
+  return path;
+};

package/esm/visualizations/chart/utils/point.js

@@ -0,0 +1,214 @@
+import { isCategoricalScale, isLogScale } from './scale';
+
+/**
+ * Position a label should be placed relative to the point
+ *
+ * @example
+ * 'top' would have the label be located above the point itself,
+ * and thus the vertical alignment of that text would be bottom.
+ */
+
+/**
+ * Get a point from a data value and a scale.
+ *
+ * @param dataValue - The data value to convert to a pixel position.
+ * @param scale - The scale function.
+ * @param anchor (@default 'middle') - For band scales, where to anchor the point within the band.
+ * @returns The pixel value (@default 0 if data value is not defined in scale).
+ */
+export const getPointOnScale = function (dataValue, scale) {
+  var _scale;
+  let anchor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'middle';
+  if (isCategoricalScale(scale)) {
+    var _bandScale$bandwidth, _bandScale$bandwidth2, _bandScale$step, _bandScale$step2;
+    const bandScale = scale;
+    const bandStart = bandScale(dataValue);
+    if (bandStart === undefined) return 0;
+    const bandwidth = (_bandScale$bandwidth = (_bandScale$bandwidth2 = bandScale.bandwidth) === null || _bandScale$bandwidth2 === void 0 ? void 0 : _bandScale$bandwidth2.call(bandScale)) !== null && _bandScale$bandwidth !== void 0 ? _bandScale$bandwidth : 0;
+    const step = (_bandScale$step = (_bandScale$step2 = bandScale.step) === null || _bandScale$step2 === void 0 ? void 0 : _bandScale$step2.call(bandScale)) !== null && _bandScale$step !== void 0 ? _bandScale$step : bandwidth;
+    const paddingOffset = (step - bandwidth) / 2;
+    const stepStart = bandStart - paddingOffset;
+    switch (anchor) {
+      case 'stepStart':
+        return stepStart;
+      case 'bandStart':
+        return bandStart;
+      case 'middle':
+        return bandStart + bandwidth / 2;
+      case 'bandEnd':
+        return bandStart + bandwidth;
+      case 'stepEnd':
+        return stepStart + step;
+    }
+  }
+
+  // For log scales, ensure the value is positive
+  let adjustedValue = dataValue;
+  if (isLogScale(scale) && dataValue <= 0) {
+    adjustedValue = 0.001; // Use a small positive value for log scales
+  }
+  return (_scale = scale(adjustedValue)) !== null && _scale !== void 0 ? _scale : 0;
+};
+
+/**
+ * Projects a data point to pixel coordinates using the chart scale.
+ * Automatically handles log scale transformations for zero/negative values.
+ *
+ * @example
+ * ```typescript
+ * const chartScale = getChartScale({ chartRect, domain, range, xScale, yScale });
+ * const pixelCoord = projectPoint({ x: 5, y: 10, chartScale });
+ * ```
+ * @example
+ * ```typescript
+ * const chartScale = getChartScale({ chartRect, domain, range, xScale, yScale });
+ * const pixelCoord = projectPoint({ x: 2, y: 10, chartScale, xData: ['Jan', 'Feb', 'Mar'] });
+ * ```
+ */
+export const projectPoint = _ref => {
+  let {
+    x,
+    y,
+    xScale,
+    yScale
+  } = _ref;
+  return {
+    x: getPointOnScale(x, xScale),
+    y: getPointOnScale(y, yScale)
+  };
+};
+
+/**
+ * Projects multiple data points to pixel coordinates using chart scale functions.
+ * Handles both numeric and band scales automatically.
+ *
+ * @example
+ * ```typescript
+ * const chartScale = getChartScale({ chartRect, domain, range, xScale, yScale });
+ * const pixelPoints = projectPoints({ data, chartScale });
+ * // For mixed scales
+ * const pixelPoints = projectPoints({ data, chartScale, xData: ['Jan', 'Feb', 'Mar'] });
+ * ```
+ */
+export const projectPoints = _ref2 => {
+  let {
+    data,
+    xScale,
+    yScale,
+    xData,
+    yData,
+    layout = 'vertical'
+  } = _ref2;
+  if (data.length === 0) {
+    return [];
+  }
+  return data.map((value, index) => {
+    if (value === null) {
+      return null;
+    }
+    if (typeof value === 'object' && 'x' in value && 'y' in value) {
+      return projectPoint({
+        x: value.x,
+        y: value.y,
+        xScale,
+        yScale
+      });
+    }
+
+    // Determine values/scales based on role (index vs value) and layout.
+    const categoryAxisIsX = layout !== 'horizontal';
+    const indexScale = categoryAxisIsX ? xScale : yScale;
+    const indexData = categoryAxisIsX ? xData : yData;
+
+    // 1. Calculate position along the index axis (categorical or numeric domain).
+    let indexValue = index;
+    if (!isCategoricalScale(indexScale)) {
+      if (indexData && Array.isArray(indexData) && indexData.length > 0) {
+        if (typeof indexData[0] === 'number') {
+          var _index;
+          indexValue = (_index = indexData[index]) !== null && _index !== void 0 ? _index : index;
+        }
+      }
+    }
+
+    // 2. Calculate position along the value axis (measured magnitude).
+    const valueAsNumber = value;
+
+    // 3. Project final coordinates based on layout.
+    if (categoryAxisIsX) {
+      return projectPoint({
+        x: indexValue,
+        y: valueAsNumber,
+        xScale,
+        yScale
+      });
+    }
+    return projectPoint({
+      x: valueAsNumber,
+      y: indexValue,
+      xScale,
+      yScale
+    });
+  });
+};
+
+/**
+ * Determines text alignment based on label position.
+ * For example, a 'top' position needs the text aligned to the 'bottom' so it appears above the point.
+ */
+export const getAlignmentFromPosition = position => {
+  let horizontalAlignment = 'center';
+  let verticalAlignment = 'middle';
+  switch (position) {
+    case 'top':
+      verticalAlignment = 'bottom';
+      break;
+    case 'bottom':
+      verticalAlignment = 'top';
+      break;
+    case 'left':
+      horizontalAlignment = 'right';
+      break;
+    case 'right':
+      horizontalAlignment = 'left';
+      break;
+    case 'center':
+    default:
+      horizontalAlignment = 'center';
+      verticalAlignment = 'middle';
+      break;
+  }
+  return {
+    horizontalAlignment,
+    verticalAlignment
+  };
+};
+
+/**
+ * Calculates the final label coordinates by applying offset based on position.
+ */
+export const getLabelCoordinates = (x, y, position, offset) => {
+  let dx = 0;
+  let dy = 0;
+  switch (position) {
+    case 'top':
+      dy = -offset;
+      break;
+    case 'bottom':
+      dy = offset;
+      break;
+    case 'left':
+      dx = -offset;
+      break;
+    case 'right':
+      dx = offset;
+      break;
+    case 'center':
+    default:
+      break;
+  }
+  return {
+    x: x + dx,
+    y: y + dy
+  };
+};

package/esm/visualizations/chart/utils/scale.js

@@ -0,0 +1,59 @@
+import { scaleBand, scaleLinear, scaleLog } from 'd3-scale';
+
+// https://d3js.org/d3-scale - ideal next scale would be time
+
+export const isCategoricalScale = scale => {
+  return scale !== undefined && 'bandwidth' in scale && typeof scale.bandwidth === 'function';
+};
+export const isNumericScale = scale => {
+  return scale !== undefined && !isCategoricalScale(scale);
+};
+
+/**
+ * Type guard to check if a scale is logarithmic.
+ */
+export const isLogScale = scale => {
+  return scale !== undefined && 'base' in scale && typeof scale.base === 'function';
+};
+
+/**
+ * Create a numeric scale (linear or logarithmic)
+ * @returns A numeric scale function
+ */
+export const getNumericScale = _ref => {
+  let {
+    scaleType,
+    domain,
+    range
+  } = _ref;
+  const scale = scaleType === 'log' ? scaleLog() : scaleLinear();
+  return scale.domain([domain.min, domain.max]).range([range.min, range.max]);
+};
+
+/**
+ * Create a categorical scale (band)
+ * @returns A categorical scale function
+ */
+export const getCategoricalScale = _ref2 => {
+  let {
+    domain,
+    range,
+    padding = 0.1
+  } = _ref2;
+  const domainArray = Array.from({
+    length: domain.max - domain.min + 1
+  }, (_, i) => i);
+  const scale = scaleBand().domain(domainArray).range([range.min, range.max]).paddingInner(padding).paddingOuter(padding / 2);
+  return scale;
+};
+
+/**
+ * Anchor position for points on a scale. Currently used only for band scales.
+ *
+ * For band scales, this determines where within the band to position a point:
+ * - `'stepStart'` - At the start of the step
+ * - `'bandStart'` - At the start of the band
+ * - `'middle'` - At the center of the band
+ * - `'bandEnd'` - At the end of the band
+ * - `'stepEnd'` - At the end of the step
+ */

package/esm/visualizations/chart/utils/scrubber.js

@@ -0,0 +1,137 @@
+/**
+ * Determines which side (left/right) to place scrubber labels based on available space.
+ * Honors the preferred side when there's enough space, otherwise switches to the opposite side.
+ */
+export const getLabelPosition = function (beaconX, maxLabelWidth, drawingArea) {
+  let xOffset = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 16;
+  let preferredSide = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 'right';
+  if (drawingArea.width <= 0 || drawingArea.height <= 0) {
+    return preferredSide;
+  }
+  const requiredSpace = maxLabelWidth + xOffset;
+  if (preferredSide === 'right') {
+    const availableSpace = drawingArea.x + drawingArea.width - beaconX;
+    return requiredSpace <= availableSpace ? 'right' : 'left';
+  }
+  const availableSpace = beaconX - drawingArea.x;
+  return requiredSpace <= availableSpace ? 'left' : 'right';
+};
+/**
+ * Calculates Y positions for all labels avoiding overlaps while maintaining order.
+ */
+export const calculateLabelYPositions = (dimensions, drawingArea, labelHeight, minGap) => {
+  if (dimensions.length === 0) {
+    return new Map();
+  }
+
+  // Sort by preferred Y values and create working labels
+  const sortedLabels = [...dimensions].sort((a, b) => a.preferredY - b.preferredY).map(dim => ({
+    seriesId: dim.seriesId,
+    preferredY: dim.preferredY,
+    finalY: dim.preferredY
+  }));
+
+  // Initial bounds fitting
+  const minY = drawingArea.y + labelHeight / 2;
+  const maxY = drawingArea.y + drawingArea.height - labelHeight / 2;
+  const requiredDistance = labelHeight + minGap;
+  for (const label of sortedLabels) {
+    // Clamp each label to the drawing area
+    label.finalY = Math.max(minY, Math.min(maxY, label.preferredY));
+  }
+
+  // First pass: push down any overlapping labels
+  for (let i = 1; i < sortedLabels.length; i++) {
+    const prev = sortedLabels[i - 1];
+    const current = sortedLabels[i];
+    const minAllowedY = prev.finalY + requiredDistance;
+    if (current.finalY < minAllowedY) {
+      current.finalY = minAllowedY;
+    }
+  }
+
+  // Find collision groups - groups of labels that are tightly packed (gap < minGap between them)
+  const collisionGroups = [];
+  let currentGroup = [sortedLabels[0]];
+  for (let i = 1; i < sortedLabels.length; i++) {
+    const prev = sortedLabels[i - 1];
+    const current = sortedLabels[i];
+    const gap = current.finalY - prev.finalY - labelHeight;
+    if (gap < minGap + 0.01) {
+      // Labels are touching or very close - part of same collision group
+      currentGroup.push(current);
+    } else {
+      // Gap is large enough - start new group
+      collisionGroups.push(currentGroup);
+      currentGroup = [current];
+    }
+  }
+  collisionGroups.push(currentGroup);
+
+  // Process each collision group - optimize positioning to minimize displacement
+  for (const group of collisionGroups) {
+    if (group.length === 1) {
+      // Single label, already at best position
+      continue;
+    }
+    const groupLastLabel = group[group.length - 1];
+    const groupFirstLabel = group[0];
+    const groupOverflow = groupLastLabel.finalY + labelHeight / 2 - (drawingArea.y + drawingArea.height);
+
+    // Calculate the ideal center point for this group
+    const groupPreferredCenter = group.reduce((sum, label) => sum + label.preferredY, 0) / group.length;
+    const groupTotalNeeded = group.length * labelHeight + (group.length - 1) * minGap;
+    if (groupOverflow <= 0) {
+      // Group fits, but let's center it better if possible
+      // Calculate how much we can shift up/down to center around preferred positions
+      const currentCenter = (groupFirstLabel.finalY + groupLastLabel.finalY) / 2;
+      const desiredShift = groupPreferredCenter - currentCenter;
+
+      // Calculate max shift in each direction
+      const maxShiftUp = groupFirstLabel.finalY - minY;
+      const maxShiftDown = maxY - groupLastLabel.finalY;
+
+      // Apply the shift, constrained by boundaries
+      const actualShift = Math.max(-maxShiftUp, Math.min(maxShiftDown, desiredShift));
+      if (Math.abs(actualShift) > 0.01) {
+        for (const label of group) {
+          label.finalY += actualShift;
+        }
+      }
+    } else {
+      // Group overflows - need to adjust
+      const groupStartY = groupFirstLabel.finalY - labelHeight / 2;
+      const availableSpace = drawingArea.y + drawingArea.height - groupStartY;
+      const maxShiftUp = groupFirstLabel.finalY - minY;
+      if (maxShiftUp >= groupOverflow) {
+        // Can shift entire group up to fit
+        for (const label of group) {
+          label.finalY -= groupOverflow;
+        }
+      } else if (groupTotalNeeded <= availableSpace) {
+        // Can't shift enough, but there's room - redistribute with proper spacing
+        let currentY = Math.max(minY, groupFirstLabel.finalY - maxShiftUp);
+        const gap = (availableSpace - group.length * labelHeight) / Math.max(1, group.length - 1);
+        for (const label of group) {
+          label.finalY = currentY;
+          currentY += labelHeight + gap;
+        }
+      } else {
+        // Not enough space even with compression - compress gaps and fit to bottom
+        const compressedGap = Math.max(1, (availableSpace - group.length * labelHeight) / Math.max(1, group.length - 1));
+        // Position so last label is at maxY
+        let currentY = maxY - (group.length - 1) * (labelHeight + compressedGap);
+        currentY = Math.max(minY, currentY);
+        for (const label of group) {
+          label.finalY = currentY;
+          currentY += labelHeight + compressedGap;
+        }
+      }
+    }
+  }
+  const result = new Map();
+  for (const label of sortedLabels) {
+    result.set(label.seriesId, label.finalY);
+  }
+  return result;
+};