@umriss-ui/charts 0.7.0 → 0.8.0

package/CHANGELOG.md

@@ -29,6 +29,30 @@ interface was still expected to move before `0.3.0`.
 
 ---
 
+## 0.8.0 – Working time (Sep. 2026)
+
+### Changed
+
+- **Operating time is working time** (ADR-0035). The calendar axis and its
+  pure modules speak of working time, not of a plant's operating time. A hard
+  cut, without deprecated aliases — rename on upgrade:
+
+  | Before | After |
+  |---|---|
+  | `operatingCalendar()` | `workingCalendar()` |
+  | `toOperatingTime()` | `toWorkingTime()` |
+  | `toOperatingTimeClamped()` | `toWorkingTimeClamped()` |
+  | `operatingTicks()` | `workingTicks()` |
+  | `operatingTimeTicks()` | `workingTimeTicks()` |
+  | `OperatingCalendar` | `WorkingCalendar` |
+  | `OperatingInterval` | `WorkingInterval` |
+  | `OperatingTimeTick` | `WorkingTimeTick` |
+  | `OperatingTimeTick.operatingTime` | `WorkingTimeTick.workingTime` |
+  | `RemovedSpan.operatingTime` | `RemovedSpan.workingTime` |
+
+  `calendar` on `XAxis`/`YAxis`, `CalendarInput`, `calendarFrom`,
+  `toWallClock`, `breaks` and `removedIntervals` keep their names.
+
 ## 0.7.0 – Data table, marks and stacks (Sep. 2026)
 
 ### Added
@@ -201,7 +225,7 @@ gone** - occupancy is drawn by `@umriss-ui/schedule` (ADR-0026).
   band came out in the palette's second colour, after three bands in its
   fourth. It now gets the first. A series without a `name` counts its position
   among the series that take a colour.
-- **The operating-time axis labels in en-GB by level.** Without a
+- **The working-time axis labels in en-GB by level.** Without a
   `tickFormat` it wrote every tick as `dd.MM. HH:mm`; it now labels as the
   time axis does - `15:00`, and the date on the first tick of a new day,
   `17 Mar 06:00` - and the tooltip's x value as `17 Mar 15:23`. Its ticks
@@ -331,12 +355,12 @@ gone** - occupancy is drawn by `@umriss-ui/schedule` (ADR-0026).
   found none and drew nothing, silently. Without an `axisId` a limit now binds
   to the first axis of its orientation - an `<XAxis id="time">` too - and an
   unknown `axisId` is a DEV error, as it is for a series.
-- **The operating-time axis stands on the local clock.** Its day and half-day
+- **The working-time axis stands on the local clock.** Its day and half-day
   ticks fell on UTC's midnight and were labelled in local time - "01:00"
   where a day begins, in CET. They now fall on local midnight and noon. Explicit
   `ticks` and the value of an x limit are named on the wall clock, like the
-  data, and mapped into operating time as the data are; before, both were taken
-  as operating time and landed far off, or pulled the axis out of shape.
+  data, and mapped into working time as the data are; before, both were taken
+  as working time and landed far off, or pulled the axis out of shape.
 - **Hit testing where areas and points meet.** Under `mode="nearest"` a state
   band or a matrix cell under the pointer counted as distance zero and beat
   every point; a point within 12 px of the pointer now wins, and the area
@@ -431,7 +455,7 @@ time arithmetic from here, so what it uses is public now.
   `light-dark()` included, resolved to values a canvas can draw in the scheme
   that applies at `root`. **`subscribeTheme(notify)`** tells a canvas when to
   resolve again.
-- **`toOperatingTimeClamped`** — wall clock to operating time without `NaN`: a
+- **`toWorkingTimeClamped`** — wall clock to working time without `NaN`: a
   time in removed time lands on its seam.
 
 ### No longer a release candidate
@@ -529,7 +553,7 @@ German defaults stood there regardless:
   `"Sonstige"`). Whoever names `collectRank` names `remainderName` with it — in
   the type (`ParetoSettings`) and in DEV as an error. `paretoDefaults` no longer
   contains `remainderName`.
-- The labelling of an operating-time axis without a `tickFormat` of its own is
+- The labelling of a working-time axis without a `tickFormat` of its own is
   `dd.MM. HH:mm`, set by hand. Previously it came out of
   `toLocaleString(undefined, …)` and looked different on every machine.
 - `"Series n"` remains the last resort for a series without a `name`, but warns
@@ -569,8 +593,8 @@ ADR-0006 to ADR-0011.
 - **`ControlChart`:** the control chart as a composition out of `Line`,
   `LimitLine` and `Scatter` (ADR-0008), and with it the pure modules
   `controlLimits`, `zones`, the four rules and `violations`.
-- **The operating-time axis:** `calendar` on `XAxis`/`YAxis` and the pure modules
-  out of `operatingTime.ts` — wall clock ↔ operating time, ticks, breaks.
+- **The working-time axis:** `calendar` on `XAxis`/`YAxis` and the pure modules
+  out of `workingTime.ts` — wall clock ↔ working time, ticks, breaks.
 - **`pareto`** as a pure module.
 - **The limit as a rule:** `assess` and `verdictWeight` with their types — the
   same rule as in `@umriss-ui/core`, deliberately there twice (ADR-0006).

package/README.md

@@ -2,8 +2,8 @@
 
 Canvas-based charts for data-dense applications: few chart kinds, each one drawn
 properly. Lines, areas, bars, scatters, state bands and matrices compose into
-one chart on shared axes — together with the instruments a plant screen is
-made of: limit lines and bands, a control chart, a Pareto and an operating-time
+one chart on shared axes — together with the instruments a monitoring screen is
+made of: limit lines and bands, a control chart, a Pareto and a working-time
 axis.
 
 The package depends on **nothing but React**, and it will keep doing so (R-1.2).
@@ -86,15 +86,15 @@ loaded: Geist when the application has it, the system fonts otherwise.
 ## What it can do
 
 * **Six series kinds** in one chart on shared axes: `Line`, `Area`, `Bar`,
-  `Scatter`, `StateBand`, `Matrix`. Occupancy — jobs on machines, idle time,
+  `Scatter`, `StateBand`, `Matrix`. Occupancy — work on people or vehicles, idle time,
   double bookings — is `@umriss-ui/schedule`'s (ADR-0026).
 * **Several axes per orientation**, each with its own extent; only the first
   registered axis per orientation draws a grid.
 * **The instruments**: `LimitLine` and `LimitBand`, `ControlChart` with its four
-  rule violations, `pareto()` with a collected remainder, and an operating-time
+  rule violations, `pareto()` with a collected remainder, and a working-time
   axis that takes the empty hours out and marks every removed span.
 * **The pure modules are exported**, not hidden: `assess`, `controlLimits`,
-  `zones`, `violations`, `pareto`, `operatingCalendar` and the rest. Whoever
+  `zones`, `violations`, `pareto`, `workingCalendar` and the rest. Whoever
   wants to draw something other than the composition offers should reach the
   arithmetic without rebuilding it.
 * **Performance, measured rather than claimed**, up to three series of a

package/dist/charts.js

@@ -347,12 +347,12 @@ function On(s) {
     e.push({
       from: t.intervals[n - 1].to,
       to: t.intervals[n].from,
-      operatingTime: t.offsets[n]
+      workingTime: t.offsets[n]
     });
   return e;
 }
 function Hn(s, t, e) {
-  return On(s).map((n) => n.operatingTime).filter((n) => n >= t && n <= e);
+  return On(s).map((n) => n.workingTime).filter((n) => n >= t && n <= e);
 }
 const ke = [
   ot,
@@ -396,7 +396,7 @@ function Wn(s, t, e, n, i = 0) {
   let c = Number.NaN;
   for (let h = l; h <= a; h++) {
     const f = i + h * n, m = ut(f, o);
-    Number.isNaN(m) || m === c || (r.push({ wallClock: f, operatingTime: m }), c = m);
+    Number.isNaN(m) || m === c || (r.push({ wallClock: f, workingTime: m }), c = m);
   }
   return r;
 }
@@ -410,7 +410,7 @@ function Is(s, t, e, n, i = 0) {
     ht(l, o),
     a,
     i
-  ).map((h) => h.operatingTime).filter((h) => h >= t && h <= e);
+  ).map((h) => h.workingTime).filter((h) => h >= t && h <= e);
 }
 const we = 365 * K, zn = [
   ...[1, 2, 5, 10, 15, 30].map((s) => ({ unit: "minute", n: s, ms: s * V })),
@@ -2085,14 +2085,14 @@ class rn {
       i.inExtent && (i.orientation !== t || this.limitAxisId(i) !== e || (i.kind === "line" ? n.push(this.limitAt(i, i.value)) : n.push(this.limitAt(i, i.from), this.limitAt(i, i.to))));
     return n;
   }
-  /** A limit's value in the units of its axis. An x limit on an operating-time
+  /** A limit's value in the units of its axis. An x limit on a working-time
       axis is named on the wall clock, like the data, and mapped as they are. */
   limitAt(t, e) {
     if (t.orientation !== "x") return e;
     const n = this.findAxisConfig("x", this.limitAxisId(t)), i = n === null ? void 0 : this.mapFor(n);
     return i === void 0 ? e : i(e);
   }
-  /** Pre-mapping of the x values of an axis with an operating calendar. The scale
+  /** Pre-mapping of the x values of an axis with a working calendar. The scale
       stays affine; the mapping happens beforehand, once per point, in
       materialisation - exactly the route ADR-0001 prescribes for a non-affine
       axis. */
@@ -2444,7 +2444,7 @@ class rn {
   }
   /** Lane of a state series in pixels. Without a value the whole domain of its y
       axis: a single series fills its band, a stack gets a domain with one unit per
-      machine from the caller. */
+      lane from the caller. */
   lanePx(t, e) {
     const n = e.scale.domain, i = e.scale.toPx(t.laneFrom ?? n[0]), o = e.scale.toPx(t.laneTo ?? n[1]);
     return { top: Math.min(i, o), bottom: Math.max(i, o) };
@@ -4304,9 +4304,6 @@ export {
   qt as invalidateTheme,
   Ns as localOffset,
   ws as mapSeries,
-  Dn as operatingCalendar,
-  Is as operatingTicks,
-  Wn as operatingTimeTicks,
   Ws as pareto,
   xs as paretoDefaults,
   On as removedIntervals,
@@ -4318,11 +4315,14 @@ export {
   Cs as sigmaFromLimit,
   Tn as subscribeTheme,
   Rn as timeStep,
-  ut as toOperatingTime,
-  Cn as toOperatingTimeClamped,
   ht as toWallClock,
+  ut as toWorkingTime,
+  Cn as toWorkingTimeClamped,
   As as verdictWeight,
   ps as violatedIndices,
   ms as violations,
+  Dn as workingCalendar,
+  Is as workingTicks,
+  Wn as workingTimeTicks,
   as as zones
 };

package/dist/index.d.ts

@@ -127,10 +127,10 @@ export declare interface AxisConfig<T = unknown> {
     /** 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
+    /** Working calendar: the intervals in which time counts. With it,
+     materialisation maps wall clock time onto working time before the scale
      calculates - the scale stays affine (ADR-0001). */
-    calendar?: readonly OperatingInterval[];
+    calendar?: readonly WorkingInterval[];
     /** 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
@@ -190,17 +190,17 @@ export declare interface BarSeriesConfig<T = unknown> extends SeriesBase<T>, Sta
     barWidth: number;
 }
 
-/** The breaks in operating time that lie within the extent [from, to] - what the
+/** The breaks in working time that lie within the extent [from, to] - what the
  axis must mark, in domain units. */
 export declare function breaks(input: CalendarInput, from: number, to: number): number[];
 
 /** Calendar from an input - a built calendar is passed straight through, a raw
  list is built once and remembered. */
-export declare function calendarFrom(input: CalendarInput): OperatingCalendar;
+export declare function calendarFrom(input: CalendarInput): WorkingCalendar;
 
 /** Every function of this module takes either: the raw list as it stands on the
  axis, or the calendar built from it. */
-export declare type CalendarInput = OperatingCalendar | readonly OperatingInterval[];
+export declare type CalendarInput = WorkingCalendar | readonly WorkingInterval[];
 
 export declare function Chart<T>(props: ChartProps<T>): ReactNode;
 
@@ -310,7 +310,7 @@ declare interface CommonProps {
      is nearly always a value and not a moment. */
     orientation?: "x" | "y";
     /** Two severities, not five: five urgencies are five colours, and five colours
-     on a plant screen are noise. */
+     on a dense screen are noise. */
     severity?: Severity;
     /** What the value means. A line at 90 does not say what 90 is. */
     label?: string;
@@ -601,7 +601,7 @@ export declare interface LineProps<T> {
      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
+     and jumps there - a target, a digital signal. A gap ends the hold at
      its x. The tooltip reports the sample the hold began with. */
     step?: boolean;
 }
@@ -696,70 +696,6 @@ export declare interface MatrixSeriesConfig<T = unknown> extends SeriesBase<T> {
 
 export declare const MINUTE: number;
 
-/** An operating calendar: sorted, merged intervals with the operating time
- accumulated before each one begins. An empty calendar is no calendar: it maps
- unchanged.
-
- Build once, then pass around: the mapping runs once per point, and were it to
- sort and accumulate every time, the calendar would be the most expensive
- thing about the frame. */
-export declare interface OperatingCalendar {
-    readonly intervals: readonly OperatingInterval[];
-    /** Operating time accumulated before the respective interval begins. */
-    readonly offsets: readonly number[];
-    /** The whole operating time - the axis' extent is [0, total]. */
-    readonly total: number;
-}
-
-/** Builds a calendar: sorts, merges overlapping and abutting intervals and
- throws away empty, reversed and non-finite ones. Merging is not a courtesy
- but a precondition: only over separated intervals is the reverse mapping
- unambiguous. */
-export declare function operatingCalendar(intervals: readonly OperatingInterval[]): OperatingCalendar;
-
-/** An interval in which time counts; thought of as half-open, but mappable from
- both sides at its edges: both `from` and `to` have an operating time. */
-export declare interface OperatingInterval {
-    readonly from: number;
-    readonly to: number;
-}
-
-/** Tick values for an axis extent that already stands in OPERATING TIME - the
- route the axis layout takes.
-
- The extent is trimmed to the operating time that exists (an extent widened to
- nice boundaries reaches beyond it), calculated back into wall clock time, and
- the candidates arise there. The step comes from the span in operating time and
- not from the one in wall clock time: roughly one candidate per step of
- operating time survives, and calculated from the wall clock span, four out of
- ten wanted ticks would be left. */
-export declare function operatingTicks(input: CalendarInput, from: number, to: number, count: number, offset?: number): number[];
-
-/** A tick: where it stands on the clock and where it lies on the axis. */
-export declare interface OperatingTimeTick {
-    readonly wallClock: number;
-    readonly operatingTime: number;
-}
-
-/** Ticks for an operating time axis, from an extent in WALL CLOCK TIME.
-
- The candidates arise in wall clock time on multiples of the step - hours,
- shift changes, days - whatever lies in removed time falls away, the rest is
- mapped. Never the other way round: ticks generated in operating time land in
- the middle of a shift and yield an axis labelled 14.5 and 29.0 which nobody
- can read.
-
- The offset shifts the grid; with it a local time hits its own midnight without
- this module having to know about time zones.
-
- If two candidates fall on the same operating time - the end of one shift and
- the beginning of the next - the earlier one stays: two labels on the same
- pixel would be one too many.
-
- Both times come back, because the axis needs both: the operating time to
- place the tick, the wall clock time to label it. */
-export declare function operatingTimeTicks(input: CalendarInput, from: number, to: number, step: number, offset?: number): OperatingTimeTick[];
-
 export declare interface Padding {
     top: number;
     right: number;
@@ -850,7 +786,7 @@ export declare interface Rect {
     height: number;
 }
 
-/** The removed spans between the operating intervals, for the mark in the axis
+/** The removed spans between the working intervals, for the mark in the axis
  band. A chart that takes a weekend out and does not say so claims a
  continuity it does not have. Before the first and after the last interval
  there is nothing to mark: that lies outside the axis' extent. */
@@ -860,8 +796,8 @@ export declare function removedIntervals(input: CalendarInput): RemovedSpan[];
 export declare interface RemovedSpan {
     readonly from: number;
     readonly to: number;
-    /** Operating time on which the whole span lies - a point, not a stretch. */
-    readonly operatingTime: number;
+    /** Working time on which the whole span lies - a point, not a stretch. */
+    readonly workingTime: number;
 }
 
 /** Any number of CSS colours - a token, `light-dark(…)`, `var(--…)`, a
@@ -1012,7 +948,7 @@ export declare type SeriesKind = SeriesConfig["kind"];
 
 /** How seriously a violation weighs. Exactly two: one severity that advises and
  one that calls for action. Five severities would be five colours, and five
- colours on a control room screen are noise. Whoever needs a third
+ colours on a dense screen are noise. Whoever needs a third
  distinction sets a second limit. */
 export declare type Severity = "warning" | "alarm";
 
@@ -1149,7 +1085,15 @@ export declare interface TooltipProps<T> {
     render?: (hit: TooltipHit<T>) => ReactNode;
 }
 
-/** Wall clock time → operating time.
+/** Working time → wall clock time; outside [0, total] there is none.
+
+ At a seam - the end of an interval which is at the same time the beginning of
+ the next - the beginning of the next comes out: from there time counts again,
+ and a pointer aiming there aims at the coming interval. Only the end of the last
+ interval has no next and comes back as itself. */
+export declare function toWallClock(workingTime: number, input: CalendarInput): number;
+
+/** Wall clock time → working time.
 
  A point in a removed interval is a gap and becomes `NaN` - the encoding every
  gap of this library already uses, and the drawing loop breaks the mark at it
@@ -1159,30 +1103,22 @@ export declare interface TooltipProps<T> {
  before the first and after the last interval.
 
  The end of one interval and the beginning of the next fall on the same value:
- in operating time they are neighbours, and the line between two points on
+ in working time they are neighbours, and the line between two points on
  either side is drawn. That is not a lie but the whole purpose of the axis; the
  mark in the axis band tells the reader that time was taken out there. */
-export declare function toOperatingTime(wallClock: number, input: CalendarInput): number;
+export declare function toWorkingTime(wallClock: number, input: CalendarInput): number;
 
-/** Wall clock time → operating time, but without NaN: whatever lies in removed
+/** Wall clock time → working time, but without NaN: whatever lies in removed
  time falls onto the seam that this span collapses onto anyway; whatever lies
  before the first or after the last interval onto 0 or onto the whole
- operating time respectively.
+ working time respectively.
 
  Why this exists: the materialised x values must stay ascending. Binary search
  - for a hit as for a segment boundary - assumes that, and every comparison
  with NaN is false, so that a search over a block of NaN silently lands on the
  wrong point. The clamped value is a POSITION, not a statement: the point
  itself is carried as a gap and is never drawn and never hit. */
-export declare function toOperatingTimeClamped(wallClock: number, input: CalendarInput): number;
-
-/** Operating time → wall clock time; outside [0, total] there is none.
-
- At a seam - the end of an interval which is at the same time the beginning of
- the next - the beginning of the next comes out: from there time counts again,
- and a pointer aiming there aims at the coming shift. Only the end of the last
- interval has no next and comes back as itself. */
-export declare function toWallClock(operatingTime: number, input: CalendarInput): number;
+export declare function toWorkingTimeClamped(wallClock: number, input: CalendarInput): number;
 
 /** What a value is. Four outcomes, not three.
 
@@ -1212,6 +1148,70 @@ export declare interface Violation {
  listed beside the chart as well as marked on it. */
 export declare function violations(values: readonly number[], limits: ControlLimits, options?: Partial<RuleOptions>): Violation[];
 
+/** A working calendar: sorted, merged intervals with the working time
+ accumulated before each one begins. An empty calendar is no calendar: it maps
+ unchanged.
+
+ Build once, then pass around: the mapping runs once per point, and were it to
+ sort and accumulate every time, the calendar would be the most expensive
+ thing about the frame. */
+export declare interface WorkingCalendar {
+    readonly intervals: readonly WorkingInterval[];
+    /** Working time accumulated before the respective interval begins. */
+    readonly offsets: readonly number[];
+    /** The whole working time - the axis' extent is [0, total]. */
+    readonly total: number;
+}
+
+/** Builds a calendar: sorts, merges overlapping and abutting intervals and
+ throws away empty, reversed and non-finite ones. Merging is not a courtesy
+ but a precondition: only over separated intervals is the reverse mapping
+ unambiguous. */
+export declare function workingCalendar(intervals: readonly WorkingInterval[]): WorkingCalendar;
+
+/** An interval in which time counts; thought of as half-open, but mappable from
+ both sides at its edges: both `from` and `to` have a working time. */
+export declare interface WorkingInterval {
+    readonly from: number;
+    readonly to: number;
+}
+
+/** Tick values for an axis extent that already stands in WORKING TIME - the
+ route the axis layout takes.
+
+ The extent is trimmed to the working time that exists (an extent widened to
+ nice boundaries reaches beyond it), calculated back into wall clock time, and
+ the candidates arise there. The step comes from the span in working time and
+ not from the one in wall clock time: roughly one candidate per step of
+ working time survives, and calculated from the wall clock span, four out of
+ ten wanted ticks would be left. */
+export declare function workingTicks(input: CalendarInput, from: number, to: number, count: number, offset?: number): number[];
+
+/** A tick: where it stands on the clock and where it lies on the axis. */
+export declare interface WorkingTimeTick {
+    readonly wallClock: number;
+    readonly workingTime: number;
+}
+
+/** Ticks for a working time axis, from an extent in WALL CLOCK TIME.
+
+ The candidates arise in wall clock time on multiples of the step - hours,
+ interval changes, days - whatever lies in removed time falls away, the rest is
+ mapped. Never the other way round: ticks generated in working time land in
+ the middle of an interval and yield an axis labelled 14.5 and 29.0 which nobody
+ can read.
+
+ The offset shifts the grid; with it a local time hits its own midnight without
+ this module having to know about time zones.
+
+ If two candidates fall on the same working time - the end of one interval and
+ the beginning of the next - the earlier one stays: two labels on the same
+ pixel would be one too many.
+
+ Both times come back, because the axis needs both: the working time to
+ place the tick, the wall clock time to label it. */
+export declare function workingTimeTicks(input: CalendarInput, from: number, to: number, step: number, offset?: number): WorkingTimeTick[];
+
 export declare function XAxis<T>(props: XAxisProps<T>): null;
 
 export declare interface XAxisProps<T> extends CommonProps_2<T> {
@@ -1229,11 +1229,11 @@ export declare interface XAxisProps<T> extends CommonProps_2<T> {
      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
+    /** Working calendar: the intervals in which time counts. With it the axis
+     stands in working time - nights and weekends are out, and every
      removed span gets a break mark. The scale stays affine; the mapping happens
      in materialisation (ADR-0001). */
-    calendar?: readonly OperatingInterval[];
+    calendar?: readonly WorkingInterval[];
     /** 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