Reviewing files that changed from the base of the PR and between 8ae7d8b and f1f8ec2.

• eslint.config.mjs
• src/cartesian/Area.tsx
• src/cartesian/Bar.tsx
• src/chart/Sankey.tsx
• src/component/LabelList.tsx
• src/component/Text.tsx
• src/polar/Pie.tsx
• src/polar/RadialBar.tsx
• src/state/chartDataSlice.ts
• src/state/selectors/areaSelectors.ts
• src/state/types/AreaSettings.ts
• src/util/ChartUtils.ts
• src/util/getTypedValue.ts
• src/util/scale/getNiceTickValues.ts
• src/util/scale/util/utils.ts
• src/util/types.ts
• test/cartesian/Area.spec.tsx
• test/cartesian/Area.typed.spec.tsx
• test/state/selectors/axisSelectors.spec.tsx
• test/state/selectors/dataSelectors.spec.tsx
• test/state/selectors/selectors.spec.tsx
• test/util/ChartUtils/truncateByDomain.spec.ts
• test/util/getTypedValue.spec.tsx
• test/util/scale/utils.spec.ts

• src/util/scale/util/utils.ts
• test/util/scale/utils.spec.ts

• GitHub Check: Build, Test, Pack

src/state/selectors/areaSelectors.ts (1)

27-27: Type change appropriately widens value property.

The change from [number, number] to ReadonlyArray<unknown> aligns with the PR's typed data access goals, enabling more flexible value extraction while preserving readonly semantics.

test/state/selectors/dataSelectors.spec.tsx (1)

54-59: Test data correctly updated for typed dataKey pattern.

The change from primitive arrays to object arrays with explicit dataKey props properly demonstrates the typed data access pattern introduced in this PR.

src/state/chartDataSlice.ts (1)

15-15: Generic type parameter enhances type safety while maintaining backward compatibility.

The addition of the generic parameter with default T = unknown enables better type inference for consumers while preserving all existing usage patterns.

test/state/selectors/axisSelectors.spec.tsx (1)

170-170: Test data systematically updated for typed dataKey pattern.

All Area components have been consistently updated to use object-based data with explicit dataKey props, properly testing the new typed data access pattern while maintaining comprehensive coverage of axis selector behavior.

Also applies to: 235-235, 470-470, 1414-1415, 1464-1464

test/util/ChartUtils/truncateByDomain.spec.ts (1)

13-17: Test expectations correctly updated for new return type.

The changes properly verify that truncateByDomain now returns undefined for invalid or NaN domains, aligning with the updated function signature [number, number] | undefined.

Also applies to: 56-60

test/state/selectors/selectors.spec.tsx (1)

1230-1249: LGTM! Test data extraction improves readability.

Extracting the inline data arrays into named variables data1 and data2 makes the test more readable and maintainable. The test logic remains unchanged.

src/util/types.ts (1)

37-37: LGTM! Core type alias for typed data access.

The change from the previous DataKey<T> definition to aliasing TypedDataKey<T> is the foundation for the typed data key functionality described in the PR objectives. This enables TypeScript to enforce the relationship between data and dataKey within components.

Also applies to: 94-94

eslint.config.mjs (1)

473-486: LGTM! Strict typing enforcement for scale utilities.

The new neverAny ESLint configuration enforces stricter TypeScript rules for the src/util/scale/** directory. This prevents the use of any, TypeScript comment pragmas, and type assertions, ensuring proper typing in utility code.

As per coding guidelines, this aligns with the requirement to avoid any types in TypeScript code.

Also applies to: 515-515

src/polar/Pie.tsx (1)

66-66: LGTM! Adoption of typed data value extraction.

The change from getValueByDataKey to getTypedValue aligns with the PR's systematic replacement of data extraction utilities with the new typed approach. This maintains the same runtime behavior while enabling better TypeScript support for label rendering.

Also applies to: 607-607

test/cartesian/Area.spec.tsx (1)

652-652: LGTM! Test data aligned with typed data access pattern.

The test data structure has been updated from primitive arrays [1, 2, 3] to object arrays [{ value: 1 }, { value: 2 }, { value: 3 }], which is necessary for the dataKey="value" extraction to work correctly with the new typed data access approach. Both occurrences are updated consistently.

Also applies to: 704-704

src/state/types/AreaSettings.ts (1)

5-5: LGTM! Type upgrade aligns with PR objectives.

The change from DataKey<any> to TypedDataKey implements the stricter typing described in the PR. This enables IDE autocomplete and type safety for the dataKey property while maintaining backward compatibility.

Also applies to: 12-12

src/polar/RadialBar.tsx (1)

645-645: LGTM! Data extraction updated to use typed utility.

The replacement of getValueByDataKey with getTypedValue aligns with the PR's goal of introducing stricter typing while maintaining functional equivalence.

src/component/Text.tsx (1)

77-79: LGTM! Runtime type guard complements compile-time types.

The new isRenderableText guard correctly validates values against the RenderableText type, enabling safer runtime checks in rendering paths. The implementation properly covers all union members: nullish values (via isNullish) and string/number/boolean primitives.

test/util/getTypedValue.spec.tsx (1)

1-235: LGTM! Comprehensive test coverage for new utility.

The test suite thoroughly covers getTypedValue functionality:

• Object and array data access (string/numeric keys, nested paths)
• Default value fallbacks
• Edge cases (undefined, null, NaN)
• Function-based accessors
• Compile-time type inference validation

The type inference tests are particularly valuable for verifying TypeScript behavior with TypedDataKey.

src/cartesian/Bar.tsx (2)

89-89: LGTM!

Import of getTypedValue is correct and aligns with the PR's goal of migrating to typed data access.

---

987-1014: Type-safe data extraction and null-safety improvements look good.

The changes properly:

1. Update stackedDomain to ReadonlyArray<unknown> | null to match the updated truncateByDomain signature
2. Add explicit null check after truncateByDomain (lines 1002-1004) since it now returns undefined for invalid domains
3. Use getTypedValue for raw value extraction in the non-stacked path

One consideration: value[1] on line 1016 is now unknown rather than a number. The minPointSizeCallback includes explicit runtime validation—it checks that the value is numeric or null/undefined and throws an invariant assertion if not. This validation ensures correctness at runtime, though TypeScript loses type information at the call site.

test/cartesian/Area.typed.spec.tsx (4)

1-4: LGTM!

Imports are correct. The test file properly uses the public API entry point for Area and AreaChart as required by coding guidelines, while internal test helpers are imported from relative paths (which is allowed for test files per learnings).

---

22-40: Well-structured backward compatibility tests.

The test suite appropriately documents the limitations of TypeScript's contextual typing—when data is on AreaChart and dataKey is on Area, type checking cannot connect them. The comments clearly explain this is expected behavior for backward compatibility.

---

132-148: Good use of @ts-expect-error for compile-time validation.

The tests at lines 140-143 correctly use @ts-expect-error to verify that TypeScript catches mismatched dataKeys when data is defined directly on Area. This validates the PR's typing improvements work as intended.

---

151-240: Comprehensive explicit type parameter tests.

The tests for <Area<ExampleDataPoint>> and <Area<ExampleDataPoint, number>> validate the new generic type parameters work correctly. The @ts-expect-error assertions confirm TypeScript catches type mismatches at compile time.

src/util/ChartUtils.ts (2)

44-46: Good deprecation notice.

The @deprecated JSDoc appropriately guides users to the new getTypedValue utility. This supports the gradual migration path mentioned in the PR objectives.

---

296-324: Breaking change in truncateByDomain return type correctly implemented.

The function now returns undefined instead of the original value when the domain is invalid. This is a safer approach that forces callers to handle the error case explicitly.

The changes are:

1. domain parameter now accepts ReadonlyArray<unknown> | null | undefined
2. Return type changed to [number, number] | undefined
3. Invalid domain returns undefined (line 301)

All callers have been updated to handle the new return type:

• src/cartesian/Bar.tsx:1002 checks if (truncated == null) before using the value
• src/polar/RadialBar.tsx:640 checks if (truncated == null) before using the value

src/component/LabelList.tsx (4)

11-12: LGTM!

Imports correctly bring in the new typed utilities for value extraction and renderability checking.

---

19-19: Broadening value type to unknown is appropriate.

This change acknowledges that the value can come from arbitrary user data. The runtime isRenderableText checks (lines 155, 197) ensure only valid text types are rendered. This is a safer pattern than assuming the type at compile time.

---

151-159: Defensive defaultAccessor implementation.

The accessor now properly:

1. Handles array values by extracting the last element
2. Validates renderability before returning
3. Returns undefined for non-renderable values

This prevents runtime errors from attempting to render objects or other non-text types.

---

193-199: Type-safe value extraction with renderability guard.

The updated logic:

1. Uses getTypedValue for typed data access when dataKey is provided
2. Guards against non-renderable values with isRenderableText check
3. Returns null early to skip rendering invalid values

This is a robust pattern that prevents rendering failures.

src/util/getTypedValue.ts (3)

4-20: Well-designed TypedDataKey type.

The conditional type handles multiple scenarios elegantly:

1. Falls back to loose typing when T is any or unknown
2. Supports legacy string-indexed types
3. Provides strict key inference for well-typed objects
4. Supports array index access via template literal `${number}`
5. Allows function accessors

The use of any on line 8 is appropriate per the codebase's intentional exception for DataKey<any> while proper typing is being developed. Based on learnings, this should not be flagged.

---

22-48: Comprehensive function overloads for type inference.

The overloads cover all practical use cases:

• Direct property access (keyof T)
• Function-based extraction
• Array index access
• Generic fallback with explicit return type

This enables TypeScript to infer the correct return type based on how the function is called, improving IDE autocomplete and type safety.

---

49-67: Clean implementation with proper null-safety.

The implementation:

1. Returns defaultValue for nullish inputs (defensive)
2. Uses es-toolkit/compat/get for safe nested property access
3. Invokes function keys directly
4. Falls back gracefully for unsupported key types

This matches the behavior of the deprecated getValueByDataKey while providing better type information.

src/cartesian/Area.tsx (3)

15-16: LGTM!

Import changes correctly replace getValueByDataKey usage with getTypedValue and add TypedDataKey for the typed dataKey prop.

---

1000-1017: Type-safe value extraction in computeArea.

The changes properly:

1. Type valueAsArray as ReadonlyArray<unknown> | undefined to match the typed approach
2. Use getTypedValue(entry, dataKey) for extraction
3. Handle array vs scalar values appropriately
4. Update isBreakPoint calculation to use getTypedValue

This maintains the same runtime behavior while improving type awareness.

---

1111-1115: Type assertion for generic memoized component.

The as assertion on the memoized component is necessary because React.memo doesn't preserve generic type parameters. This pattern is standard for generic React components that need memoization.

The @ts-expect-error on line 1114 for displayName is acceptable since TypeScript doesn't understand that the cast type can have additional properties.