@magmonium/one 0.4.57 → 0.4.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@magmonium/one",
-  "version": "0.4.57",
+  "version": "0.4.59",
   "description": "Magmonium One — Angular design-system primitives for mm Apps",
   "author": "magmonium",
   "license": "MIT",

package/types/magmonium-one.d.ts

@@ -39,6 +39,7 @@ export declare const LAYOUT_ASSET_FOLDER: {
   readonly text_output: "text_outputs";
   readonly list: "lists";
   readonly section_table: "section_tables";
+  readonly section_chart: "section_charts";
 };
 export declare const FORM_ASSET_FOLDER: {
   readonly form: "forms";
@@ -6060,6 +6061,597 @@ declare const defaultSectionTableSort: (columns: readonly SectionTableColumn[])
  * to the end in either direction — an empty cell is not the smallest value.
  */
 export declare const sortSectionTableRows: <T>(rows: readonly T[] | null | undefined, sort: SectionTableSort | null | undefined) => T[];
+/**
+ * What a SectionChart draws its lines against (GLOSSARY.md SectionChart).
+ * `auto` reads `value` for one series and `percent` for more: two price levels
+ * on one axis flatten each other, so a comparison is always % change. `value`
+ * under two or more series is read as `percent` for the same reason.
+ */
+type SectionChartScale = 'auto' | 'percent' | 'value';
+export declare const SECTION_CHART_SCALES: readonly SectionChartScale[];
+/**
+ * The span a SectionChart draws, as the two ISO 8601 instants it runs between
+ * (GLOSSARY.md SectionChartWindow). Text rather than epoch ms: what reads a
+ * window is most often an api call, and an api takes its dates as text.
+ */
+type SectionChartWindow = {
+  from: string;
+  to: string;
+};
+/**
+ * The `range` a SectionChart holds once its window was set by hand rather
+ * than by a preset — the window itself is then the whole answer.
+ */
+export declare const SECTION_CHART_CUSTOM_RANGE = "custom";
+/**
+ * The presets offered when no `section_charts/<name>.yml` names its own
+ * `ranges`. An id is `max`, `ytd`, or a count and a unit — `10d`, `2w`,
+ * `3m`, `5y` (GLOSSARY.md SectionChartPreset).
+ */
+export declare const DEFAULT_SECTION_CHART_RANGES: readonly string[];
+/** One preset as the toggle draws it. */
+type SectionChartPreset = SectionToggleItem & {
+  id: string;
+};
+/**
+ * A SectionChart's asset (`section_charts/<name>.yml`). The preset list is
+ * the reason it exists — a list is an asset (ADR 0010); the scalars beside it
+ * stand in only where the tag leaves them unset.
+ */
+type SectionChartConfig = Config & {
+  ranges?: string[];
+  range?: string;
+  scale?: SectionChartScale;
+  height?: number;
+  navigator?: boolean;
+  measure?: boolean;
+};
+/** One series' points as the chart reads them: times ascending, one value each. */
+type SectionChartPoints = {
+  t: number[];
+  y: number[];
+};
+/**
+ * One series as the chart draws it — its points, the label its legend row
+ * reads (with the MessageVariable values it is resolved with) and the colour
+ * that names it.
+ */
+type SectionChartLine = SectionChartPoints & {
+  label: string;
+  noTranslate: boolean;
+  params?: Record<string, string>;
+  color: string;
+};
+/** Where a tick on the time axis falls, and which unit names it. */
+type SectionChartTimeTick = {
+  t: number;
+  unit: 'day' | 'month' | 'year';
+};
+/**
+ * The categorical colours a series takes by its position when it names none,
+ * one row per theme mode. The order is the colour-blind safety, not taste:
+ * every neighbouring pair clears ΔE 8 under protan, deutan and tritan
+ * simulation, and the dark row is stepped for a dark surface rather than
+ * being the light row flipped. Never cycled — a ninth series draws neutral.
+ */
+declare const SECTION_CHART_PALETTE: {
+  readonly light: readonly ["#2a78d6", "#eb6834", "#1baf7a", "#eda100", "#e87ba4", "#008300", "#6250d6", "#e34948"];
+  readonly dark: readonly ["#3987e5", "#d95926", "#199e70", "#c98500", "#d55181", "#008300", "#9085e9", "#e66767"];
+};
+/**
+ * What a SectionChartSeries registers about itself so the chart can draw it.
+ * Signals, because the rows behind a series arrive whenever its binding loads.
+ */
+interface SectionChartMember {
+  readonly points: Signal<SectionChartPoints>;
+  readonly label: Signal<string>;
+  readonly noTranslate: Signal<boolean>;
+  readonly params: Signal<Record<string, string> | undefined>;
+  readonly color: Signal<string | undefined>;
+}
+/**
+ * What a series' legend row reads back from the chart: the colour it was
+ * given and its change across the window, both the chart's to decide because
+ * both depend on every other series and on the window.
+ */
+interface SectionChartLegendRow {
+  readonly color: string;
+  readonly change: string;
+  readonly trend: 'up' | 'down' | 'flat';
+}
+/**
+ * The chart's side of the contract. A series finds it by DI rather than the
+ * chart querying its content: the editor's Canvas renders children through a
+ * template outlet, which a content query never sees, and DI walks the element
+ * injector the same way whichever of the two put the series there — the walk a
+ * SectionTableCell takes to its table.
+ */
+interface SectionChartContext {
+  register(member: SectionChartMember): void;
+  unregister(member: SectionChartMember): void;
+  /** The legend row this member draws; undefined once it has left. */
+  legendOf(member: SectionChartMember): Signal<SectionChartLegendRow | undefined>;
+}
+declare const SECTION_CHART_CONTEXT: InjectionToken<SectionChartContext>;
+type Line = SectionChartLine & {
+  member?: SectionChartMember;
+};
+type Plotted = {
+  line: Line;
+  shown: number[];
+  ds: SectionChartPoints;
+};
+/**
+ * A time-series chart composed from series placed inside it (GLOSSARY.md
+ * SectionChart): every `m-section-chart-series` that registers with it is one
+ * line on one axis. One series reads in its own values; two or more read as % change from
+ * each one's first point in the window, the only scale on which instruments
+ * priced 240 and 11,800 can be compared at all.
+ *
+ * The x axis is time, not position: series sampled on different days still
+ * line up, and a gap in the data is a gap on the axis. Lines are straight
+ * between points — a smoothed curve draws highs and lows that never happened.
+ *
+ * What it draws is a window of the data: a preset (`1m`, `ytd`, `max`, …)
+ * measured back from the last point, or a window set by hand. `range` and
+ * `window` are models, so `rangeChange` and `windowChange` fire when the reader
+ * picks a preset or lets go of the navigator, and never because an input moved
+ * — the SectionPagination rule (m-one-ui ADR 0097): an emit caused by an input
+ * is how a Screen fetches in a loop.
+ *
+ * On the Canvas, series holding no data draw a sample, so a chart dropped
+ * before its binding exists is still something the author can see and select.
+ */
+export declare class SectionChartComponent extends ConfigComponent<SectionChartConfig> {
+  subFolder: "section_charts";
+  readonly scale: import("@angular/core").InputSignal<SectionChartScale | undefined>;
+  /** The whole chart's height in px, the time axis included. */
+  readonly height: import("@angular/core").InputSignalWithTransform<number | undefined, unknown>;
+  /**
+   * Draws the navigator: an overview of all the data beneath the plot, with
+   * the window on it to drag, resize, or jump by pressing outside it.
+   */
+  readonly navigator: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /**
+   * Lets the reader drag across the plot to measure a stretch: the band is
+   * shaded and every series' change between its two ends is read out. A
+   * click clears it. Display only — it writes nothing and emits nothing.
+   */
+  readonly measure: import("@angular/core").InputSignalWithTransform<boolean | undefined, unknown>;
+  /**
+   * The preset in force — one of the asset's `ranges`, or `custom` once the
+   * window was set by hand. Unset reads the asset's `range`, then `max`.
+   */
+  readonly range: import("@angular/core").ModelSignal<string | undefined>;
+  /**
+   * The window drawn under a `custom` range. Written whenever the reader picks
+   * a preset too, so whoever fetches hears one shape whichever way the window
+   * moved.
+   */
+  readonly window: import("@angular/core").ModelSignal<SectionChartWindow | undefined>;
+  /** Every series that registered, in arrival order, each with its slot. */
+  private readonly members;
+  private readonly locale;
+  protected readonly tableId: string;
+  protected readonly left: number;
+  protected readonly top: number;
+  protected readonly width: import("@angular/core").WritableSignal<number>;
+  private readonly dateFormat;
+  private readonly dayFormat;
+  private readonly monthFormat;
+  private readonly yearFormat;
+  private readonly numberFormat;
+  private readonly compactFormat;
+  protected readonly resolvedHeight: import("@angular/core").Signal<number>;
+  private readonly resolvedScale;
+  private readonly resolvedRange;
+  protected readonly showNavigator: import("@angular/core").Signal<boolean>;
+  protected readonly canMeasure: import("@angular/core").Signal<boolean>;
+  /** The asset's presets, ids that name no span dropped; the defaults without one. */
+  protected readonly presets: import("@angular/core").Signal<SectionChartPreset[]>;
+  protected readonly presetIndex: import("@angular/core").Signal<number>;
+  private readonly palette;
+  /**
+   * Every registered series with the colour it draws in. A series keeps the
+   * slot it was given on arrival whether its neighbours hold data, gain it or
+   * leave, so a line never repaints because another one changed.
+   */
+  private readonly painted;
+  /** Every series as read: its points beside the colour it draws in. */
+  protected readonly lines: import("@angular/core").Signal<Line[]>;
+  /** The first and last time any series holds. */
+  private readonly dataSpan;
+  /**
+   * The span drawn: the hand-set window under `custom`, the preset's span
+   * otherwise. A `custom` range with no readable window, or a preset id that
+   * names no span, draws everything rather than nothing.
+   */
+  protected readonly span: import("@angular/core").Signal<[number, number] | null>;
+  /**
+   * The span the navigator is dragging, drawn live but not yet written: the
+   * models move once, on release, so whoever fetches hears one window per
+   * gesture rather than one per pixel.
+   */
+  private readonly draft;
+  private drag;
+  /** What is drawn: the drag in progress, else the range's span. */
+  protected readonly drawnSpan: import("@angular/core").Signal<[number, number] | null>;
+  /** Each line cut to the span; a line with nothing in it keeps its legend row. */
+  private readonly windowed;
+  /** Whether the lines read as % change from their own first point. */
+  protected readonly percent: import("@angular/core").Signal<boolean>;
+  private readonly plotWidth;
+  private readonly plotHeight;
+  protected readonly right: import("@angular/core").Signal<number>;
+  protected readonly bottom: import("@angular/core").Signal<number>;
+  protected readonly viewBox: import("@angular/core").Signal<string>;
+  /**
+   * The lines in the axis's terms. A line starting at zero has no % change to
+   * draw, so under `percent` it leaves the plot rather than drawing infinities;
+   * its legend row stays.
+   */
+  protected readonly plotted: import("@angular/core").Signal<Plotted[]>;
+  private readonly extent;
+  private readonly sx;
+  private readonly sy;
+  protected readonly paths: import("@angular/core").Signal<{
+    d: string;
+    color: string;
+    endX: number;
+    endY: number;
+  }[]>;
+  protected readonly yTicks: import("@angular/core").Signal<{
+    y: number;
+    label: string;
+    zero: boolean;
+  }[]>;
+  protected readonly xTicks: import("@angular/core").Signal<{
+    x: number;
+    label: string;
+  }[]>;
+  protected readonly windowLabel: import("@angular/core").Signal<string>;
+  /**
+   * Each series' legend row: its colour, and its change measured across the
+   * window — `—` for a series with nothing in it. Every registered series has
+   * one, so every series has an element of its own to be selected by.
+   */
+  private readonly legendRows;
+  /**
+   * The times the crosshair snaps to: the longest line's, which holds every
+   * date a shorter one does whenever the series share a calendar.
+   */
+  private readonly times;
+  /** Where the crosshair stands, as an index into `times`. New data clears it. */
+  protected readonly hoverIndex: import("@angular/core").WritableSignal<number | null>;
+  /**
+   * The stretch being measured: where it was anchored, then where it reaches,
+   * both times off `times`. New data or a new window clears it — a band over
+   * a span no longer drawn would measure something the reader cannot see.
+   */
+  protected readonly measured: import("@angular/core").WritableSignal<[number, number] | null>;
+  private measuring;
+  private anchored;
+  protected readonly measureView: import("@angular/core").Signal<{
+    start: number;
+    width: number;
+    card: null;
+  } | {
+    start: number;
+    width: number;
+    card: {
+      title: string;
+      rows: {
+        color: string;
+        label: string;
+        noTranslate: boolean;
+        params: Record<string, string> | undefined;
+        value: string;
+        sub: string;
+      }[];
+      flip: boolean;
+      x: number;
+    };
+  } | null>;
+  protected readonly hover: import("@angular/core").Signal<{
+    x: number;
+    title: string;
+    rows: {
+      color: string;
+      label: string;
+      noTranslate: boolean;
+      params: Record<string, string> | undefined;
+      v: number;
+      value: string;
+      sub: string;
+      cx: number;
+      cy: number;
+    }[];
+    flip: boolean;
+  } | null>;
+  /** Where the navigator puts a time, over all the data rather than the window. */
+  private readonly navScale;
+  /**
+   * The navigator as drawn: the first series over all its data, muted — it
+   * says where the window sits, not what the series did — and the window on it.
+   */
+  protected readonly navigatorView: import("@angular/core").Signal<{
+    d: string;
+    area: string;
+    base: number;
+    start: number;
+    end: number;
+    position: number;
+    ticks: {
+      x: number;
+      label: string;
+    }[];
+  } | null>;
+  protected readonly navHeight = 64;
+  protected readonly navTop = 4;
+  protected readonly navViewBox: import("@angular/core").Signal<string>;
+  /** The table view: every drawn point, newest first, one column per line. */
+  protected readonly table: import("@angular/core").Signal<{
+    columns: {
+      label: string;
+      noTranslate: boolean;
+      params: Record<string, string> | undefined;
+    }[];
+    rows: {
+      date: string;
+      cells: string[];
+    }[];
+  }>;
+  constructor();
+  /**
+   * A series arriving takes the lowest slot no other series holds — the slot
+   * a departed series freed, before a new one — so colours stay with the
+   * series they were first given to.
+   */
+  readonly register: (member: SectionChartMember) => void;
+  readonly unregister: (member: SectionChartMember) => void;
+  readonly legendOf: (member: SectionChartMember) => import("@angular/core").Signal<SectionChartLegendRow | undefined>;
+  /**
+   * The reader picked a preset: both models move, so `rangeChange` and
+   * `windowChange` fire together. The window written is the span the preset
+   * names over the data as it stands.
+   */
+  protected readonly selectPreset: (index: number) => void;
+  /** A window set by hand: the range becomes `custom` and the window says where. */
+  private readonly commit;
+  private readonly toWindow;
+  private readonly navTime;
+  /**
+   * A press on the navigator: an edge resizes, the window pans, and the strip
+   * outside it jumps the window there — drawn at once, written on release.
+   */
+  protected readonly onNavigatorDown: (event: PointerEvent) => void;
+  protected readonly onNavigatorMove: (event: PointerEvent) => void;
+  /** Release writes the window once; a press that moved nothing writes nothing. */
+  protected readonly onNavigatorUp: () => void;
+  /** The navigator on the keyboard: ← → pan a tenth of the window, Home End. */
+  protected readonly onNavigatorKeydown: (event: KeyboardEvent) => void;
+  /** The time off `times` nearest a pointer over the plot; null off it. */
+  private readonly plotTime;
+  protected readonly onPointerMove: (event: PointerEvent) => void;
+  /** A press on the plot starts a measure where it lands, when measuring is on. */
+  protected readonly onPlotDown: (event: PointerEvent) => void;
+  /** Release keeps the band; a press that went nowhere was a click, and clears it. */
+  protected readonly onPlotUp: () => void;
+  protected readonly clearHover: () => void;
+  /**
+   * The crosshair on the keyboard: ← → step a point, Shift ten, Home End, Esc.
+   * With measuring on, Enter anchors a measure at the crosshair, the arrows
+   * stretch it, and Enter again leaves it standing; Esc clears both.
+   */
+  protected readonly onKeydown: (event: KeyboardEvent) => void;
+  /** A change as read out: arrow, signed %, and which way it went. */
+  private readonly signedChange;
+  private readonly percentFormats;
+  private readonly formatPercent;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SectionChartComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SectionChartComponent, "m-section-chart", never, {
+    "scale": {
+      "alias": "scale";
+      "required": false;
+      "isSignal": true;
+    };
+    "height": {
+      "alias": "height";
+      "required": false;
+      "isSignal": true;
+    };
+    "navigator": {
+      "alias": "navigator";
+      "required": false;
+      "isSignal": true;
+    };
+    "measure": {
+      "alias": "measure";
+      "required": false;
+      "isSignal": true;
+    };
+    "range": {
+      "alias": "range";
+      "required": false;
+      "isSignal": true;
+    };
+    "window": {
+      "alias": "window";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "range": "rangeChange";
+    "window": "windowChange";
+  }, never, ["*"], true, never>;
+}
+/**
+ * One line of a SectionChart (GLOSSARY.md SectionChartSeries). It registers
+ * with the chart it sits in, at any depth, and the chart draws every
+ * registered series on one axis; what the series draws itself is its legend
+ * row — so the row is the series' own element, which is what an editor selects
+ * it by. Composed rather than configured, SectionTableRow's way — a series
+ * written inside an `@for` is one line per item, one written outside it is one
+ * line.
+ *
+ * Reads any collection as it stands: `x` and `y` name the members holding each
+ * row's time and value, so an api's rows bind with no reshaping first.
+ */
+export declare class SectionChartSeriesComponent {
+  /** The rows this line reads. Unset or empty draws no line. */
+  readonly data: import("@angular/core").InputSignal<readonly unknown[] | null | undefined>;
+  /** The member holding each row's time: epoch ms, an ISO date or a Date. */
+  readonly x: import("@angular/core").InputSignal<string>;
+  /** The member holding each row's value. */
+  readonly y: import("@angular/core").InputSignal<string>;
+  /** What the legend and the tooltip call this line — a translation key. */
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Draws `label` as written: a name read off the data is not a key. */
+  readonly noTranslate: import("@angular/core").InputSignal<boolean>;
+  /**
+   * The [MessageVariable] values `label` is resolved with — the legend, the
+   * tooltip and the table all read the same record. Ignored under
+   * `noTranslate`, where the label is not looked up.
+   */
+  readonly params: import("@angular/core").InputSignal<Record<string, string> | undefined>;
+  /**
+   * A ThemeColor key or any CSS colour. Unset takes the palette slot the chart
+   * gave this series when it arrived, and keeps it while siblings come and go.
+   */
+  readonly color: import("@angular/core").InputSignal<string | undefined>;
+  readonly points: Signal<import("@magmonium/one").SectionChartPoints>;
+  /** The legend row the chart worked out for this series; none outside one. */
+  protected readonly row: Signal<SectionChartLegendRow | undefined>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<SectionChartSeriesComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SectionChartSeriesComponent, "m-section-chart-series", never, {
+    "data": {
+      "alias": "data";
+      "required": false;
+      "isSignal": true;
+    };
+    "x": {
+      "alias": "x";
+      "required": false;
+      "isSignal": true;
+    };
+    "y": {
+      "alias": "y";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "noTranslate": {
+      "alias": "noTranslate";
+      "required": false;
+      "isSignal": true;
+    };
+    "params": {
+      "alias": "params";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * A row's time as epoch ms: a finite number as it stands, a numeric string as
+ * the number it spells, any other string through `Date.parse`, a Date as its
+ * own time. Anything else is no time, and the row it came from is dropped.
+ */
+declare const toChartTime: (value: unknown) => number | null;
+/**
+ * Reads one series out of any collection: `x` names the member holding each
+ * row's time and `y` the member holding its value. A positional row — a tuple
+ * — is read the same way, its places named `0`, `1` and so on. Rows with no
+ * time or no finite value drop; what is left comes back time-ascending.
+ */
+export declare const readChartPoints: (rows: readonly unknown[] | null | undefined, x: string, y: string) => SectionChartPoints;
+/** The first index whose time is not before `x`. */
+declare const lowerBound: (times: readonly number[], x: number) => number;
+/** The index whose time is closest to `x`; the earlier one on a tie. */
+declare const nearestIndex: (times: readonly number[], x: number) => number;
+/**
+ * Each value as % change from the first one. A series starting at zero has
+ * no % change to speak of, so it comes back `null` rather than as infinities.
+ */
+declare const rebase: (values: readonly number[]) => number[] | null;
+/** % change from a series' first value to its last, or null when it has none. */
+declare const chartChange: (values: readonly number[]) => number | null;
+/**
+ * Largest-Triangle-Three-Buckets: at most `n` points that keep the shape —
+ * peaks and troughs survive where every-k-th sampling drops them. The triangle
+ * is measured on the index rather than the time, so milliseconds against
+ * percent never weights one axis over the other.
+ */
+declare const downsample: (t: readonly number[], y: readonly number[], n: number) => SectionChartPoints;
+/**
+ * Round-number ticks covering `min`–`max`, about `count` of them, stepped in
+ * 1, 2 or 5 of a power of ten. The domain widens to the outer ticks so the
+ * plot never ends between two gridlines.
+ */
+declare const niceTicks: (min: number, max: number, count?: number) => {
+  min: number;
+  max: number;
+  ticks: number[];
+};
+/**
+ * Ticks for a time axis at most `maxTicks` wide, read in UTC: Mondays a week
+ * or more apart for spans up to ~100 days, month starts beyond that, and year
+ * starts once months would crowd. A January tick names its year.
+ */
+declare const timeTicks: (t0: number, t1: number, maxTicks: number) => SectionChartTimeTick[];
+/**
+ * The span a preset id names, ending on the last point and measured back from
+ * it rather than from today — data may lag the clock, and a 1M chart of a
+ * series a week stale should still hold a month of it. Calendar months and
+ * years, in UTC. Never reaches before the first point: a 5Y preset over two
+ * years of data is those two years, not three empty ones.
+ *
+ * `max` is everything and `ytd` runs from the last point's 1 January. Any
+ * other id is a count and a unit — `10d`, `2w`, `3m`, `5y` — and anything
+ * else names no span.
+ */
+declare const presetSpan: (id: string, first: number, last: number) => [number, number] | null;
+/** Whether an id names a span at all — what a preset list keeps. */
+declare const isPresetId: (id: unknown) => id is string;
+/** What a preset's button reads: its id, upper-cased — `1M`, `YTD`, `MAX`. */
+declare const presetLabel: (id: string) => string;
+/** The points of a series that fall in `from`–`to`, both ends included. */
+declare const sliceSpan: (points: SectionChartPoints, from: number, to: number) => SectionChartPoints;
+/** What a press on the navigator takes hold of. */
+type NavigatorGrip = 'start' | 'end' | 'move' | 'outside';
+/**
+ * Which part of the window a press at `t` takes hold of: an edge within
+ * `slop` of it, the window itself between them, or the strip outside. The
+ * nearer edge wins when a narrow window puts both within reach.
+ */
+declare const navigatorGrip: (t: number, span: readonly [number, number], slop: number) => NavigatorGrip;
+/** A span moved by `delta`, its width kept and its ends kept inside `bounds`. */
+declare const panSpan: (span: readonly [number, number], delta: number, bounds: readonly [number, number]) => [number, number];
+/** A span of the same width centred on `t`, kept inside `bounds`. */
+declare const centreSpan: (span: readonly [number, number], t: number, bounds: readonly [number, number]) => [number, number];
+/**
+ * A span with one edge dragged to `t`. The edge stops `minWidth` short of the
+ * other one rather than crossing it, and never leaves `bounds`.
+ */
+declare const resizeSpan: (span: readonly [number, number], edge: "start" | "end", t: number, bounds: readonly [number, number], minWidth: number) => [number, number];
+/** An SVG path through the points, straight segments — a curve invents highs. */
+declare const linePath: (t: readonly number[], y: readonly number[], sx: (t: number) => number, sy: (v: number) => number) => string;
+/**
+ * The points a SectionChart draws on the Canvas when its series hold no data:
+ * a year of weekly closes per series, deterministic so a screenshot never
+ * moves, each series drifting its own way so a comparison reads as one.
+ */
+declare const sampleChartPoints: (index: number, end?: number) => SectionChartPoints;
 type TabGroup = Config & {
   tabs: Button[];
   activeTabId?: string;
@@ -17196,4 +17788,4 @@ export declare const toggleUid: (audience: Audience, uid: string) => Audience;
 export declare const toggleGroup: (audience: Audience, groupId: string) => Audience;
 /** How many Users and Groups an Audience names. */
 export declare const pickCount: (audience: Audience) => number;
-export type { Accordion, AccordionGroup, AccordionVariant, AppCardData, AppCardInputs, AppCardVariant, AppLogoTone, AppLogoVariant, AppManifest, AppTileData, AssetOption, Audience, AudienceLevel, AudienceMember, AudiencePicker, AuthResult, Badge, BadgeCount, BadgePosition, BadgeVariant, Button, ButtonGroup, CellChangeEvent, CellClickEvent, ColBreakpoint, ColSpan, ColorPallet, ColumnDef, Comment, CommentItem, Config, ContextMenu, ContextMenuEvent, Cursor, CustomIcon, DragListReorder, Draggable, DraggableState, FileUploadConfig, FileUploadEvent, FilterGroupContext, FilterGroupMember, FilterOption, FilterPanel, FilterPanelIo, FilterRangeMode, FilterSelectionMap, FilterValue, FilterVariant, FilteredTreeGrid, FlatTreeGridRow, FlexAlign, FlexAlignSelf, FlexConfig, FlexDirection, FlexItemConfig, FlexJustify, FlexVariant, GridAlignX, GridAlignY, GroupActionEvent, GroupDropEvent, GroupKind, GroupMenuEvent, Header, HeaderLevel, HeatSwatchRadius, Icon, KeyValueVariant, LabelSegment, ListConfig, ListContext, ListItem, ListOrientation, ListVariant, MenuItem, MoneySystem, NavCountConfig, NavInstanceConfig, NavMenuConfig, NavRowsConfig, NavVisibilityConfig, NavVisibleAnswer, NavWidgetConfig, NavWidgetEntry, NavWidgetMap, OverlayWidgetLoader, OverlayWidgetMap, PageChangeEvent, Pagination, PaginationWindow, ResolvedUserTab, RowDropEvent, SearchChangeEvent, SectionAccordion, SectionAccordionGroup, SectionAccordionGroupContext, SectionAccordionRef, SectionButtonGroupConfig, SectionFilterGroupConfig, SectionHero, SectionHeroVariant, SectionTableAlign, SectionTableColumn, SectionTableConfig, SectionTableDataType, SectionTableSort, SectionTableSortDirection, SectionTableVariant, SectionToggleItem, SectionToggleItemContext, SelectionAction, SelectionActionEvent, SelectionChangeEvent, SelectorConfig, SharingClient, SharingGroup, SocketMessage, Sort, SortChange, SortChangeEvent, SortOption, SortOrder, SourceAudience, SpacingInward, SqueezeMode, StatAlign, StatCornerEdge, StatCornerPosition, StatCornerSide, StatSurface, StatVariant, TabGroup, TableConfig, TableFilterCondition, TableFilterDef, TableGroup, TextOrNumberInput, Timeline, TimelineItem, TreeGridCellClickEvent, TreeGridLoadChildrenEvent, TreeGridRow, TreeGridRowSelectEvent, TreeGridToggleEvent, User };
+export type { Accordion, AccordionGroup, AccordionVariant, AppCardData, AppCardInputs, AppCardVariant, AppLogoTone, AppLogoVariant, AppManifest, AppTileData, AssetOption, Audience, AudienceLevel, AudienceMember, AudiencePicker, AuthResult, Badge, BadgeCount, BadgePosition, BadgeVariant, Button, ButtonGroup, CellChangeEvent, CellClickEvent, ColBreakpoint, ColSpan, ColorPallet, ColumnDef, Comment, CommentItem, Config, ContextMenu, ContextMenuEvent, Cursor, CustomIcon, DragListReorder, Draggable, DraggableState, FileUploadConfig, FileUploadEvent, FilterGroupContext, FilterGroupMember, FilterOption, FilterPanel, FilterPanelIo, FilterRangeMode, FilterSelectionMap, FilterValue, FilterVariant, FilteredTreeGrid, FlatTreeGridRow, FlexAlign, FlexAlignSelf, FlexConfig, FlexDirection, FlexItemConfig, FlexJustify, FlexVariant, GridAlignX, GridAlignY, GroupActionEvent, GroupDropEvent, GroupKind, GroupMenuEvent, Header, HeaderLevel, HeatSwatchRadius, Icon, KeyValueVariant, LabelSegment, ListConfig, ListContext, ListItem, ListOrientation, ListVariant, MenuItem, MoneySystem, NavCountConfig, NavInstanceConfig, NavMenuConfig, NavRowsConfig, NavVisibilityConfig, NavVisibleAnswer, NavWidgetConfig, NavWidgetEntry, NavWidgetMap, OverlayWidgetLoader, OverlayWidgetMap, PageChangeEvent, Pagination, PaginationWindow, ResolvedUserTab, RowDropEvent, SearchChangeEvent, SectionAccordion, SectionAccordionGroup, SectionAccordionGroupContext, SectionAccordionRef, SectionButtonGroupConfig, SectionChartConfig, SectionChartPoints, SectionChartScale, SectionChartWindow, SectionFilterGroupConfig, SectionHero, SectionHeroVariant, SectionTableAlign, SectionTableColumn, SectionTableConfig, SectionTableDataType, SectionTableSort, SectionTableSortDirection, SectionTableVariant, SectionToggleItem, SectionToggleItemContext, SelectionAction, SelectionActionEvent, SelectionChangeEvent, SelectorConfig, SharingClient, SharingGroup, SocketMessage, Sort, SortChange, SortChangeEvent, SortOption, SortOrder, SourceAudience, SpacingInward, SqueezeMode, StatAlign, StatCornerEdge, StatCornerPosition, StatCornerSide, StatSurface, StatVariant, TabGroup, TableConfig, TableFilterCondition, TableFilterDef, TableGroup, TextOrNumberInput, Timeline, TimelineItem, TreeGridCellClickEvent, TreeGridLoadChildrenEvent, TreeGridRow, TreeGridRowSelectEvent, TreeGridToggleEvent, User };