@eifi1/ui-kit 0.52.0 → 0.54.0

package/dist/components/series-chart.d.ts

@@ -10,7 +10,14 @@ export { AXIS_TICK_WIDTH, AXIS_TITLE_STRIP, anchoredBand, axisBandWidth, mergeSe
 export type { SeriesSource } from "./series-chart-axes.js";
 import { type ChartTooltipPlacement, type LabelOverride } from "../i18n/kit-labels.js";
 import { type ChartHeight } from "./chart-height.js";
-export interface SeriesChartSeries {
+/**
+ * One line, area or bar run of a {@link SeriesChart}.
+ *
+ * `TRow` is the chart's row type (0.53, keksdose after 0.52), and only `dot` reads it: its
+ * `point.row` is that type. Without a type argument a series is what it was, and a chart
+ * of typed rows still takes it — see {@link SeriesChartProps}.
+ */
+export interface SeriesChartSeries<TRow extends object = object> {
     /** The row key this line reads — and the `--color-<key>` it is painted with, so it
      *  must be a CSS identifier. Build keys out of data with {@link seriesKey}. */
     key: string;
@@ -58,8 +65,9 @@ export interface SeriesChartSeries {
      * point: `true` for the default dot, `false`/`null` for none, or any SVG node drawn
      * as-is at `point.cx`/`point.cy` — a buy/sell marker on keksdose's paper price.
      * Never called for a point with no value. Bars have no points, and ignore it.
+     * `point.row` is the caller's own row, typed as the chart's rows are (0.53).
      */
-    dot?: boolean | ((point: SeriesChartPoint) => ReactNode);
+    dot?: boolean | ((point: SeriesChartPoint<TRow>) => ReactNode);
     /** Line (or area outline) weight in px. Default 2, or 1.5 for a `step`. keksdose
      *  draws the subject of a chart at 2.5 and the reference it is read against at 1.5. */
     strokeWidth?: number;
@@ -94,14 +102,16 @@ export interface SeriesChartSeries {
 }
 /** What a series draws. See {@link SeriesChartSeries.type}. */
 export type SeriesChartType = "line" | "bar" | "area";
-/** One point of a series, as a `dot` function is handed it. */
-export interface SeriesChartPoint {
+/** One point of a series, as a `dot` function is handed it. `TRow` is the chart's row
+ *  type (0.53); without one, `row` is a {@link SeriesChartRow}, as before. */
+export interface SeriesChartPoint<TRow extends object = object> {
     /** The series' key. */
     key: string;
     /** The row's position in `rows`. */
     index: number;
-    /** The caller's own row, with everything the chart did not plot still in it. */
-    row: SeriesChartRow;
+    /** The caller's own row, with everything the chart did not plot still in it: the very
+     *  object in `rows`, typed as `rows` is. */
+    row: SeriesChartRowOf<TRow>;
     /** The abscissa in the caller's terms: the number, the category, or (time) a Date. */
     x: SeriesChartXValue;
     value: number;
@@ -113,8 +123,26 @@ export interface SeriesChartPoint {
 }
 /** A row of a series chart: one abscissa value and the series' values at it. Anything
  *  else in it (a raw ISO period for a drilldown) rides along untouched and is handed
- *  back in {@link SeriesChartPoint.row} and {@link SeriesChartHit.row}. */
+ *  back in {@link SeriesChartPoint.row} and {@link SeriesChartHit.row} — typed as the
+ *  caller's rows are since 0.53, and as this where their type names no keys. */
 export type SeriesChartRow = Readonly<Record<string, unknown>>;
+/**
+ * The row a hit or a point hands back, for a chart whose rows are `TRow[]` (0.53, keksdose
+ * after 0.52): `TRow` itself, so a drilldown reads `hit.row.rawPeriod` as the string it
+ * is. A {@link SeriesChartRow} where `TRow` names no keys — `object`, the default, which
+ * keeps `SeriesChartHit` and `SeriesChartPoint` without a type argument what they were, and
+ * the `object[]` rows an app passes today; `{}`; and `any` or `never` (`rows={[]}`), which
+ * are both assignable to `null` while no object type is.
+ *
+ * Both tests take `TRow` in the CHECKED position, never in the `extends` one, so TypeScript
+ * measures every type below as covariant in it (`SeriesChartSeries`, through `dot`'s
+ * parameter, contravariant) and relates two of them by their type arguments alone: a
+ * `SeriesChartHit<Month>` is a `SeriesChartHit`, and a handler or a series typed without an
+ * argument fits a chart of `Month` rows, though an interface has no index signature and is
+ * not, field by field, a `SeriesChartRow`. Written `object extends TRow ?`, the type is
+ * invariant and both of those stop type-checking.
+ */
+type SeriesChartRowOf<TRow> = [TRow] extends [null] ? SeriesChartRow : [keyof TRow] extends [never] ? SeriesChartRow : TRow;
 /** An abscissa value: a number (`x.type: "number"`), a category (a string, a number or
  *  a Date standing for a period), or a time (a Date, epoch ms or an ISO string). */
 export type SeriesChartXValue = number | string | Date;
@@ -406,28 +434,41 @@ export interface SeriesChartMarker {
     /** Radius in px. Default 4.5. */
     r?: number;
 }
-/** What a click on the plot picked. */
-export interface SeriesChartHit {
+/** What a click on the plot picked. `TRow` is the chart's row type (0.53); without one,
+ *  `row` is a {@link SeriesChartRow}, as before. */
+export interface SeriesChartHit<TRow extends object = object> {
     /** The row's position in `rows`. */
     index: number;
-    /** The caller's own row — with its `rawPeriod`, id or whatever the drilldown needs. */
-    row: SeriesChartRow;
+    /** The caller's own row — with its `rawPeriod`, id or whatever the drilldown needs: the
+     *  very object in `rows`, typed as `rows` is, so it is read without a cast. */
+    row: SeriesChartRowOf<TRow>;
     x: SeriesChartXValue;
     /** The series, when the click landed ON a bar. A click anywhere else picks the slot
      *  (the period), not a series. */
     key?: string;
 }
-export interface SeriesChartProps {
+/**
+ * The props of {@link SeriesChart} and {@link StaticSeriesChart}, for rows of type `TRow`.
+ *
+ * `TRow` is inferred from `rows` (0.53, keksdose after 0.52), and what the chart hands back
+ * — `hit.row` in `onPointClick`, `point.row` in a series' `dot` — is that type, so a
+ * drilldown reads its own fields without narrowing an `unknown`. Without a type argument,
+ * `SeriesChartProps` is what it was: any object is a row, and a row comes back as a
+ * {@link SeriesChartRow}. So is `ComponentProps<typeof SeriesChart>`, which reads the
+ * constraint, `object`. A series, a handler or a `dot` typed without an argument fits a
+ * chart of typed rows too.
+ */
+export interface SeriesChartProps<TRow extends object = object> {
     /**
      * One row per abscissa value. A missing key is a hole (see `connectNulls`).
      *
      * Any object (0.52, refactor audit 2026-10-30, API-2): an `interface` has no index
      * signature, so a typed sweep did not fit `SeriesChartRow` and Kurvenschmiede cast its
      * Ackermann rows `as unknown as Record<string, number>[]`. The chart reads the keys
-     * `series` and `x` name, and hands the row back as {@link SeriesChartRow}.
+     * `series` and `x` name, and hands the row back typed as these are (0.53).
      */
-    rows: readonly object[];
-    series: readonly SeriesChartSeries[];
+    rows: readonly TRow[];
+    series: readonly SeriesChartSeries<TRow>[];
     /** Default: one untitled axis, `"y"`. */
     axes?: readonly SeriesChartAxis[];
     x?: SeriesChartX;
@@ -482,7 +523,7 @@ export interface SeriesChartProps {
      * a chart without bars, named "period — series: value", behind ONE tab stop. With this
      * they are buttons that Enter and Space activate; without, images to read.
      */
-    onPointClick?: (hit: SeriesChartHit) => void;
+    onPointClick?: (hit: SeriesChartHit<TRow>) => void;
     /** Where the tooltip may go: for a chart inside a scroll wrapper. See
      *  {@link SeriesChartTooltip}. */
     tooltip?: SeriesChartTooltip;
@@ -595,17 +636,21 @@ export interface SeriesLegendAxes {
  * series whose axis is not drawn says the unit that axis would have: "Velocity (mm/s)"
  * — see {@link SeriesChartAxis.unit}. Without them, the labels are as given.
  */
-export declare function seriesLegendEntries(series: readonly SeriesChartSeries[], { axes, budgeted }?: SeriesLegendAxes): LegendEntry[];
+export declare function seriesLegendEntries<TRow extends object>(series: readonly SeriesChartSeries<TRow>[], { axes, budgeted }?: SeriesLegendAxes): LegendEntry[];
 /**
  * {@link SeriesChart} without the zoom: the same picture, no drag layer, no reset
  * button. For a thumbnail, a print view, or a chart the consumer wraps in its own
  * interaction.
  */
-export declare function StaticSeriesChart(props: SeriesChartProps): import("react").JSX.Element;
+export declare function StaticSeriesChart<TRow extends object = object>(props: SeriesChartProps<TRow>): import("react").JSX.Element;
 /**
  * The series chart, zoomable. Drag across the plot to zoom (the drag's shape picks the
  * axes), double-click or press the reset button to go back; wrap several in
  * `SharedXZoom` to move their x windows together. Which axes zoom depends on the marks
  * — see {@link SeriesChartProps.zoomAxes}.
+ *
+ * Generic in its rows (0.53): `hit.row` and a `dot`'s `point.row` are typed as `rows` is —
+ * see {@link SeriesChartProps}. A plain function, so the generic survives: a `memo` or a
+ * `forwardRef` around it would read `TRow` as its constraint.
  */
-export declare function SeriesChart(props: SeriesChartProps): import("react").JSX.Element;
+export declare function SeriesChart<TRow extends object = object>(props: SeriesChartProps<TRow>): import("react").JSX.Element;

package/dist/components/series-chart.js

@@ -822,7 +822,8 @@ function SeriesPlot({
   ] });
 }
 const ZoomablePlot = withChartZoom(SeriesPlot);
-function usePlotProps(props) {
+function usePlotProps(typed) {
+  const props = typed;
   const x = props.x ?? {};
   const { rows } = props;
   const { type, key } = x;