solid-recharts 0.1.0

package/src/state/selectors/combiners/combineTooltipPayload.ts

@@ -0,0 +1,203 @@
+// Ported from recharts 3.8.1 src/state/selectors/combiners/combineTooltipPayload.ts.
+//
+// Deviations (all to remove `any`): values pulled from data via getValueByDataKey
+// are `unknown`, so they're coerced to the declared ValueType/name shapes with
+// the type guards below (recharts leans on `any`); the function-dataKey branch of
+// parseDataKey uses a user-defined type guard instead of a cast. The Scatter
+// "array of arrays" payload path is ported faithfully but only exercised once
+// Scatter lands (Line/Bar/Area take the single-object `else` branch).
+import {
+  TooltipEntrySettings,
+  TooltipIndex,
+  TooltipPayload,
+  TooltipPayloadConfiguration,
+  TooltipPayloadEntry,
+  TooltipPayloadSearcher,
+} from "../../tooltipSlice";
+import { ChartData, ChartDataState } from "../../chartDataSlice";
+import { DataKey, TooltipEventType } from "../../../util/types";
+import { findEntryInArray, isNumOrStr } from "../../../util/DataUtils";
+import { getTooltipEntry, getValueByDataKey } from "../../../util/ChartUtils";
+import { getSliced } from "../../../util/getSliced";
+import { ActiveLabel } from "../../../synchronisation/types";
+import { ValueType } from "../../../component/DefaultTooltipContent";
+
+type TooltipPayloadItemLike = {
+  name: TooltipEntrySettings["name"];
+  unit: TooltipEntrySettings["unit"];
+  dataKey: DataKey<unknown> | undefined;
+  payload: unknown;
+  color: string | undefined;
+  fill: string | undefined;
+};
+
+function isReadonlyArray(value: unknown): value is ReadonlyArray<unknown> {
+  return Array.isArray(value);
+}
+
+function isDataKeyFunction(value: unknown): value is (obj: unknown) => unknown {
+  return typeof value === "function";
+}
+
+/** Coerce an `unknown` data value to the declared ValueType (else undefined). */
+function coerceValueType(value: unknown): ValueType | undefined {
+  if (isNumOrStr(value)) {
+    return value;
+  }
+  if (isReadonlyArray(value) && value.every(isNumOrStr)) {
+    return value;
+  }
+  return undefined;
+}
+
+/** Like reference getValueByDataKey consumption: preserve explicit null for filterNull=false. */
+function tooltipEntryValue(value: unknown): ValueType | null | undefined {
+  if (value === null) {
+    return null;
+  }
+  return coerceValueType(value);
+}
+
+function toName(value: unknown): string | number | undefined {
+  // recharts keeps the raw nameKey value (number or string), not a stringified copy.
+  return isNumOrStr(value) ? value : undefined;
+}
+
+function parseName(value: unknown): TooltipEntrySettings["name"] {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  return undefined;
+}
+
+function parseUnit(value: unknown): TooltipEntrySettings["unit"] {
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  return undefined;
+}
+
+function parseDataKey(value: unknown): DataKey<unknown> | undefined {
+  if (typeof value === "string" || typeof value === "number") {
+    return value;
+  }
+  if (isDataKeyFunction(value)) {
+    return (obj) => value(obj);
+  }
+  return undefined;
+}
+
+function parseColor(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    return value;
+  }
+  return undefined;
+}
+
+function parseTooltipPayloadItem(item: unknown): TooltipPayloadItemLike | undefined {
+  if (item == null || typeof item !== "object") {
+    return undefined;
+  }
+
+  const name = "name" in item ? parseName(item.name) : undefined;
+  const unit = "unit" in item ? parseUnit(item.unit) : undefined;
+  const dataKey = "dataKey" in item ? parseDataKey(item.dataKey) : undefined;
+  const payload = "payload" in item ? item.payload : undefined;
+  const color = "color" in item ? parseColor(item.color) : undefined;
+  const fill = "fill" in item ? parseColor(item.fill) : undefined;
+
+  return { name, unit, dataKey, payload, color, fill };
+}
+
+function selectFinalData(
+  dataDefinedOnItem: unknown,
+  dataDefinedOnChart: ChartData | undefined,
+): unknown {
+  // Prefer the graphical item's own data; otherwise fall back to chart-level data.
+  if (dataDefinedOnItem != null) {
+    return dataDefinedOnItem;
+  }
+  return dataDefinedOnChart;
+}
+
+export const combineTooltipPayload = (
+  tooltipPayloadConfigurations: ReadonlyArray<TooltipPayloadConfiguration>,
+  activeIndex: TooltipIndex,
+  chartDataState: ChartDataState,
+  tooltipAxisDataKey: DataKey<unknown> | undefined,
+  activeLabel: ActiveLabel,
+  tooltipPayloadSearcher: TooltipPayloadSearcher | undefined,
+  tooltipEventType: TooltipEventType | undefined,
+): TooltipPayload | undefined => {
+  if (activeIndex == null || tooltipPayloadSearcher == null) {
+    return undefined;
+  }
+  const { chartData, computedData, dataStartIndex, dataEndIndex } = chartDataState;
+
+  const init: Array<TooltipPayloadEntry> = [];
+
+  return tooltipPayloadConfigurations.reduce(
+    (agg, { dataDefinedOnItem, settings }): Array<TooltipPayloadEntry> => {
+      const finalData = selectFinalData(dataDefinedOnItem, chartData);
+
+      const sliced = isReadonlyArray(finalData)
+        ? getSliced(finalData, dataStartIndex, dataEndIndex)
+        : finalData;
+
+      const finalDataKey: DataKey<unknown> | undefined = settings?.dataKey ?? tooltipAxisDataKey;
+      const finalNameKey: DataKey<unknown> | undefined = settings?.nameKey;
+      let tooltipPayload: unknown;
+      if (
+        tooltipAxisDataKey &&
+        isReadonlyArray(sliced) &&
+        // Scatter provides arrays-of-arrays; findEntryInArray can't handle that.
+        !isReadonlyArray(sliced[0]) &&
+        // 'axis' searches by dataKey + label (order may not match data); 'item'
+        // searches by index.
+        tooltipEventType === "axis"
+      ) {
+        tooltipPayload = findEntryInArray(sliced, tooltipAxisDataKey, activeLabel);
+      } else {
+        tooltipPayload = tooltipPayloadSearcher(sliced, activeIndex, computedData, finalNameKey);
+      }
+
+      if (isReadonlyArray(tooltipPayload)) {
+        tooltipPayload.forEach((item) => {
+          const parsedItem = parseTooltipPayloadItem(item);
+          const itemName = parsedItem?.name;
+          const itemDataKey = parsedItem?.dataKey;
+          const itemPayload = parsedItem?.payload;
+          const newSettings: TooltipEntrySettings = {
+            ...settings,
+            name: itemName,
+            unit: parsedItem?.unit,
+            // Preserve item-level color/fill from graphical items.
+            color: parsedItem?.color ?? settings?.color,
+            fill: parsedItem?.fill ?? settings?.fill,
+          };
+          agg.push(
+            getTooltipEntry({
+              tooltipEntrySettings: newSettings,
+              dataKey: itemDataKey,
+              payload: itemPayload,
+              value: tooltipEntryValue(getValueByDataKey(itemPayload, itemDataKey)),
+              name: itemName,
+            }),
+          );
+        });
+      } else {
+        agg.push(
+          getTooltipEntry({
+            tooltipEntrySettings: settings,
+            dataKey: finalDataKey,
+            payload: tooltipPayload,
+            value: tooltipEntryValue(getValueByDataKey(tooltipPayload, finalDataKey)),
+            name: toName(getValueByDataKey(tooltipPayload, finalNameKey)) ?? toName(settings?.name),
+          }),
+        );
+      }
+      return agg;
+    },
+    init,
+  );
+};

package/src/state/selectors/combiners/combineTooltipPayloadConfigurations.ts

@@ -0,0 +1,45 @@
+// Ported from recharts 3.8.1 src/state/selectors/combiners/combineTooltipPayloadConfigurations.ts.
+import { TooltipIndex, TooltipPayloadConfiguration, TooltipState } from "../../tooltipSlice";
+import { TooltipEventType } from "../../../util/types";
+import { TooltipTrigger } from "../../../chart/types";
+import { GraphicalItemId } from "../../graphicalItemsSlice";
+
+export const combineTooltipPayloadConfigurations = (
+  tooltipState: TooltipState,
+  tooltipEventType: TooltipEventType | undefined,
+  trigger: TooltipTrigger,
+  defaultIndex: TooltipIndex | undefined,
+): ReadonlyArray<TooltipPayloadConfiguration> => {
+  // axis interaction shows all items at the same axis coordinate.
+  if (tooltipEventType === "axis") {
+    return tooltipState.tooltipItemPayloads;
+  }
+  // item interaction shows only the hovered/clicked item.
+  if (tooltipState.tooltipItemPayloads.length === 0) {
+    return [];
+  }
+  let filterByGraphicalItemId: GraphicalItemId | undefined;
+  if (trigger === "hover") {
+    filterByGraphicalItemId = tooltipState.itemInteraction.hover.graphicalItemId;
+  } else {
+    filterByGraphicalItemId = tooltipState.itemInteraction.click.graphicalItemId;
+  }
+  if (tooltipState.syncInteraction.active && filterByGraphicalItemId == null) {
+    // Synchronised from another chart: show all items at the synced index.
+    return tooltipState.tooltipItemPayloads;
+  }
+  if (
+    filterByGraphicalItemId == null &&
+    (defaultIndex != null || tooltipState.keyboardInteraction.active)
+  ) {
+    // With defaultIndex/keyboard but no hovered item, show the first item.
+    const firstItemPayload = tooltipState.tooltipItemPayloads[0];
+    if (firstItemPayload != null) {
+      return [firstItemPayload];
+    }
+    return [];
+  }
+  return tooltipState.tooltipItemPayloads.filter(
+    (tpc) => tpc.settings?.graphicalItemId === filterByGraphicalItemId,
+  );
+};

package/src/state/selectors/containerSelectors.ts

@@ -0,0 +1,12 @@
+// Ported from recharts 3.8.1 src/state/selectors/containerSelectors.ts (commit 7a23854).
+// Solid-native: plain selector functions (memoization comes from `useAppSelector`'s createMemo).
+import { RechartsRootState } from "../store";
+import { Margin } from "../../util/types";
+
+export const selectChartWidth = (state: RechartsRootState): number => state.layout.width;
+
+export const selectChartHeight = (state: RechartsRootState): number => state.layout.height;
+
+export const selectContainerScale = (state: RechartsRootState): number => state.layout.scale;
+
+export const selectMargin = (state: RechartsRootState): Margin => state.layout.margin;

package/src/state/selectors/dataSelectors.ts

@@ -0,0 +1,90 @@
+// Ported from recharts 3.8.1 src/state/selectors/dataSelectors.ts (commit 7a23854).
+//
+// Solid-native: plain selector functions, no reselect. recharts wraps several of
+// these in `createSelector` purely for memoization (to swallow spurious Immer
+// reference churn); in the Solid store, memoization comes from `useAppSelector`'s
+// `createMemo` at the consumer, so these stay plain functions. Behavior is
+// identical.
+import { RechartsRootState } from "../store";
+import { ChartData, ChartDataState } from "../chartDataSlice";
+
+/**
+ * Always returns the data with the indexes set by a Brush. That might or might
+ * not be what you want — in charts with Brush you sometimes want the full range
+ * (e.g. the panorama inside the Brush). Prefer
+ * {@link selectChartDataAndAlwaysIgnoreIndexes} or
+ * {@link selectChartDataWithIndexesIfNotInPanoramaPosition4} when that matters.
+ */
+export const selectChartDataWithIndexes = (state: RechartsRootState): ChartDataState =>
+  state.chartData;
+
+/**
+ * Always returns the full range of data, ignoring Brush indexes. Useful for the
+ * Brush panorama, Legend, and Tooltip.
+ */
+export const selectChartDataAndAlwaysIgnoreIndexes = (state: RechartsRootState): ChartDataState => {
+  const dataState = selectChartDataWithIndexes(state);
+  const dataEndIndex = dataState.chartData != null ? dataState.chartData.length - 1 : 0;
+  return {
+    chartData: dataState.chartData,
+    computedData: dataState.computedData,
+    dataEndIndex,
+    dataStartIndex: 0,
+  };
+};
+
+export const selectChartDataWithIndexesIfNotInPanoramaPosition4 = (
+  state: RechartsRootState,
+  _unused1: unknown,
+  _unused2: unknown,
+  isPanorama: boolean,
+): ChartDataState => {
+  if (isPanorama) {
+    return selectChartDataAndAlwaysIgnoreIndexes(state);
+  }
+  return selectChartDataWithIndexes(state);
+};
+
+export const selectChartDataWithIndexesIfNotInPanoramaPosition3 = (
+  state: RechartsRootState,
+  _unused1: unknown,
+  isPanorama: boolean,
+): ChartDataState => {
+  if (isPanorama) {
+    return selectChartDataAndAlwaysIgnoreIndexes(state);
+  }
+  return selectChartDataWithIndexes(state);
+};
+
+/**
+ * Returns the chart-level data slice (respecting Brush indexes). Used when a
+ * selector needs chart-level data.
+ */
+export const selectChartDataSliceIfNotInPanorama = (
+  state: RechartsRootState,
+  _unused1: unknown,
+  _unused2: unknown,
+  isPanorama: boolean,
+): ChartData => {
+  const { chartData, dataStartIndex, dataEndIndex } =
+    selectChartDataWithIndexesIfNotInPanoramaPosition4(state, _unused1, _unused2, isPanorama);
+  return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+};
+
+/**
+ * Returns the chart-level data slice (ignoring Brush indexes). Used in tooltip
+ * and polar selectors that always need the full data range.
+ */
+export const selectChartDataSliceIgnoringIndexes = (state: RechartsRootState): ChartData => {
+  const { chartData, dataStartIndex, dataEndIndex } = selectChartDataAndAlwaysIgnoreIndexes(state);
+  return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+};
+
+/**
+ * Returns the chart-level data slice (with Brush indexes applied). Used in
+ * tooltip selectors.
+ */
+export const selectChartDataSliceWithIndexes = (state: RechartsRootState): ChartData => {
+  const { chartData, dataStartIndex, dataEndIndex } = selectChartDataWithIndexes(state);
+  return chartData != null ? chartData.slice(dataStartIndex, dataEndIndex + 1) : [];
+};

package/src/state/selectors/funnelSelectors.ts

@@ -0,0 +1,83 @@
+// Ported from recharts 3.8.1 src/state/selectors/funnelSelectors.ts (commit 7a23854).
+// Solid-native plain selector (no reselect). The funnel settings are RESOLVED FROM
+// PROPS (not a graphical-items slice) and passed in directly — the only store reads
+// are the chart offset and chart-level data. Cells + per-row presentation merge here,
+// mirroring the reference (cell props win over data, which wins over presentation).
+import { computeFunnelTrapezoids, FunnelTrapezoidItem } from "../../cartesian/Funnel";
+import { ChartData } from "../chartDataSlice";
+import { RechartsRootState } from "../store";
+import { selectChartOffsetInternal } from "./selectChartOffsetInternal";
+import { selectChartDataAndAlwaysIgnoreIndexes } from "./dataSelectors";
+import { DataKey, TooltipType } from "../../util/types";
+import type { CellProps } from "../../component/Cell";
+import { GraphicalItemId } from "../graphicalItemsSlice";
+
+export type ResolvedFunnelSettings = {
+  dataKey: DataKey<unknown> | undefined;
+  data: ChartData | undefined;
+  nameKey: DataKey<unknown> | undefined;
+  tooltipType?: TooltipType;
+  lastShapeType?: "triangle" | "rectangle";
+  reversed?: boolean;
+  customWidth?: string | number;
+  cells: ReadonlyArray<CellProps>;
+  presentationProps: Record<string, unknown> | null;
+  id: GraphicalItemId;
+};
+
+/** Spread an unknown data entry into a plain record (`{}` for non-objects). */
+const toRecord = (entry: unknown): Record<string, unknown> =>
+  typeof entry === "object" && entry != null ? { ...entry } : {};
+
+export const selectFunnelTrapezoids = (
+  state: RechartsRootState,
+  funnelSettings: ResolvedFunnelSettings,
+): ReadonlyArray<FunnelTrapezoidItem> => {
+  const offset = selectChartOffsetInternal(state);
+  const { chartData } = selectChartDataAndAlwaysIgnoreIndexes(state);
+  const {
+    data,
+    dataKey,
+    nameKey,
+    tooltipType,
+    lastShapeType,
+    reversed,
+    customWidth,
+    cells,
+    presentationProps,
+    id: graphicalItemId,
+  } = funnelSettings;
+
+  let source: ChartData | undefined;
+  if (data != null && data.length > 0) {
+    source = data;
+  } else if (chartData != null && chartData.length > 0) {
+    source = chartData;
+  }
+
+  let displayedData: ReadonlyArray<Record<string, unknown>>;
+  if (source && source.length > 0) {
+    displayedData = source.map((entry, index) => ({
+      payload: entry,
+      ...presentationProps,
+      ...toRecord(entry),
+      ...toRecord(cells[index]),
+    }));
+  } else if (cells.length > 0) {
+    displayedData = cells.map((cell) => ({ ...presentationProps, ...toRecord(cell) }));
+  } else {
+    return [];
+  }
+
+  return computeFunnelTrapezoids({
+    dataKey,
+    nameKey,
+    displayedData,
+    tooltipType,
+    lastShapeType,
+    reversed,
+    offset,
+    customWidth,
+    graphicalItemId,
+  });
+};

package/src/state/selectors/graphicalItemSelectors.ts

@@ -0,0 +1,23 @@
+// Ported from recharts 3.8.1 src/state/selectors/graphicalItemSelectors.ts
+// (commit 7a23854). Solid-native plain selectors.
+import { RechartsRootState } from "../store";
+import { GraphicalItemId } from "../graphicalItemsSlice";
+import { AxisId, defaultAxisId } from "../cartesianAxisSlice";
+
+export function selectXAxisIdFromGraphicalItemId(
+  state: RechartsRootState,
+  id: GraphicalItemId,
+): AxisId {
+  return (
+    state.graphicalItems.cartesianItems.find((item) => item.id === id)?.xAxisId ?? defaultAxisId
+  );
+}
+
+export function selectYAxisIdFromGraphicalItemId(
+  state: RechartsRootState,
+  id: GraphicalItemId,
+): AxisId {
+  return (
+    state.graphicalItems.cartesianItems.find((item) => item.id === id)?.yAxisId ?? defaultAxisId
+  );
+}

package/src/state/selectors/legendSelectors.ts

@@ -0,0 +1,29 @@
+// Ported from recharts 3.8.1 src/state/selectors/legendSelectors.ts (commit 7a23854).
+// Deviation: payload is stored as `{ id, items }[]` (proxy-safe ids) so the flat
+// selector flatMaps `items` rather than `flat(1)`-ing a 2D array.
+import { sortBy } from "../../util/collectionUtils";
+import { RechartsRootState } from "../store";
+import { LegendSettings } from "../legendSlice";
+import { LegendItemSorter, LegendPayload } from "../../component/DefaultLegendContent";
+import { Size } from "../../util/types";
+
+export const selectLegendSettings = (state: RechartsRootState): LegendSettings =>
+  state.legend.settings;
+
+export const selectLegendSize = (state: RechartsRootState): Size => state.legend.size;
+
+export const selectLegendPayload = (state: RechartsRootState): ReadonlyArray<LegendPayload> => {
+  const flat = state.legend.payload.flatMap((entry) => entry.items);
+  const { itemSorter } = selectLegendSettings(state);
+  return sortByLegendItemSorter(flat, itemSorter);
+};
+
+function sortByLegendItemSorter(
+  items: ReadonlyArray<LegendPayload>,
+  itemSorter: LegendItemSorter | null,
+): ReadonlyArray<LegendPayload> {
+  if (itemSorter == null) {
+    return items;
+  }
+  return sortBy(items, [itemSorter]);
+}

package/src/state/selectors/lineSelectors.ts

@@ -0,0 +1,111 @@
+// Ported from recharts 3.8.1 src/state/selectors/lineSelectors.ts (commit 7a23854).
+// Solid-native: plain selector functions (memoization comes from useAppSelector's
+// createMemo at the consumer).
+import { computeLinePoints, LinePointItem } from "../../cartesian/Line";
+import { RechartsRootState } from "../store";
+import { AxisId } from "../cartesianAxisSlice";
+import { selectChartDataWithIndexesIfNotInPanoramaPosition4 } from "./dataSelectors";
+import { selectChartLayout } from "../../context/chartLayoutContext";
+import {
+  selectAxisWithScale,
+  selectTicksOfGraphicalItem,
+  selectUnfilteredCartesianItems,
+} from "./axisSelectors";
+import { getBandSizeOfAxis, isCategoricalAxis } from "../../util/ChartUtils";
+import { ChartData } from "../chartDataSlice";
+import { CartesianGraphicalItemSettings, GraphicalItemId } from "../graphicalItemsSlice";
+import { LineSettings } from "../types/LineSettings";
+
+const selectBandSize = (
+  state: RechartsRootState,
+  xAxisId: AxisId,
+  yAxisId: AxisId,
+  isPanorama: boolean,
+): number | undefined => {
+  const layout = selectChartLayout(state);
+  if (isCategoricalAxis(layout, "xAxis")) {
+    return getBandSizeOfAxis(
+      selectAxisWithScale(state, "xAxis", xAxisId, isPanorama),
+      selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama),
+      false,
+    );
+  }
+  return getBandSizeOfAxis(
+    selectAxisWithScale(state, "yAxis", yAxisId, isPanorama),
+    selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama),
+    false,
+  );
+};
+
+function isLineSettings(item: CartesianGraphicalItemSettings): item is LineSettings {
+  return item.type === "line";
+}
+
+/*
+ * There is a race condition where we read some data from props and some from the
+ * state. The state is updated through a dispatch and is one render behind, so we
+ * always read the dataKey from the state here.
+ */
+const selectSynchronisedLineSettings = (
+  state: RechartsRootState,
+  id: GraphicalItemId,
+): LineSettings | undefined =>
+  selectUnfilteredCartesianItems(state)
+    .filter(isLineSettings)
+    .find((x) => x.id === id);
+
+export const selectLinePoints = (
+  state: RechartsRootState,
+  xAxisId: AxisId,
+  yAxisId: AxisId,
+  isPanorama: boolean,
+  id: GraphicalItemId,
+): ReadonlyArray<LinePointItem> | undefined => {
+  const layout = selectChartLayout(state);
+  const xAxis = selectAxisWithScale(state, "xAxis", xAxisId, isPanorama);
+  const yAxis = selectAxisWithScale(state, "yAxis", yAxisId, isPanorama);
+  const xAxisTicks = selectTicksOfGraphicalItem(state, "xAxis", xAxisId, isPanorama);
+  const yAxisTicks = selectTicksOfGraphicalItem(state, "yAxis", yAxisId, isPanorama);
+  const lineSettings = selectSynchronisedLineSettings(state, id);
+  const bandSize = selectBandSize(state, xAxisId, yAxisId, isPanorama);
+  const { chartData, dataStartIndex, dataEndIndex } =
+    selectChartDataWithIndexesIfNotInPanoramaPosition4(state, xAxisId, yAxisId, isPanorama);
+
+  if (
+    lineSettings == null ||
+    xAxis == null ||
+    yAxis == null ||
+    xAxisTicks == null ||
+    yAxisTicks == null ||
+    xAxisTicks.length === 0 ||
+    yAxisTicks.length === 0 ||
+    bandSize == null ||
+    (layout !== "horizontal" && layout !== "vertical")
+  ) {
+    return undefined;
+  }
+
+  const { dataKey, data } = lineSettings;
+  let displayedData: ChartData | undefined;
+
+  if (data != null && data.length > 0) {
+    displayedData = data;
+  } else {
+    displayedData = chartData?.slice(dataStartIndex, dataEndIndex + 1);
+  }
+
+  if (displayedData == null) {
+    return undefined;
+  }
+
+  return computeLinePoints({
+    layout,
+    xAxis,
+    yAxis,
+    xAxisTicks,
+    yAxisTicks,
+    dataKey,
+    bandSize,
+    displayedData,
+  });
+};

package/src/state/selectors/numberDomainEqualityCheck.ts

@@ -0,0 +1,8 @@
+// SKIPPED — intentionally NOT ported to the SolidJS port.
+//
+// Reason: reselect resultEqualityCheck — Solid memoizes via createMemo, not needed
+//
+// TODO: do not port this file as-is. The Solid-native port replaces it (see the
+// reason above). If a consumer needs this path, wire it to the Solid equivalent
+// instead. Tracked in scripts/porting-queue.mjs SKIP list and project memory.
+export {};

package/src/state/selectors/pickAxisId.ts

@@ -0,0 +1,6 @@
+// Ported from recharts 3.8.1 src/state/selectors/pickAxisId.ts (commit 7a23854).
+import { RechartsRootState } from "../store";
+import { AxisId } from "../cartesianAxisSlice";
+
+export const pickAxisId = (_state: RechartsRootState, _axisType: unknown, axisId: AxisId): AxisId =>
+  axisId;

package/src/state/selectors/pickAxisType.ts

@@ -0,0 +1,4 @@
+// Ported from recharts 3.8.1 src/state/selectors/pickAxisType.ts (commit 7a23854).
+import { RechartsRootState } from "../store";
+
+export const pickAxisType = <T>(_state: RechartsRootState, axisType: T): T => axisType;