@umriss-ui/charts 0.3.2 → 0.4.0

package/dist/index.d.ts

@@ -1,12 +1,16 @@
 import { CSSProperties } from 'react';
 import { ReactNode } from 'react';
 
+/** Value access of a series. Compared by its source text, not its identity - an
+ inline accessor is new on every render. Known limit: one that reads a
+ changed closure variable under the same text is not run again; pass a new
+ data reference then. A native or bound function is compared by identity. */
 export declare type Accessor<T> = (d: T, index: number) => number | null | undefined;
 
 export declare function Area<T>(props: AreaProps<T>): null;
 
 export declare interface AreaProps<T> {
-    /** Upper edge; null/undefined/NaN means a gap (R-2.5). */
+    /** Upper edge; null/undefined/NaN/±Infinity means a gap (R-2.5). */
     accessor: Accessor<T>;
     /** Lower edge; without a value the fixed baseline 0. */
     baseline?: Accessor<T>;
@@ -20,12 +24,26 @@ export declare interface AreaProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
+    /** The value as the tooltip writes it; without one the y axis' `tickFormat`,
+     then the default. */
+    format?: (value: number) => string;
     /** Any CSS colour value; without one the palette --uc-series-N. */
     color?: string;
-    /** Opacity of the fill; the outline stays fully opaque. */
+    /** A role instead of a colour value; the theme resolves it. `color` beats
+     it. */
+    tone?: "ok" | "warning" | "alarm";
+    /** Opacity of the fill, from 0 to 1; the outline stays fully opaque. */
     fillOpacity?: number;
-    /** Width of the outline along the upper edge; 0 leaves it out. */
+    /** Width of the outline along the upper edge in CSS pixels; 0 leaves it
+     out. */
     strokeWidth?: number;
+    /** Dash pattern of the outline as a run of lengths in CSS pixels; without
+     one a solid outline. The fill stays whole. */
+    dash?: readonly number[];
 }
 
 export declare interface AreaSeriesConfig<T = unknown> extends SeriesBase<T> {
@@ -35,6 +53,8 @@ export declare interface AreaSeriesConfig<T = unknown> extends SeriesBase<T> {
     /** Opacity of the fill; the outline stays fully opaque. */
     fillOpacity: number;
     strokeWidth: number;
+    /** Dash pattern of the outline. */
+    dash?: readonly number[];
 }
 
 /** What the value is, given the limit set. A pure function of the two.
@@ -83,7 +103,9 @@ export declare interface AxisConfig<T = unknown> {
     label?: string;
     tickCount?: number;
     tickFormat?: (v: number) => string;
-    domain: "nice" | "data" | readonly [number, number];
+    /** "visible" is a y axis' only: the extent of what its series show inside
+     their x axis' domain. */
+    domain: "nice" | "data" | "visible" | readonly [number, number];
     /** undefined = the default per R-4.15 (only the first registered axis per
      orientation). */
     grid?: boolean;
@@ -91,10 +113,18 @@ export declare interface AxisConfig<T = unknown> {
      not numbers but places: the lanes of a state stack, the categories of a
      Pareto. */
     ticks?: readonly number[];
+    /** The values are instants in milliseconds: ticks on local boundaries,
+     labels by level. A calendar implies it. */
+    time?: boolean;
     /** Operating calendar: the intervals in which time counts. With it,
      materialisation maps wall clock time onto operating time before the scale
      calculates - the scale stays affine (ADR-0001). */
     calendar?: readonly OperatingInterval[];
+    /** y axes only: this axis' ticks on the first y axis' grid. */
+    alignTicks?: boolean;
+    /** x axes only: where wheel, drag, pinch and double click propose a
+     domain. Without it the axis does not zoom. */
+    onDomainChange?: (domain: [number, number]) => void;
 }
 
 export declare type AxisOrientation = "x" | "y";
@@ -104,7 +134,7 @@ export declare type AxisPosition = "bottom" | "top" | "left" | "right";
 export declare function Bar<T>(props: BarProps<T>): null;
 
 export declare interface BarProps<T> {
-    /** Height; null/undefined/NaN means a gap (R-2.5). */
+    /** Height; null/undefined/NaN/±Infinity means a gap (R-2.5). */
     accessor: Accessor<T>;
     /** Binding to an x axis (R-4.12). */
     xAxisId?: string;
@@ -116,8 +146,18 @@ export declare interface BarProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
+    /** The value as the tooltip writes it; without one the y axis' `tickFormat`,
+     then the default. */
+    format?: (value: number) => string;
     /** Any CSS colour value; without one the palette --uc-series-N. */
     color?: string;
+    /** A role instead of a colour value; the theme resolves it. `color` beats
+     it. */
+    tone?: "ok" | "warning" | "alarm";
     /** Width as a fraction of the step; just under 1, so that neighbours do not
      touch. Several bar series share this fraction. */
     barWidth?: number;
@@ -156,8 +196,8 @@ export declare interface ChartProps<T> {
     /** Width in CSS pixels, or `"100%"` for the host's. Without a value the chart
      measures its host and follows it through a ResizeObserver. */
     width?: number | "100%";
-    /** Height in CSS pixels. Without a value the chart takes its host's, which
-     then has to have one - a chart in a box of height 0 draws nothing. */
+    /** Height in CSS pixels; 300 without a value. Unlike the width, the chart
+     does not take its host's. */
     height?: number;
     /** Outer spacing of the plot area in CSS pixels. */
     padding?: number | Partial<Padding>;
@@ -169,6 +209,16 @@ export declare interface ChartProps<T> {
      here: a height set past the component is a height the scene does not know
      about. */
     style?: CSSProperties;
+    /** Shown in the middle of the plot area when no visible series has a point
+     to show - no data, only gaps, or every series hidden. Axes and frame
+     stay. Without a value "No data"; any other language or wording is the
+     caller's. */
+    empty?: ReactNode;
+    /** Charts with the same id share the pointer's x position, in domain units:
+     each draws its crosshair there, the tooltip stays with the chart under
+     the pointer. Zoom is not shared - give every chart the same controlled
+     `domain`. */
+    syncId?: string;
     /** Instrumentation for the benchmark page (R-5.1); not needed otherwise. */
     onPerf?: (perf: ChartPerf) => void;
     /** The axes, series and companions of this chart. They draw nothing
@@ -178,7 +228,8 @@ export declare interface ChartProps<T> {
 }
 
 declare interface CommonProps {
-    /** Axis on which the value lies. */
+    /** Axis on which the value lies. Without one, the first axis of the
+     orientation. */
     axisId?: string;
     /** Whether the value lies on the x or on the y axis. Without one, y: a limit
      is nearly always a value and not a moment. */
@@ -204,14 +255,18 @@ declare interface CommonProps {
 declare interface CommonProps_2<T> {
     /** Axis id, through which series bind themselves (R-4.12). */
     id?: string;
-    /** Value access of this axis. */
+    /** Value access of this axis. Compared by its source text, as a series'
+     accessor is (`Accessor`) - with the same closure limit. */
     accessor: (d: T, index: number) => number;
     /** Axis title. */
     label?: string;
     /** Target value; the 1-2-5 algorithm may deviate. */
     tickCount?: number;
+    /** Label of a tick. Compared by its source text: one that reads a changed
+     closure variable under the same text does not relabel the axis - give it
+     a new text or remount. A bound `Intl.NumberFormat#format` is compared by
+     identity. */
     tickFormat?: (v: number) => string;
-    domain?: "nice" | "data" | readonly [number, number];
     /** Grid lines; the default follows R-4.15. */
     grid?: boolean;
     /** Fixed tick values instead of the 1-2-5 algorithm. For axes whose values are
@@ -239,8 +294,14 @@ export declare interface ControlChartProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** The value as the tooltip writes it - on the line and on the violations;
+     without one the y axis' `tickFormat`, then the default. */
+    format?: (value: number) => string;
     /** Any CSS colour value; without one the palette --uc-series-N. */
     color?: string;
+    /** A role instead of a colour value for the line; the theme resolves it.
+     The violations are always "alarm". */
+    tone?: "ok" | "warning" | "alarm";
     /** Switchable one by one; run lengths are parameters. */
     rules?: Partial<RuleOptions>;
     /** The faint zone lines at one and two sigma. Rule 4 is about the two-sigma
@@ -311,7 +372,7 @@ export declare const HOUR: number;
  redraws. */
 export declare function invalidateTheme(): void;
 
-export declare function Legend({ placement }: LegendProps): ReactNode;
+export declare function Legend({ placement, onToggle }: LegendProps): ReactNode;
 
 export declare interface LegendConfig {
     placement: "top" | "bottom";
@@ -321,6 +382,10 @@ export declare interface LegendProps {
     /** Which side of the plot area the legend stands on. Without a value, above
      it. */
     placement?: "top" | "bottom";
+    /** Called with an entry's name when it is clicked - the series' name, or a
+     state's label. The caller flips `hidden` on the series it means. Without
+     it the legend is not clickable. */
+    onToggle?: (name: string) => void;
 }
 
 /** A bound: a value, a side and a severity. No more - a tolerance band is
@@ -344,14 +409,15 @@ export declare interface LimitBandConfig extends LimitBase {
 export declare interface LimitBandProps extends CommonProps {
     /** Lower edge of the band, in domain units of its axis. */
     from: number;
-    /** Upper edge. A band drawn backwards (`from` above `to`) is drawn between
+    /** Upper edge, in domain units of its axis. A band drawn backwards (`from` above `to`) is drawn between
      the two all the same - the pair is a range, not a direction. */
     to: number;
 }
 
 declare interface LimitBase {
-    /** Axis on which the value lies. */
-    axisId: string;
+    /** Axis on which the value lies; without one, the first axis of its
+     orientation (charts-fixes 08). */
+    axisId?: string;
     orientation: AxisOrientation;
     severity: Severity;
     role: LimitRole;
@@ -414,7 +480,7 @@ export declare class LinearScale implements Scale {
 }
 
 export declare interface LineProps<T> {
-    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    /** Y value; null/undefined/NaN/±Infinity means a gap (R-2.5). */
     accessor: Accessor<T>;
     /** Binding to an x axis (R-4.12). */
     xAxisId?: string;
@@ -426,6 +492,13 @@ export declare interface LineProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
+    /** The value as the tooltip writes it; without one the y axis' `tickFormat`,
+     then the default. */
+    format?: (value: number) => string;
     /** Any CSS colour value; without one the palette --uc-series-N. */
     color?: string;
     /** A role instead of a colour value; the theme resolves it. */
@@ -434,9 +507,14 @@ export declare interface LineProps<T> {
     strokeWidth?: number;
     /** Dash pattern as a run of lengths in CSS pixels; without one a solid line. */
     dash?: readonly number[];
-    /** When the individual points are drawn as marks: `auto` from a density at
-     which they no longer run into each other, `always`, `never`. */
+    /** When the individual points are drawn as marks: `auto` every point up to
+     60 points and above that only a point between two gaps - it has no line
+     to be seen by - `always`, or `never`, not even that one. */
     markers?: "auto" | "always" | "never";
+    /** Sample-and-hold: each value holds as a horizontal until the next sample
+     and jumps there - a set point, a digital signal. A gap ends the hold at
+     its x. The tooltip reports the sample the hold began with. */
+    step?: boolean;
 }
 
 export declare interface LineSeriesConfig<T = unknown> extends SeriesBase<T> {
@@ -444,14 +522,22 @@ export declare interface LineSeriesConfig<T = unknown> extends SeriesBase<T> {
     strokeWidth: number;
     dash?: readonly number[];
     markers: "auto" | "always" | "never";
+    /** Sample-and-hold: each value holds until the next sample. */
+    step?: boolean;
 }
 
+/** The local offset at an instant, as the shift of a grid that is to lie on
+ local time: `wallClock = offset + k · step`. Taken at one instant, it holds
+ for a grid up to the next clock change. */
+export declare function localOffset(instant: number): number;
+
 /** Map a whole series inwards - the route materialisation takes when it wants to
  go it in one piece. Only the first n values are touched. */
 export declare function mapSeries(input: CalendarInput, source: Float64Array, n: number, target: Float64Array): void;
 
 /** Materialised series: the draw loop works only on this (R-2.7).
- Gaps (null/undefined/NaN out of the accessor) are encoded as NaN (R-2.5). */
+ Gaps (null/undefined/NaN/±Infinity out of the accessor) are encoded as NaN
+ (R-2.5). */
 export declare interface MaterializedSeries {
     x: Float64Array;
     y: Float64Array;
@@ -463,9 +549,6 @@ export declare interface MaterializedSeries {
      carry does not belong in the shared type with a comment (ADR-0011). null
      for every kind that does not use it. */
     w: Float64Array | null;
-    /** Second x channel: the end of a span. Named for the same reason.
-     NaN here does not mean a gap but open (ADR-0011). */
-    x1: Float64Array | null;
     length: number;
 }
 
@@ -505,6 +588,13 @@ export declare interface MatrixProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
+    /** The value as the tooltip writes it; without one the default. The y
+     axis' `tickFormat` writes the row, not the value. */
+    format?: (value: number) => string;
 }
 
 export declare interface MatrixSeriesConfig<T = unknown> extends SeriesBase<T> {
@@ -769,7 +859,7 @@ export declare interface Scale {
 export declare function Scatter<T>(props: ScatterProps<T>): null;
 
 export declare interface ScatterProps<T> {
-    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    /** Y value; null/undefined/NaN/±Infinity means a gap (R-2.5). */
     accessor: Accessor<T>;
     /** Binding to an x axis (R-4.12). */
     xAxisId?: string;
@@ -781,6 +871,13 @@ export declare interface ScatterProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
+    /** The value as the tooltip writes it; without one the y axis' `tickFormat`,
+     then the default. */
+    format?: (value: number) => string;
     /** Any CSS colour value; without one the palette --uc-series-N. */
     color?: string;
     /** A role instead of a colour value; the theme resolves it. */
@@ -798,21 +895,26 @@ export declare interface ScatterSeriesConfig<T = unknown> extends SeriesBase<T>
 export declare const SECOND = 1000;
 
 export declare interface SeriesBase<T = unknown> {
-    /** Y value; null/undefined/NaN means a gap (R-2.5). */
+    /** Y value; null/undefined/NaN/±Infinity means a gap (R-2.5). */
     accessor: Accessor<T>;
     /** Series-own data; overrides the container data (R-2.4). */
     data?: readonly T[];
     xAxisId: string;
     yAxisId: string;
     name?: string;
+    /** The value in the tooltip; before the y axis' `tickFormat`. Compared by its
+     source text, as an accessor is. */
+    format?: (value: number) => string;
     color?: string;
     /** A role instead of a colour value: the theme resolves it, in both themes.
      For series that mean something rather than just being the next one - the
      violating points of a control chart, say. `color` beats it. */
     tone?: "ok" | "warning" | "alarm";
+    /** Not drawn, not hit, not in its axes' extent; its legend entry stays. */
+    hidden?: boolean;
 }
 
-export declare type SeriesConfig<T = unknown> = LineSeriesConfig<T> | AreaSeriesConfig<T> | BarSeriesConfig<T> | ScatterSeriesConfig<T> | StateSeriesConfig<T> | MatrixSeriesConfig<T> | SpanSeriesConfig<T>;
+export declare type SeriesConfig<T = unknown> = LineSeriesConfig<T> | AreaSeriesConfig<T> | BarSeriesConfig<T> | ScatterSeriesConfig<T> | StateSeriesConfig<T> | MatrixSeriesConfig<T>;
 
 export declare type SeriesKind = SeriesConfig["kind"];
 
@@ -829,45 +931,18 @@ export declare type Side = "upper" | "lower";
  baseline has been handed down as a centre line and a control limit. */
 export declare function sigmaFromLimit(center: number, upper: number): number;
 
-export declare function Span<T>(props: SpanProps<T>): null;
-
-export declare interface SpanProps<T> {
-    /** Lane position on the y axis. */
-    accessor: Accessor<T>;
-    /** End on the x axis. Missing means open: the span runs to the edge and is
-     drawn as open - a running job is a fact one wants to see. */
-    to: Accessor<T>;
-    /** Binding to an x axis (R-4.12). */
-    xAxisId?: string;
-    /** Binding to a y axis (R-4.12). */
-    yAxisId?: string;
-    /** Series-own data; overrides the container data (R-2.4). */
-    data?: readonly T[];
-    /** The name in legend and tooltip. Without one the series is called
-     "Series n" and a warning stands in DEV - an unnamed series is a colour
-     nobody can look up. */
-    name?: string;
-    /** Any CSS colour value; without one the palette --uc-series-N. */
-    color?: string;
-    /** Height of a span as a fraction of one domain unit of the y axis. */
-    height?: number;
-}
-
-export declare interface SpanSeriesConfig<T = unknown> extends SeriesBase<T> {
-    kind: "span";
-    /** End of the span on the x axis. Missing means open: the span runs to the end
-     of the domain and is drawn as open. */
-    to: Accessor<T>;
-    /** Height of a span as a fraction of one domain unit of the y axis. */
-    height?: number;
-}
-
+/** A band of states: each point's state holds from its x until the next
+ point's. The last one holds until the latest reading of the chart - the
+ last x of any visible series on the same x axis - and where the band itself
+ reports last, one median step of its own x values past its last point;
+ never beyond the x domain. A state is claimed for as long as it was
+ reported, not until the axis' rounded end. */
 export declare function StateBand<T>(props: StateBandProps<T>): null;
 
 export declare interface StateBandProps<T> {
-    /** Index of the state in `states`; null/undefined/NaN is a gap - and a gap
-     stays a hole, it gets no colour for "unknown". A colour would be a claim
-     about the interval. */
+    /** Index of the state in `states`; null/undefined/NaN/±Infinity is a gap -
+     and a gap stays a hole, it gets no colour for "unknown". A colour would
+     be a claim about the interval. */
     accessor: Accessor<T>;
     /** The closed set of states, in the order of their codes. */
     states: readonly StateEntry[];
@@ -881,6 +956,10 @@ export declare interface StateBandProps<T> {
      "Series n" and a warning stands in DEV - an unnamed series is a colour
      nobody can look up. */
     name?: string;
+    /** Not drawn, not hit and not counted for its axes' extent - a fixed
+     `domain` keeps the axis still. Its legend entry stays, drawn back.
+     Controlled: the caller sets it, typically from `Legend onToggle`. */
+    hidden?: boolean;
     /** Lower edge of the lane in domain units of the y axis. */
     laneFrom?: number;
     /** Upper edge of the lane in domain units of the y axis. */
@@ -936,6 +1015,9 @@ export declare interface TooltipHit<T = unknown> {
 export declare interface TooltipPoint<T = unknown> {
     seriesName: string;
     color: string;
+    /** The point's x value on its own x axis - with several x axes it can
+     differ from the hit's. */
+    xValue: number;
     yValue: number;
     datum: T;
     index: number;
@@ -944,7 +1026,7 @@ export declare interface TooltipPoint<T = unknown> {
      therefore the row. Putting both into one field would be exactly the
      overloading ADR-0011 is written against. */
     value?: number;
-    /** Only for state series and spans: the section being pointed at.
+    /** Only for state series: the section being pointed at.
      A duration does not stand here - it is the difference of two numbers the
      entry already carries, and formatting it would presuppose knowing what the
      x axis means. The caller knows that, not this library. */
@@ -952,7 +1034,6 @@ export declare interface TooltipPoint<T = unknown> {
         from: number;
         to: number;
         label: string;
-        open: boolean;
     };
 }
 
@@ -960,7 +1041,8 @@ export declare interface TooltipProps<T> {
     /** "x": every series at the x position; "nearest": only the nearest point. */
     mode?: "x" | "nearest";
     /** Render prop for content of one's own; without it the built-in tooltip
-     applies. */
+     applies. Compared by its source text, like `tickFormat` - with the same
+     closure limit. */
     render?: (hit: TooltipHit<T>) => ReactNode;
 }
 
@@ -1030,19 +1112,47 @@ export declare function violations(values: readonly number[], limits: ControlLim
 export declare function XAxis<T>(props: XAxisProps<T>): null;
 
 export declare interface XAxisProps<T> extends CommonProps_2<T> {
+    /** `"nice"` widens the data's extent to ticks, `"data"` keeps it, a pair is
+     fixed - the one a zoom passes back. */
+    domain?: "nice" | "data" | readonly [number, number];
     /** Which edge the axis stands at. A second x axis on the opposite edge is how
      a series counts in a unit of its own. */
     position?: "bottom" | "top";
+    /** The values are instants (milliseconds since the epoch): ticks on local
+     boundaries from the minute to the month, labels by level in en-GB with a
+     24-hour clock - `15:00`, `17 Mar`, `Mar 2026` - and the date on the first
+     tick and on the first of a new day (`17 Mar 00:00`); a day tick there
+     carries the year. The tooltip's x value carries the seconds where the
+     readings lie less than a minute apart. Another language is a `tickFormat`,
+     which is handed the instant. `calendar` implies it. */
+    time?: boolean;
     /** Operating calendar: the intervals in which time counts. With it the axis
      stands in operating time - weekends and night shifts are out, and every
      removed span gets a break mark. The scale stays affine; the mapping happens
      in materialisation (ADR-0001). */
     calendar?: readonly OperatingInterval[];
+    /** Zoom and pan, controlled: Ctrl or ⌘ with the wheel - and a pinch - zoom
+     around the pointer, a drag, a horizontal wheel or Shift with the wheel pan,
+     a double click proposes the whole data range. Each proposes a domain in
+     the axis' units and changes nothing; the caller passes it back as
+     `domain`, clamped as it likes. Without a handler the axis does not zoom,
+     and the plain wheel always scrolls the page. */
+    onDomainChange?: (domain: [number, number]) => void;
 }
 
 export declare function YAxis<T>(props: YAxisProps<T>): null;
 
 export declare interface YAxisProps<T> extends CommonProps_2<T> {
+    /** As on the x axis, and `"visible"`: what the series show inside their x
+     axis' domain - a zoomed hour gets the hour's range, not the week's -,
+     widened to ticks as `"nice"` is. Where the x domain is not fixed that is
+     every point. */
+    domain?: "nice" | "data" | "visible" | readonly [number, number];
+    /** On a further y axis: take the first y axis' tick count and widen this
+     axis' domain until its ticks fall on that one's grid lines, the steps
+     still 1-2-5 - one grid serves both. `tickCount` then does not apply; on
+     the first y axis it changes nothing. */
+    alignTicks?: boolean;
     /** Which edge the axis stands at. Several y axes per side are stacked
      outwards, so that extents of clearly different magnitude stay readable. */
     position?: "left" | "right";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umriss-ui/charts",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "description": "Canvas-based chart library - few chart kinds, uncompromisingly clean, high performance.",
   "license": "MIT",
   "author": "Roman Händler",
@@ -58,7 +58,7 @@
     "vite": "^6.0.0",
     "vite-plugin-dts": "^4.3.0",
     "@umriss-ui/demo": "0.0.0",
-    "@umriss-ui/core": "0.3.2"
+    "@umriss-ui/core": "0.4.0"
   },
   "scripts": {
     "props": "node --disable-warning=ExperimentalWarning --experimental-strip-types demo/props.ts",