solid-recharts 0.1.0

package/src/util/createEventProxy.ts

@@ -0,0 +1,24 @@
+// Ported from recharts 3.8.1 src/util/createEventProxy.ts (commit 7a23854).
+// Solid deviation: no React `persist()` — capture `currentTarget` on a Proxy so
+// async/throttled handlers can read it after the original event loop turn.
+// Narrows an unknown to a callable type (not the lib `Function`, whose `.bind`/`.apply`
+// return `any`) so a forwarded method stays typed without a cast.
+function isCallable(value: unknown): value is (...args: unknown[]) => unknown {
+  return typeof value === "function";
+}
+
+export function createEventProxy<E extends { currentTarget: unknown }>(event: E): E {
+  const { currentTarget } = event;
+  return new Proxy(event, {
+    get(target, prop) {
+      if (prop === "currentTarget") {
+        return currentTarget;
+      }
+      const value: unknown = Reflect.get(target, prop);
+      if (isCallable(value)) {
+        return value.bind(target);
+      }
+      return value;
+    },
+  });
+}

package/src/util/createPolarCharts.tsx

@@ -0,0 +1,86 @@
+// Ported from recharts 3.8.1 src/util/createPolarCharts.tsx.
+// Solid-native: React.ComponentType → `(props) => JSX.Element`; layout binding
+// via `merge()`.
+import type { JSX } from "@solidjs/web";
+import { RadialBarChart as OriginalRadialBarChart } from "../chart/RadialBarChart";
+import { RadarChart as OriginalRadarChart } from "../chart/RadarChart";
+import { PieChart as OriginalPieChart } from "../chart/PieChart";
+import type { PolarChartProps } from "./types";
+
+type Component<P> = (props: P) => JSX.Element;
+type ChartComponent<TData> = Component<Omit<PolarChartProps<TData>, "layout">>;
+
+export type TypedCentricChartContext<TData, _TCategorical, _TNumerical, TComponents> = {
+  RadarChart: ChartComponent<TData>;
+} & Omit<TComponents, "RadialBar" | "RadialBarChart" | "Pie" | "PieChart">;
+
+export type TypedRadialChartContext<TData, _TCategorical, _TNumerical, TComponents> = {
+  RadialBarChart: ChartComponent<TData>;
+  PieChart: ChartComponent<TData>;
+} & Omit<TComponents, "Radar" | "RadarChart">;
+
+export type NoRadial<T> = "RadialBar" extends keyof T
+  ? never
+  : "RadialBarChart" extends keyof T
+    ? never
+    : "Pie" extends keyof T
+      ? never
+      : "PieChart" extends keyof T
+        ? never
+        : T;
+
+export type NoCentric<T> = "Radar" extends keyof T
+  ? never
+  : "RadarChart" extends keyof T
+    ? never
+    : T;
+
+/**
+ * Creates a typed context for centric Polar charts. Curries chart definitions to
+ * strictly bind `layout="centric"`. Rejects radial-only elements (`RadialBar`,
+ * `Pie`, etc.) at compile time.
+ *
+ * @since 3.8
+ */
+export function createCentricChart<TData, TCategorical = string, TNumerical = number>() {
+  return function withComponents<TComponents extends Record<string, unknown>>(
+    components: NoRadial<TComponents>,
+  ): TypedCentricChartContext<TData, TCategorical, TNumerical, TComponents> {
+    const RadarChart: ChartComponent<TData> = (props) => (
+      <OriginalRadarChart {...props} layout="centric" />
+    );
+    // eslint-disable-next-line typescript/consistent-type-assertions -- runtime identity preserved; type is a remap
+    return {
+      RadarChart,
+      // eslint-disable-next-line typescript/consistent-type-assertions -- NoRadial<T> narrows to T at runtime
+      ...(components as TComponents),
+    } as unknown as TypedCentricChartContext<TData, TCategorical, TNumerical, TComponents>;
+  };
+}
+
+/**
+ * Creates a typed context for radial Polar charts. Curries chart definitions to
+ * strictly bind `layout="radial"`. Rejects centric-only elements (`Radar`,
+ * `RadarChart`) at compile time.
+ *
+ * @since 3.8
+ */
+export function createRadialChart<TData, TCategorical = string, TNumerical = number>() {
+  return function withComponents<TComponents extends Record<string, unknown>>(
+    components: NoCentric<TComponents>,
+  ): TypedRadialChartContext<TData, TCategorical, TNumerical, TComponents> {
+    const RadialBarChart: ChartComponent<TData> = (props) => (
+      <OriginalRadialBarChart {...props} layout="radial" />
+    );
+    const PieChart: ChartComponent<TData> = (props) => (
+      <OriginalPieChart {...props} layout="radial" />
+    );
+    // eslint-disable-next-line typescript/consistent-type-assertions -- runtime identity preserved; type is a remap
+    return {
+      RadialBarChart,
+      PieChart,
+      // eslint-disable-next-line typescript/consistent-type-assertions -- NoCentric<T> narrows to T at runtime
+      ...(components as TComponents),
+    } as unknown as TypedRadialChartContext<TData, TCategorical, TNumerical, TComponents>;
+  };
+}

package/src/util/cursor/getCursorPoints.ts

@@ -0,0 +1,48 @@
+// Ported from recharts 3.8.1 src/util/cursor/getCursorPoints.ts (commit 7a23854).
+// Pure function — no framework surface — behavior is byte-identical to recharts.
+
+import { polarToCartesian } from "../PolarUtils";
+import {
+  Coordinate,
+  ChartOffsetInternal,
+  PolarCoordinate,
+  isPolarCoordinate,
+  CartesianLayout,
+  PolarLayout,
+} from "../types";
+import { RadialCursorPoints, getRadialCursorPoints } from "./getRadialCursorPoints";
+
+export function getCursorPoints(
+  layout: CartesianLayout | PolarLayout,
+  activeCoordinate: Coordinate | PolarCoordinate,
+  offset: ChartOffsetInternal,
+): [Coordinate, Coordinate] | RadialCursorPoints | undefined {
+  if (layout === "horizontal") {
+    return [
+      { x: activeCoordinate.x, y: offset.top },
+      { x: activeCoordinate.x, y: offset.top + offset.height },
+    ];
+  }
+
+  if (layout === "vertical") {
+    return [
+      { x: offset.left, y: activeCoordinate.y },
+      { x: offset.left + offset.width, y: activeCoordinate.y },
+    ];
+  }
+
+  if (isPolarCoordinate(activeCoordinate)) {
+    if (layout === "centric") {
+      const { cx, cy, innerRadius, outerRadius, angle } = activeCoordinate;
+      const innerPoint = polarToCartesian(cx, cy, innerRadius, angle);
+      const outerPoint = polarToCartesian(cx, cy, outerRadius, angle);
+      return [
+        { x: innerPoint.x, y: innerPoint.y },
+        { x: outerPoint.x, y: outerPoint.y },
+      ];
+    }
+    return getRadialCursorPoints(activeCoordinate);
+  }
+
+  return undefined;
+}

package/src/util/cursor/getCursorRectangle.ts

@@ -0,0 +1,31 @@
+// Ported from recharts 3.8.1 src/util/cursor/getCursorRectangle.ts (commit 7a23854).
+// Pure function — no framework surface — behavior is byte-identical to recharts.
+
+import { ChartCoordinate, ChartOffsetInternal, LayoutType } from "../types";
+
+export type CursorRectangle = {
+  stroke: string;
+  fill: string;
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+
+export function getCursorRectangle(
+  layout: LayoutType,
+  activeCoordinate: ChartCoordinate,
+  offset: ChartOffsetInternal,
+  tooltipAxisBandSize: number,
+): CursorRectangle {
+  const halfSize = tooltipAxisBandSize / 2;
+
+  return {
+    stroke: "none",
+    fill: "#ccc",
+    x: layout === "horizontal" ? activeCoordinate.x - halfSize : offset.left + 0.5,
+    y: layout === "horizontal" ? offset.top + 0.5 : activeCoordinate.y - halfSize,
+    width: layout === "horizontal" ? tooltipAxisBandSize : offset.width - 1,
+    height: layout === "horizontal" ? offset.height - 1 : tooltipAxisBandSize,
+  };
+}

package/src/util/cursor/getRadialCursorPoints.ts

@@ -0,0 +1,34 @@
+// Ported from recharts 3.8.1 src/util/cursor/getRadialCursorPoints.ts (commit 7a23854).
+// Pure function — no framework surface — behavior is byte-identical to recharts.
+
+import { polarToCartesian } from "../PolarUtils";
+import { Coordinate, PolarCoordinate } from "../types";
+
+export type RadialCursorPoints = {
+  points: [startPoint: Coordinate, endPoint: Coordinate];
+  cx?: number;
+  cy?: number;
+  radius?: number;
+  startAngle?: number;
+  endAngle?: number;
+};
+
+/**
+ * Only applicable for radial layouts
+ * @param {Object} activeCoordinate ChartCoordinate
+ * @returns {Object} RadialCursorPoints
+ */
+export function getRadialCursorPoints(activeCoordinate: PolarCoordinate): RadialCursorPoints {
+  const { cx, cy, radius, startAngle, endAngle } = activeCoordinate;
+  const startPoint = polarToCartesian(cx, cy, radius, startAngle);
+  const endPoint = polarToCartesian(cx, cy, radius, endAngle);
+
+  return {
+    points: [startPoint, endPoint],
+    cx,
+    cy,
+    radius,
+    startAngle,
+    endAngle,
+  };
+}

package/src/util/excludeEventProps.ts

@@ -0,0 +1,172 @@
+// Ported verbatim from recharts 3.8.1 (event-name data).
+export const EventKeys = [
+  "dangerouslySetInnerHTML",
+  "onCopy",
+  "onCopyCapture",
+  "onCut",
+  "onCutCapture",
+  "onPaste",
+  "onPasteCapture",
+  "onCompositionEnd",
+  "onCompositionEndCapture",
+  "onCompositionStart",
+  "onCompositionStartCapture",
+  "onCompositionUpdate",
+  "onCompositionUpdateCapture",
+  "onFocus",
+  "onFocusCapture",
+  "onBlur",
+  "onBlurCapture",
+  "onChange",
+  "onChangeCapture",
+  "onBeforeInput",
+  "onBeforeInputCapture",
+  "onInput",
+  "onInputCapture",
+  "onReset",
+  "onResetCapture",
+  "onSubmit",
+  "onSubmitCapture",
+  "onInvalid",
+  "onInvalidCapture",
+  "onLoad",
+  "onLoadCapture",
+  "onError",
+  "onErrorCapture",
+  "onKeyDown",
+  "onKeyDownCapture",
+  "onKeyPress",
+  "onKeyPressCapture",
+  "onKeyUp",
+  "onKeyUpCapture",
+  "onAbort",
+  "onAbortCapture",
+  "onCanPlay",
+  "onCanPlayCapture",
+  "onCanPlayThrough",
+  "onCanPlayThroughCapture",
+  "onDurationChange",
+  "onDurationChangeCapture",
+  "onEmptied",
+  "onEmptiedCapture",
+  "onEncrypted",
+  "onEncryptedCapture",
+  "onEnded",
+  "onEndedCapture",
+  "onLoadedData",
+  "onLoadedDataCapture",
+  "onLoadedMetadata",
+  "onLoadedMetadataCapture",
+  "onLoadStart",
+  "onLoadStartCapture",
+  "onPause",
+  "onPauseCapture",
+  "onPlay",
+  "onPlayCapture",
+  "onPlaying",
+  "onPlayingCapture",
+  "onProgress",
+  "onProgressCapture",
+  "onRateChange",
+  "onRateChangeCapture",
+  "onSeeked",
+  "onSeekedCapture",
+  "onSeeking",
+  "onSeekingCapture",
+  "onStalled",
+  "onStalledCapture",
+  "onSuspend",
+  "onSuspendCapture",
+  "onTimeUpdate",
+  "onTimeUpdateCapture",
+  "onVolumeChange",
+  "onVolumeChangeCapture",
+  "onWaiting",
+  "onWaitingCapture",
+  "onAuxClick",
+  "onAuxClickCapture",
+  "onClick",
+  "onClickCapture",
+  "onContextMenu",
+  "onContextMenuCapture",
+  "onDoubleClick",
+  "onDoubleClickCapture",
+  "onDrag",
+  "onDragCapture",
+  "onDragEnd",
+  "onDragEndCapture",
+  "onDragEnter",
+  "onDragEnterCapture",
+  "onDragExit",
+  "onDragExitCapture",
+  "onDragLeave",
+  "onDragLeaveCapture",
+  "onDragOver",
+  "onDragOverCapture",
+  "onDragStart",
+  "onDragStartCapture",
+  "onDrop",
+  "onDropCapture",
+  "onMouseDown",
+  "onMouseDownCapture",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseMove",
+  "onMouseMoveCapture",
+  "onMouseOut",
+  "onMouseOutCapture",
+  "onMouseOver",
+  "onMouseOverCapture",
+  "onMouseUp",
+  "onMouseUpCapture",
+  "onSelect",
+  "onSelectCapture",
+  "onTouchCancel",
+  "onTouchCancelCapture",
+  "onTouchEnd",
+  "onTouchEndCapture",
+  "onTouchMove",
+  "onTouchMoveCapture",
+  "onTouchStart",
+  "onTouchStartCapture",
+  "onPointerDown",
+  "onPointerDownCapture",
+  "onPointerMove",
+  "onPointerMoveCapture",
+  "onPointerUp",
+  "onPointerUpCapture",
+  "onPointerCancel",
+  "onPointerCancelCapture",
+  "onPointerEnter",
+  "onPointerEnterCapture",
+  "onPointerLeave",
+  "onPointerLeaveCapture",
+  "onPointerOver",
+  "onPointerOverCapture",
+  "onPointerOut",
+  "onPointerOutCapture",
+  "onGotPointerCapture",
+  "onGotPointerCaptureCapture",
+  "onLostPointerCapture",
+  "onLostPointerCaptureCapture",
+  "onScroll",
+  "onScrollCapture",
+  "onWheel",
+  "onWheelCapture",
+  "onAnimationStart",
+  "onAnimationStartCapture",
+  "onAnimationEnd",
+  "onAnimationEndCapture",
+  "onAnimationIteration",
+  "onAnimationIterationCapture",
+  "onTransitionEnd",
+  "onTransitionEndCapture",
+] as const;
+
+export type EventKeysType = (typeof EventKeys)[number];
+
+const EVENT_KEY_SET: ReadonlySet<string> = new Set(EventKeys);
+
+export function isEventKey(key: string): boolean {
+  return EVENT_KEY_SET.has(key);
+}

package/src/util/getActiveCoordinate.ts

@@ -0,0 +1,205 @@
+// Ported from recharts 3.8.1 src/util/getActiveCoordinate.ts (commit 7a23854).
+// Deviations: strict-mode type annotations on locals the reference left to
+// inference (`diffInterval: number[]`, `sameDirectionCoord: number`).
+import {
+  AxisType,
+  CartesianLayout,
+  ChartOffsetInternal,
+  RelativePointer,
+  Coordinate,
+  PolarCoordinate,
+  PolarLayout,
+  RangeObj,
+  TickItem,
+} from "./types";
+import { polarToCartesian } from "./PolarUtils";
+import { AxisRange } from "../state/selectors/axisSelectors";
+import { mathSign } from "./DataUtils";
+
+export const getActiveCartesianCoordinate = (
+  layout: CartesianLayout,
+  tooltipTicks: readonly TickItem[],
+  activeIndex: number | undefined,
+  pointer: RelativePointer,
+): Coordinate => {
+  const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+
+  if (entry) {
+    if (layout === "horizontal") {
+      return { x: entry.coordinate, y: pointer.relativeY };
+    }
+    if (layout === "vertical") {
+      return { x: pointer.relativeX, y: entry.coordinate };
+    }
+  }
+
+  return { x: 0, y: 0 };
+};
+
+/**
+ * Get the active coordinate in the polar coordinate system. Internally we only
+ * use x and y, but the returned object is public API (it goes straight to the
+ * tooltip content) so we keep the other properties for backwards compatibility.
+ */
+export const getActivePolarCoordinate = (
+  layout: PolarLayout,
+  tooltipTicks: readonly TickItem[],
+  activeIndex: number | undefined,
+  rangeObj: RangeObj,
+): PolarCoordinate => {
+  const entry = tooltipTicks.find((tick) => tick && tick.index === activeIndex);
+
+  if (entry) {
+    if (layout === "centric") {
+      const angle = entry.coordinate;
+      const { radius } = rangeObj;
+
+      return {
+        ...rangeObj,
+        ...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+        angle,
+        radius,
+      };
+    }
+
+    const radius = entry.coordinate;
+    const { angle } = rangeObj;
+
+    return {
+      ...rangeObj,
+      ...polarToCartesian(rangeObj.cx, rangeObj.cy, radius, angle),
+      angle,
+      radius,
+    };
+  }
+
+  return {
+    angle: 0,
+    clockWise: false,
+    cx: 0,
+    cy: 0,
+    endAngle: 0,
+    innerRadius: 0,
+    outerRadius: 0,
+    radius: 0,
+    startAngle: 0,
+    x: 0,
+    y: 0,
+  };
+};
+
+export function isInCartesianRange(pointer: RelativePointer, offset: ChartOffsetInternal): boolean {
+  const { relativeX: x, relativeY: y } = pointer;
+  return (
+    x >= offset.left &&
+    x <= offset.left + offset.width &&
+    y >= offset.top &&
+    y <= offset.top + offset.height
+  );
+}
+
+export const calculateActiveTickIndex = (
+  /**
+   * For different layouts, `coordinate` is different: horizontal → `x`,
+   * vertical → `y`, centric → angle, radial → radius.
+   */
+  coordinate: number | undefined,
+  ticks: ReadonlyArray<TickItem> | undefined,
+  unsortedTicks: ReadonlyArray<TickItem>,
+  axisType: AxisType | undefined,
+  range: AxisRange | undefined,
+): number | undefined => {
+  const len = ticks?.length ?? 0;
+
+  // With 1 or fewer ticks, or no coordinate, the active tick is at index 0.
+  if (len <= 1 || coordinate == null) {
+    return 0;
+  }
+
+  if (
+    axisType === "angleAxis" &&
+    range != null &&
+    Math.abs(Math.abs(range[1] - range[0]) - 360) <= 1e-6
+  ) {
+    // ticks are distributed in a circle
+    for (let i = 0; i < len; i++) {
+      const before = i > 0 ? unsortedTicks[i - 1]?.coordinate : unsortedTicks[len - 1]?.coordinate;
+      const cur = unsortedTicks[i]?.coordinate;
+      const after = i >= len - 1 ? unsortedTicks[0]?.coordinate : unsortedTicks[i + 1]?.coordinate;
+      let sameDirectionCoord: number;
+
+      if (before == null || cur == null || after == null) {
+        continue;
+      }
+
+      if (mathSign(cur - before) !== mathSign(after - cur)) {
+        const diffInterval: number[] = [];
+        if (mathSign(after - cur) === mathSign(range[1] - range[0])) {
+          sameDirectionCoord = after;
+
+          const curInRange = cur + range[1] - range[0];
+          diffInterval[0] = Math.min(curInRange, (curInRange + before) / 2);
+          diffInterval[1] = Math.max(curInRange, (curInRange + before) / 2);
+        } else {
+          sameDirectionCoord = before;
+
+          const afterInRange = after + range[1] - range[0];
+          diffInterval[0] = Math.min(cur, (afterInRange + cur) / 2);
+          diffInterval[1] = Math.max(cur, (afterInRange + cur) / 2);
+        }
+        const sameInterval: [number, number] = [
+          Math.min(cur, (sameDirectionCoord + cur) / 2),
+          Math.max(cur, (sameDirectionCoord + cur) / 2),
+        ];
+
+        if (
+          (coordinate > sameInterval[0] && coordinate <= sameInterval[1]) ||
+          (diffInterval[0] != null &&
+            diffInterval[1] != null &&
+            coordinate >= diffInterval[0] &&
+            coordinate <= diffInterval[1])
+        ) {
+          return unsortedTicks[i]?.index;
+        }
+      } else {
+        const minValue = Math.min(before, after);
+        const maxValue = Math.max(before, after);
+
+        if (coordinate > (minValue + cur) / 2 && coordinate <= (maxValue + cur) / 2) {
+          return unsortedTicks[i]?.index;
+        }
+      }
+    }
+  } else if (ticks) {
+    // ticks are distributed in a single direction
+    for (let i = 0; i < len; i++) {
+      const curr = ticks[i];
+      if (curr == null) {
+        continue;
+      }
+      const next = ticks[i + 1];
+      const prev = ticks[i - 1];
+
+      if (i === 0 && next != null && coordinate <= (curr.coordinate + next.coordinate) / 2) {
+        return curr.index;
+      }
+
+      if (i === len - 1 && prev != null && coordinate > (curr.coordinate + prev.coordinate) / 2) {
+        return curr.index;
+      }
+
+      if (
+        i > 0 &&
+        i < len - 1 &&
+        prev != null &&
+        next != null &&
+        coordinate > (curr.coordinate + prev.coordinate) / 2 &&
+        coordinate <= (curr.coordinate + next.coordinate) / 2
+      ) {
+        return curr.index;
+      }
+    }
+  }
+
+  return -1;
+};

package/src/util/getAxisTypeBasedOnLayout.ts

@@ -0,0 +1,21 @@
+// Ported from recharts 3.8.1 src/util/getAxisTypeBasedOnLayout.ts (commit 7a23854).
+import { AxisDomainTypeInput, AxisType, EvaluatedAxisDomainType, LayoutType } from "./types";
+import { isCategoricalAxis } from "./ChartUtils";
+
+/**
+ * Evaluates the "auto" axis domain type based on the chart layout and axis type,
+ * producing a definitive axis domain type for further processing.
+ */
+export function getAxisTypeBasedOnLayout(
+  layout: LayoutType | undefined,
+  axisType: AxisType,
+  axisDomainType: AxisDomainTypeInput,
+): EvaluatedAxisDomainType | undefined {
+  if (axisDomainType !== "auto") {
+    return axisDomainType;
+  }
+  if (layout == null) {
+    return undefined;
+  }
+  return isCategoricalAxis(layout, axisType) ? "category" : "number";
+}

package/src/util/getEveryNth.ts

@@ -0,0 +1,30 @@
+// Ported from recharts 3.8.1 src/util/getEveryNth.ts.
+// Pure array util — no framework surface — so behavior is byte-identical to recharts.
+
+/**
+ * Given an array and a number N, return a new array which contains every nTh
+ * element of the input array. For n below 1, an empty array is returned.
+ * For n equal to 1, the input array is returned as is.
+ * For n greater than the length of the array, an array containing the first element
+ * and every nTh element after that (if any) is returned.
+ *
+ * @param array An input array.
+ * @param n A number specifying which elements to take.
+ * @returns The result array of the same type as the input array.
+ */
+export function getEveryNth<Type>(array: ReadonlyArray<Type>, n: number): ReadonlyArray<Type> {
+  if (n < 1) {
+    return [];
+  }
+  if (n === 1) {
+    return array;
+  }
+  const result: Type[] = [];
+  for (let i = 0; i < array.length; i += n) {
+    const item = array[i];
+    if (item !== undefined) {
+      result.push(item);
+    }
+  }
+  return result;
+}

package/src/util/getRadiusAndStrokeWidthFromDot.ts

@@ -0,0 +1,35 @@
+// Ported from recharts 3.8.1 src/util/getRadiusAndStrokeWidthFromDot.tsx (commit 7a23854).
+// No JSX → `.ts`.
+import { ActiveDotType, DotType } from "./types";
+import { svgPropertiesNoEventsFromUnknown } from "./svgPropertiesNoEvents";
+
+export function getRadiusAndStrokeWidthFromDot(dot: ActiveDotType | DotType): {
+  r: number;
+  strokeWidth: number;
+} {
+  const props = svgPropertiesNoEventsFromUnknown(dot);
+  const defaultR = 3;
+  const defaultStrokeWidth = 2;
+  if (props != null) {
+    // `svgPropertiesNoEvents` now renames camelCase keys to SVG attribute names,
+    // so `strokeWidth` arrives as `stroke-width` (`r` is unchanged).
+    const r = props.r;
+    const strokeWidth = props["stroke-width"];
+    let realR = Number(r);
+    let realStrokeWidth = Number(strokeWidth);
+    if (Number.isNaN(realR) || realR < 0) {
+      realR = defaultR;
+    }
+    if (Number.isNaN(realStrokeWidth) || realStrokeWidth < 0) {
+      realStrokeWidth = defaultStrokeWidth;
+    }
+    return {
+      r: realR,
+      strokeWidth: realStrokeWidth,
+    };
+  }
+  return {
+    r: defaultR,
+    strokeWidth: defaultStrokeWidth,
+  };
+}