@coinbase/cds-mobile-visualization 3.3.0 → 3.4.0-beta.10

package/esm/chart/utils/path.js

@@ -0,0 +1,274 @@
+import { area as d3Area, curveBumpX, curveCatmullRom, curveLinear, curveLinearClosed, curveMonotoneX, curveNatural, curveStep, curveStepAfter, curveStepBefore, line as d3Line } from 'd3-shape';
+import { projectPoint, projectPoints } from './point';
+import { isCategoricalScale } from './scale';
+/**
+ * Get the d3 curve function for a path.
+ * See https://d3js.org/d3-shape/curve
+ * @param curve - The curve type. Defaults to 'linear'.
+ * @returns The d3 curve function.
+ */
+export const getPathCurveFunction = function (curve) {
+  if (curve === void 0) {
+    curve = 'linear';
+  }
+  switch (curve) {
+    case 'catmullRom':
+      return curveCatmullRom;
+    case 'monotone':
+      // When we support layout="vertical" this should dynamically switch to curveMonotoneY
+      return curveMonotoneX;
+    case 'natural':
+      return curveNatural;
+    case 'step':
+      return curveStep;
+    case 'stepBefore':
+      return curveStepBefore;
+    case 'stepAfter':
+      return curveStepAfter;
+    case 'bump':
+      // When we support layout="vertical" this should dynamically switch to curveBumpY
+      return curveBumpX;
+    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: 'linear' });
+ * ```
+ */
+export const getLinePath = _ref => {
+  var _pathGenerator;
+  let {
+    data,
+    curve = 'bump',
+    xScale,
+    yScale,
+    xData,
+    connectNulls = false
+  } = _ref;
+  if (data.length === 0) {
+    return '';
+  }
+  const curveFunction = getPathCurveFunction(curve);
+  const dataPoints = projectPoints({
+    data,
+    xScale,
+    yScale,
+    xData
+  });
+
+  // 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 : '';
+};
+
+/**
+ * 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,
+    connectNulls = false
+  } = _ref2;
+  if (data.length === 0) {
+    return '';
+  }
+  const curveFunction = getPathCurveFunction(curve);
+  const yDomain = yScale.domain();
+  const yMin = Math.min(...yDomain);
+  const normalizedData = data.map((item, index) => {
+    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 [yMin, item];
+    }
+    return null;
+  });
+  const dataPoints = normalizedData.map((range, index) => {
+    if (range === null) {
+      return {
+        x: 0,
+        low: null,
+        high: null,
+        isValid: false
+      };
+    }
+    let xValue = index;
+    if (!isCategoricalScale(xScale) && xData && xData[index] !== undefined) {
+      xValue = xData[index];
+    }
+    const xPoint = projectPoint({
+      x: xValue,
+      y: 0,
+      xScale,
+      yScale
+    });
+    const lowPoint = projectPoint({
+      x: xValue,
+      y: range[0],
+      xScale,
+      yScale
+    });
+    const highPoint = projectPoint({
+      x: xValue,
+      y: range[1],
+      xScale,
+      yScale
+    });
+    return {
+      x: xPoint.x,
+      low: lowPoint.y,
+      high: highPoint.y,
+      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().x(d => d.x).y0(d => {
+    var _d$low;
+    return (_d$low = d.low) != null ? _d$low : 0;
+  }) // Bottom boundary (low values), fallback to 0
+  .y1(d => {
+    var _d$high;
+    return (_d$high = d.high) != null ? _d$high : 0;
+  }) // Top boundary (high values), fallback to 0
+  .curve(curveFunction).defined(d => connectNulls || d.isValid && d.low != null && d.high != null); // Only draw where both values exist
+
+  const result = areaGenerator(filteredPoints);
+  return result != null ? 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 " + x1 + " " + y1 + " L " + x2 + " " + 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 = (x, y, width, height, radius, roundTop, roundBottom) => {
+  const roundBothSides = roundTop && roundBottom;
+  const r = Math.min(radius, width / 2, roundBothSides ? height / 2 : height);
+  const topR = roundTop ? r : 0;
+  const bottomR = roundBottom ? r : 0;
+
+  // Build path with selective rounding
+  let path = "M " + (x + (roundTop ? r : 0)) + " " + y;
+  path += " L " + (x + width - topR) + " " + y;
+  path += " A " + topR + " " + topR + " 0 0 1 " + (x + width) + " " + (y + topR);
+  path += " L " + (x + width) + " " + (y + height - bottomR);
+  path += " A " + bottomR + " " + bottomR + " 0 0 1 " + (x + width - bottomR) + " " + (y + height);
+  path += " L " + (x + bottomR) + " " + (y + height);
+  path += " A " + bottomR + " " + bottomR + " 0 0 1 " + x + " " + (y + height - bottomR);
+  path += " L " + x + " " + (y + topR);
+  path += " A " + topR + " " + topR + " 0 0 1 " + (x + topR) + " " + y;
+  path += ' Z';
+  return path;
+};
+
+/**
+ * Generates an SVG path string with circles arranged in a dotted pattern within a bounding area.
+ * Creates circles at regular intervals based on the pattern size and dot size parameters.
+ *
+ * @param bounds - The bounding rectangle to fill with dots
+ * @param patternSize - Size of the pattern unit (spacing between dots)
+ * @param dotSize - Radius of each dot
+ * @returns SVG path string containing all the circles
+ *
+ * @example
+ * ```typescript
+ * const dotsPath = getDottedAreaPath(
+ *   { x: 0, y: 0, width: 100, height: 50 },
+ *   8, // 8px spacing
+ *   2  // 2px radius dots
+ * );
+ * ```
+ */
+export const getDottedAreaPath = (bounds, patternSize, dotSize) => {
+  if (bounds.width <= 0 || bounds.height <= 0 || patternSize <= 0 || dotSize <= 0) {
+    return '';
+  }
+  let path = '';
+
+  // Calculate the number of dots that fit in each dimension
+  const dotsX = Math.ceil(bounds.width / patternSize);
+  const dotsY = Math.ceil(bounds.height / patternSize);
+
+  // Generate circles in a grid pattern
+  for (let row = 0; row < dotsY; row++) {
+    for (let col = 0; col < dotsX; col++) {
+      const centerX = bounds.x + col * patternSize + patternSize / 2;
+      const centerY = bounds.y + row * patternSize + patternSize / 2;
+
+      // Only draw dots that are within the bounds
+      if (centerX >= bounds.x && centerX <= bounds.x + bounds.width && centerY >= bounds.y && centerY <= bounds.y + bounds.height) {
+        // Create circle using SVG arc commands
+        // M cx,cy-r a r,r 0 1,0 0,2r a r,r 0 1,0 0,-2r
+        path += "M " + centerX + "," + (centerY - dotSize) + " a " + dotSize + "," + dotSize + " 0 1,0 0," + dotSize * 2 + " a " + dotSize + "," + dotSize + " 0 1,0 0," + -dotSize * 2 + " ";
+      }
+    }
+  }
+  return path.trim();
+};

package/esm/chart/utils/point.js

@@ -0,0 +1,229 @@
+import { applySerializableScale, isCategoricalScale, isLogScale, isNumericScale } 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.
+ * @note for categorical scales, the point will be centered within the band.
+ * @note for log scales, zero and negative values are clamped to a small positive value.
+ * @param data - the data value.
+ * @param scale - the scale function.
+ * @returns the pixel value (defaulting to 0 if data value is not defined in scale).
+ */
+export const getPointOnScale = (dataValue, scale) => {
+  var _scale2;
+  if (isCategoricalScale(scale)) {
+    var _scale, _scale$bandwidth;
+    const bandStart = (_scale = scale(dataValue)) != null ? _scale : 0;
+    const bandwidth = (_scale$bandwidth = scale.bandwidth()) != null ? _scale$bandwidth : 0;
+    return bandStart + bandwidth / 2;
+  }
+
+  // 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 (_scale2 = scale(adjustedValue)) != null ? _scale2 : 0;
+};
+
+/**
+ * Get a point from a data value and a serializable scale (worklet-compatible).
+ * @note for categorical scales, the point will be centered within the band.
+ * @note for log scales, zero and negative values are clamped to a small positive value.
+ * @param dataValue - the data value.
+ * @param scale - the serializable scale object.
+ * @returns the pixel value (defaulting to 0 if data value is not defined in scale).
+ */
+export function getPointOnSerializableScale(dataValue, scale) {
+  'worklet';
+
+  if (scale.type === 'band') {
+    const bandStart = applySerializableScale(dataValue, scale);
+    return bandStart + scale.bandwidth / 2;
+  }
+
+  // For log scales, ensure the value is positive
+  if (scale.type === 'log' && dataValue <= 0) {
+    dataValue = 0.001; // Use a small positive value for log scales
+  }
+  return applySerializableScale(dataValue, scale);
+}
+
+/**
+ * Projects a single data point to pixel coordinates using serializable scales.
+ * This is the worklet-compatible version for use in react-native-reanimated.
+ */
+export function projectPointWithSerializableScale(_ref) {
+  'worklet';
+
+  let {
+    x,
+    y,
+    xScale,
+    yScale
+  } = _ref;
+  return {
+    x: getPointOnSerializableScale(x, xScale),
+    y: getPointOnSerializableScale(y, yScale)
+  };
+}
+
+/**
+ * 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 = _ref2 => {
+  let {
+    x,
+    y,
+    xScale,
+    yScale
+  } = _ref2;
+  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 = _ref3 => {
+  let {
+    data,
+    xScale,
+    yScale,
+    xData,
+    yData
+  } = _ref3;
+  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
+      });
+    }
+
+    // For scales with axis data, determine the correct x value
+    let xValue = index;
+
+    // For band scales, always use the index
+    if (!isCategoricalScale(xScale)) {
+      // For numeric scales with axis data, use the axis data values instead of indices
+      if (xData && Array.isArray(xData) && xData.length > 0) {
+        // Check if it's numeric data
+        if (typeof xData[0] === 'number') {
+          var _numericXData$index;
+          const numericXData = xData;
+          xValue = (_numericXData$index = numericXData[index]) != null ? _numericXData$index : index;
+        }
+      }
+    }
+    let yValue = value;
+    if (isNumericScale(yScale) && yData && Array.isArray(yData) && yData.length > 0 && typeof yData[0] === 'number' && typeof value === 'number') {
+      yValue = value;
+    }
+    return projectPoint({
+      x: xValue,
+      y: yValue,
+      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
+  };
+};