@pond-ts/charts 0.57.0 → 0.58.0

package/dist/theme.js

@@ -1,78 +1,199 @@
 /**
- * The neutral default theme. `default` / `primary` match the M1 `LineChart`
- * colour (`#2563eb`) so adopting the theme channel doesn't shift existing
- * renders. `primary` / `secondary` / `context` are a built-in generic role
- * vocabulary; an unrecognised (e.g. domain-specific) identifier falls back to
- * `default`.
+ * The neutral default theme. The shared data hue is a cerulean (`#0284c7`)
+ * across `line` / `band` / `area` / `scatter` / `box` / candle-rising, chosen
+ * to clear the bar palette's *selection* blue (`#3F5BE0`) — the original M1
+ * royal blue (`#2563eb`) sat ~ΔE 5 from it, so a line drawn over bars read as
+ * nearly the selection colour. `primary` / `secondary` / `context` are a
+ * built-in generic role vocabulary; an unrecognised (e.g. domain-specific)
+ * identifier falls back to `default`.
+ *
+ * **Spreading this inherits every slot you don't override** — including colours
+ * for layers you haven't added yet, so a `{ ...defaultTheme, bar: … }` theme
+ * paints this blue the first time someone drops in a `<LineChart>`. That is the
+ * intended workflow, not a trap: take the defaults, change the one or two things
+ * that are yours. A design system that must own *every* colour should assert on
+ * that in its own test rather than catch it in review — walk the resolved theme
+ * for values outside your palette ([PND-THEMEBASE]).
+ *
+ * **The `bar` slot is the exception to "one blue".** Bars carry an interaction
+ * state (rest / hover / selected / dimmed), and encoding four states as four
+ * shades of one hue is unreadable — so `bar.default` runs its own
+ * **interaction-state palette**: teal at rest, blue when selected, brighter
+ * teal on hover. See the comment on that slot, and `brush` for the matching
+ * drag band.
  */
 export const defaultTheme = {
     line: {
-        default: { color: '#2563eb', width: 1.5 },
-        primary: { color: '#2563eb', width: 1.5 },
-        secondary: { color: '#e8836b', width: 1.5 },
-        context: { color: '#5eb5a6', width: 1.5 },
+        // **Trace interaction state is weight, plus a hue for a swept WINDOW
+        // only** — see `LineStyle.selectedWidth` / `.spanColor`. A whole-series
+        // selection thickens and keeps its colour, because colour is which series
+        // it is; a window inside one series can take the selection blue, because
+        // there identity is not in question. `spanColor` is `bar.highlight`, so a
+        // swept region on a trace reads as the same act as the band that made it.
+        default: {
+            color: '#0284c7',
+            width: 1.5,
+            selectedWidth: 3,
+            dimmedOpacity: 0.32,
+            spanColor: '#3F5BE0',
+        },
+        primary: {
+            color: '#0284c7',
+            width: 1.5,
+            selectedWidth: 3,
+            dimmedOpacity: 0.32,
+            spanColor: '#3F5BE0',
+        },
+        secondary: {
+            color: '#e8836b',
+            width: 1.5,
+            selectedWidth: 3,
+            dimmedOpacity: 0.32,
+            spanColor: '#3F5BE0',
+        },
+        context: {
+            color: '#5eb5a6',
+            width: 1.5,
+            selectedWidth: 3,
+            dimmedOpacity: 0.32,
+            spanColor: '#3F5BE0',
+        },
     },
     band: {
-        default: { fill: '#2563eb', opacity: 0.15 },
-        outer: { fill: '#2563eb', opacity: 0.1 },
-        inner: { fill: '#2563eb', opacity: 0.2 },
+        default: { fill: '#0284c7', opacity: 0.15 },
+        outer: { fill: '#0284c7', opacity: 0.1 },
+        inner: { fill: '#0284c7', opacity: 0.2 },
     },
     area: {
         // Outline at the line colour; graded fill from it. `in`/`out` are the
         // above/below-axis roles (esnet traffic), composed as two layers.
+        // Trace interaction state — see `AreaStyle.selectedWidth`. `spanColor` is
+        // `bar.highlight`, so a swept region reads as the same act as the band.
         default: {
-            color: '#2563eb',
+            color: '#0284c7',
             width: 1.5,
-            fill: '#2563eb',
+            fill: '#0284c7',
             fillOpacity: 0.3,
+            selectedWidth: 3,
+            selectedFillOpacity: 0.55,
+            dimmedOpacity: 0.32,
+            spanColor: '#3F5BE0',
         },
-        in: { color: '#2563eb', width: 1.5, fill: '#2563eb', fillOpacity: 0.3 },
+        in: { color: '#0284c7', width: 1.5, fill: '#0284c7', fillOpacity: 0.3 },
         out: { color: '#e8836b', width: 1.5, fill: '#e8836b', fillOpacity: 0.3 },
     },
     scatter: {
-        // Brand blue fill with a white ring (legible on a busy plot); the selected
-        // point gets a darker, wider ring. `primary`/`secondary` mirror the line
-        // roles so a scatter overlaid on a line can share its identity.
+        // A 9px teal point with a white ring (legible on a busy plot), and the
+        // shared `states` ladder over it. `primary`/`secondary` keep the LINE
+        // roles' hues — that identity is the whole reason they exist, so a
+        // scatter overlaid on a line still reads as the same series — and take
+        // the same states with their own hue brightened for hover.
+        //
+        // The default role's rest is `#2A9D8F`, the bar's resting teal, and NOT
+        // the old cerulean `#0284c7`: blue has to mean *committed*, and a
+        // cerulean point going to selection blue is barely a change. Same rule
+        // the bar palette reached, for the third time.
         default: {
-            color: '#2563eb',
-            radius: 4,
+            color: '#2A9D8F',
+            radius: 4.5,
             outline: '#ffffff',
             outlineWidth: 1,
             selectedOutline: '#1e293b',
             selectedWidth: 2,
             label: '#334155',
+            states: {
+                hover: '#4FD0BE',
+                hoverRadius: 5.5,
+                selected: '#3F5BE0', // the shared selection blue
+                halo: '#ffffff',
+                haloWidth: 2,
+                dimmedRadius: 2.5,
+                dimmedOpacity: 0.34,
+            },
         },
         primary: {
-            color: '#2563eb',
-            radius: 4,
+            color: '#0284c7',
+            radius: 4.5,
             outline: '#ffffff',
             outlineWidth: 1,
             selectedOutline: '#1e293b',
             selectedWidth: 2,
             label: '#334155',
+            states: {
+                hover: '#38bdf8', // the primary cerulean, brightened
+                hoverRadius: 5.5,
+                selected: '#3F5BE0', // the shared selection blue
+                halo: '#ffffff',
+                haloWidth: 2,
+                dimmedRadius: 2.5,
+                dimmedOpacity: 0.34,
+            },
         },
         secondary: {
             color: '#e8836b',
-            radius: 4,
+            radius: 4.5,
             outline: '#ffffff',
             outlineWidth: 1,
             selectedOutline: '#1e293b',
             selectedWidth: 2,
             label: '#334155',
+            states: {
+                hover: '#f5a991', // the secondary coral, brightened
+                hoverRadius: 5.5,
+                selected: '#3F5BE0', // the shared selection blue
+                halo: '#ffffff',
+                haloWidth: 2,
+                dimmedRadius: 2.5,
+                dimmedOpacity: 0.34,
+            },
+        },
+    },
+    heat: {
+        // A cell's colour is its value, so every state here is chrome around the
+        // cell (or one uniform transform over all of them) — see `HeatStates`.
+        default: {
+            veil: 'rgba(255,255,255,0.62)',
+            // White outside, dark teal inside: one of the pair reads wherever on
+            // the ramp the cell happens to sit.
+            hoverRing: ['#ffffff', '#12564E'],
+            ringWidth: 2,
+            // The shared selection blue — a selected region beside a selected bar
+            // reads as one act.
+            perimeter: '#3F5BE0',
+            perimeterWidth: 2,
         },
     },
     box: {
-        // The blue brand box: a translucent fill outlined in the line colour, a
+        // The cerulean data box: a translucent fill outlined in the line colour, a
         // bolder median, and matching whiskers.
         default: {
-            fill: '#2563eb',
+            fill: '#0284c7',
             fillOpacity: 0.3,
-            stroke: '#2563eb',
-            strokeWidth: 1.5,
-            median: '#1e3a8a',
+            stroke: '#0284c7',
+            // 1px at rest, 1.5 when selected (`selectedStrokeWidth`) — the design's
+            // hairline rule. Previously a flat 1.5, which left no headroom for a
+            // weight change to mean anything.
+            strokeWidth: 1,
+            median: '#075985',
             medianWidth: 2,
-            whisker: '#aabee9',
+            whisker: '#a3cde5',
             whiskerWidth: 1,
+            // The tint ladder. Lightness spacing is held across all three ladders,
+            // so the quantile read (outer < inner < stroke < median) never changes —
+            // only where the ladder sits does. It follows the bar palette's rule
+            // exactly: hover brightens within teal, blue means committed. Step 2 of
+            // each ladder IS the matching bar token (`bar.hover` / `bar.highlight`),
+            // so a live box beside a live bar reads as one act.
+            states: {
+                rest: ['#BFE3DE', '#7FC8BF', '#2A9D8F', '#1F7A6F'],
+                // Hover brightens *within teal* — blue stays reserved for a committed
+                // selection, the same rule `bar.hover` follows (and step 2 is exactly
+                // `bar.default.hover`, so a hovered box and a hovered bar match).
+                hover: ['#D6F1EC', '#9CDBD1', '#3FBFAE', '#2A9D8F'],
+                selected: ['#C0CAF6', '#8095EA', '#3F5BE0', '#1C2E9E'],
+                dimmedOpacity: 0.32,
+            },
+            selectedStrokeWidth: 1.5,
         },
         // The warm accent box — the second series of a paired distribution (an
         // in/out traffic list), mirroring `bar.secondary` / `line.secondary`.
@@ -89,31 +210,62 @@ export const defaultTheme = {
     },
     candle: {
         // Neutral / unbranded up-down pair — *not* market green/red (a consumer
-        // supplies that via cssVarTheme). Rising reuses the brand blue; falling the
-        // warm secondary accent — distinguishable at a glance on the light ground.
+        // supplies that via cssVarTheme). Rising reuses the data cerulean; falling
+        // the warm secondary accent — distinguishable at a glance on light ground.
         default: {
-            rising: { body: '#2563eb', wick: '#1e3a8a' },
+            rising: { body: '#0284c7', wick: '#075985' },
             falling: { body: '#e8836b', wick: '#b4442a' },
             neutral: { body: '#94a3b8', wick: '#64748b' },
             bodyWidth: 0.7,
             wickWidth: 1,
+            // No state colour at all — the direction hue owns that channel. A live
+            // candle simply grows (its body stroked in its own colour, lines
+            // heavier); a selection additionally recedes the field to `.32`, the
+            // same step every other mark uses.
+            dimmedOpacity: 0.32,
+            liveWickWidth: 1.5,
         },
     },
     bar: {
-        // Flat blue fill; the selected bar brightens + outlines. `secondary` reuses
-        // the line's warm accent for a second series.
+        // The **interaction-state palette**: state is a *hue* difference, not a
+        // shade of one colour. Rest is teal; a committed selection is blue; hover
+        // is a *brighter teal* — deliberately not blue, because blue is reserved
+        // for "committed". Out-of-selection bars recede to the same teal at 0.32.
+        // The shared drag band (`brush` below) is the selection blue at 7%, so the
+        // live region reads as the same act as the selection it is about to make.
+        // `secondary` reuses the line's warm accent for a second series.
         default: {
-            fill: '#2563eb',
-            opacity: 0.85,
-            highlight: '#1d4ed8',
+            fill: '#2A9D8F', // rest — teal, full opacity
+            opacity: 1,
+            highlight: '#3F5BE0', // selected — blue; committed state
+            hover: '#3FBFAE', // hover — brighter teal, never blue
+            dimmed: 'rgba(42,157,143,0.32)', // outside an active selection
             gap: 1,
             minWidth: 1,
             outlineWidth: 1.5,
-            // The default threshold ladder: the bar's own blue as the in-range band,
+            // The default threshold ladder: the bar's own teal as the in-range band,
             // then amber, then red. Three entries serves the common two-threshold
             // ok/warning/alarm ladder out of the box; a longer `thresholds` needs a
             // longer ladder from the theme or `bandColors`.
-            bands: ['#2563eb', '#e8a13c', '#d64545'],
+            bands: ['#2A9D8F', '#e8a13c', '#d64545'],
+            // The **stack group ramp**, first group first (so a vertical stack reads
+            // teal at the bottom up to terracotta). Four muted hues at similar
+            // lightness, so no segment shouts over its neighbours the way a
+            // saturation ladder would — the ramp says "different group", not
+            // "more important". It starts on a teal near the resting `fill` so a
+            // two-group stack still looks like the rest of the palette.
+            groups: ['#4c9e8f', '#5379be', '#e2a54a', '#b5604e'],
+            // Each ramp entry desaturated (~×0.18) and lightened toward the ground,
+            // keeping its hue and its *relative* lightness — so a receded bin still
+            // reads as four bands rather than one grey block, and the amber stays
+            // the lightest of them as it is in the vivid ramp.
+            groupsDimmed: ['#c7cecd', '#ced1d6', '#dcd8d2', '#d3cdcc'],
+            // Each ramp entry brightened by the same move `fill` → `hover` makes:
+            // hue held, lightness +0.11, saturation left alone. So a hovered segment
+            // still says which group it is — the thing a single hover colour cannot
+            // do on a stack, and under a <MultiSelector> (block-scoped hover) it is
+            // the whole bin that would otherwise go one flat colour.
+            groupsHover: ['#6bb8a9', '#7c99cd', '#eabd7a', '#c68476'],
         },
         secondary: {
             fill: '#e8836b',
@@ -140,15 +292,39 @@ export const defaultTheme = {
         size: 11,
     },
     cursor: '#64748b',
+    // The drag band in the bar palette's selection blue at 7%, edged at 1px —
+    // the live region reads as the selection it is about to commit.
+    brush: { fill: 'rgba(63,91,224,0.07)', edge: 'rgba(63,91,224,0.45)' },
     chip: { background: '#ffffff' },
     gap: { connectorOpacity: 0.5 },
-    // Teal marks register — distinct from the blue data, reads on the light ground.
+    // Burnt-amber marks register — a deliberately warm outlier against every
+    // data hue, so a placed mark never reads as data (the same rule the docs
+    // brand's `vizMark` encodes). Verified against the whole palette: its
+    // nearest data neighbours are the threshold-ladder red `#d64545` (ΔE2000
+    // ≈ 18) and the warm secondary accent `#e8836b` (ΔE2000 ≈ 21); everything
+    // else — bar teal, hover teal, selection blue, the data cerulean — clears
+    // ΔE2000 40+. (The previous turquoise `#0d9488` sat ~ΔE 4 from the bar
+    // palette's resting teal `#2A9D8F` — indistinguishable at a glance.)
     annotation: {
-        color: '#0d9488',
+        color: '#b45309',
+        // EXPERIMENTAL — a lighter orange for a swept window's edge rules, which
+        // mark a candidate range rather than a committed mark. See `spanEdge`.
+        spanEdge: '#f0b26b',
         fillOpacity: 0.1,
         depth: [1, 0.7, 0.4],
     },
     // The in-chart series key: chip-white card, gridline border, axis-label text.
+    // The row-chart register — see `ChartTheme.list`. The two band tints are
+    // the only genuinely new values: the rails are the same teal/blue pair the
+    // bar's interaction-state palette already uses (`hover` / `highlight`), and
+    // the marker ink is the near-black the annotation register reads against.
+    list: {
+        hoverBand: '#F6F6F3', // warm neutral — a lift, not a hue
+        hoverRail: '#4FD0BE', // brighter teal, never blue
+        selectedBand: '#EEF1FD', // the selection blue, washed
+        selectedRail: '#3F5BE0', // = bar.default.highlight — committed state
+        markerInk: '#1C1C1A', // reserved from the selection hue (see the doc)
+    },
     legend: {
         background: '#ffffff',
         border: '#e2e8f0',

package/dist/tracker.d.ts

@@ -48,6 +48,12 @@ export declare const DEFAULT_CURSOR_MODE: CursorMode;
  * presets — `line` is line-only, `point` / `inline` / `flag` are dot-based with
  * no line, `none` draws nothing. `flag` raises a staff from each point to a
  * value flag stacked near the top of the row (drawn in `Layers`).
+ *
+ * **Superseded by the mounted cursor presets** (`cursors.tsx` — each mode's
+ * drawing now lives in its component's registered spec): `Layers` no longer
+ * reads this. Kept, with its tests, for the life of the `cursor` string-prop
+ * deprecation window as the pinned record of what each mode drew; delete both
+ * when the modes go.
  */
 export declare function cursorParts(mode: CursorMode): {
     readonly line: boolean;

package/dist/tracker.js

@@ -79,6 +79,12 @@ export const DEFAULT_CURSOR_MODE = 'line';
  * presets — `line` is line-only, `point` / `inline` / `flag` are dot-based with
  * no line, `none` draws nothing. `flag` raises a staff from each point to a
  * value flag stacked near the top of the row (drawn in `Layers`).
+ *
+ * **Superseded by the mounted cursor presets** (`cursors.tsx` — each mode's
+ * drawing now lives in its component's registered spec): `Layers` no longer
+ * reads this. Kept, with its tests, for the life of the `cursor` string-prop
+ * deprecation window as the pinned record of what each mode drew; delete both
+ * when the modes go.
  */
 export function cursorParts(mode) {
     const base = { line: false, dots: false, chip: 'none', band: false };

package/dist/tradingAxis.fixture.d.ts

@@ -0,0 +1,78 @@
+import { BoundedSequence, TimeSeries } from 'pond-ts';
+import type { SeriesSchema } from 'pond-ts';
+import type { DiscontinuityProvider, TradingCalendarLike } from './tradingTimeScale.js';
+/**
+ * Shared fixtures for the trading-time-axis stories (reference + interaction).
+ * A session calendar + **inline** discontinuity provider (in real use you'd pass
+ * `calendar.discontinuities()` from `@pond-ts/financial`); the axis only needs
+ * the structural provider, so charts stays decoupled.
+ */
+export declare const H = 3600000;
+export declare const DAY = 86400000;
+export declare const MIN = 60000;
+export declare const MON: number;
+export declare const WIDTH = 720;
+export interface Session {
+    date: string;
+    open: number;
+    close: number;
+}
+/** `count` weekday sessions from the anchor Monday (09:30–16:00 UTC), skipping
+ *  weekends and an optional holiday date — a stand-in for a real calendar. */
+export declare function weekdaySessions(count: number, holiday?: string): Session[];
+/** An early-close (half-day) variant of the last session. */
+export declare function withHalfDay(sessions: Session[], closeHour?: number): Session[];
+/** A proportional trading-time provider over the sessions' `[open, close)` spans. */
+export declare function provider(sessions: Session[]): DiscontinuityProvider;
+/** A **uniform** trading-time provider — each session is one equal-width slot
+ *  regardless of duration (a half-day is as wide as a full day). */
+export declare function uniformProvider(sessions: Session[]): DiscontinuityProvider;
+/** A structural {@link TradingCalendarLike} — the shape `@pond-ts/financial`'s
+ *  `TradingCalendar` satisfies — that the container's `spacing` prop drives. */
+export declare function calendarOf(sessions: Session[]): TradingCalendarLike;
+/** One interval per session — the daily-bar grid. */
+export declare function sessionSeq(sessions: Session[]): BoundedSequence;
+/** Intraday `period`-ms bars within each session (never crossing a boundary). */
+export declare function barSeq(sessions: Session[], periodMs: number): BoundedSequence;
+export declare const tickSchema: readonly [{
+    readonly name: "time";
+    readonly kind: "time";
+}, {
+    readonly name: "price";
+    readonly kind: "number";
+}];
+/** Deterministic in-session price ticks (a smooth random-ish walk on sines). */
+export declare function ticks(sessions: Session[], stepMs: number): TimeSeries<typeof tickSchema>;
+/** Intraday ticks with an **overnight gap**: each session opens at a distinct
+ *  base level (a gap up from the prior close) while the intraday wiggle stays
+ *  smooth. So a session boundary is a real price jump — the connected line shows
+ *  a near-vertical bridge across the collapsed gap, `sessionBreaks` a clean
+ *  pen-up. (Plain {@link ticks} walks continuously across sessions, so close ≈
+ *  next open and the break is invisible — this is the fixture that shows it.) */
+export declare function gappingTicks(sessions: Session[], stepMs: number): TimeSeries<typeof tickSchema>;
+export declare const OHLC: {
+    readonly open: {
+        readonly from: "price";
+        readonly using: "first";
+    };
+    readonly high: {
+        readonly from: "price";
+        readonly using: "max";
+    };
+    readonly low: {
+        readonly from: "price";
+        readonly using: "min";
+    };
+    readonly close: {
+        readonly from: "price";
+        readonly using: "last";
+    };
+};
+/** Interval-keyed OHLC candles over a bucket sequence (immune to point-key slot
+ *  widths). Return type widened to the general `SeriesSchema`: the inferred
+ *  aggregate schema references an internal pond-ts module and can't be named
+ *  (TS2742), so an explicit annotation is required. `<Candlestick>` reads the
+ *  o/h/l/c columns by runtime name, so the widening is invisible to callers. */
+export declare function candles(sessions: Session[], seq: BoundedSequence, stepMs: number): TimeSeries<SeriesSchema>;
+export declare function rangeOf(sessions: Session[]): [number, number];
+//# sourceMappingURL=tradingAxis.fixture.d.ts.map

package/dist/tradingAxis.fixture.js

@@ -0,0 +1,215 @@
+import { BoundedSequence, Interval, TimeSeries } from 'pond-ts';
+/**
+ * Shared fixtures for the trading-time-axis stories (reference + interaction).
+ * A session calendar + **inline** discontinuity provider (in real use you'd pass
+ * `calendar.discontinuities()` from `@pond-ts/financial`); the axis only needs
+ * the structural provider, so charts stays decoupled.
+ */
+export const H = 3_600_000;
+export const DAY = 86_400_000;
+export const MIN = 60_000;
+export const MON = Date.UTC(2026, 0, 5); // a Monday
+export const WIDTH = 720;
+/** `count` weekday sessions from the anchor Monday (09:30–16:00 UTC), skipping
+ *  weekends and an optional holiday date — a stand-in for a real calendar. */
+export function weekdaySessions(count, holiday) {
+    const out = [];
+    for (let dayIdx = 0; out.length < count; dayIdx++) {
+        const dayStart = MON + dayIdx * DAY;
+        const dow = new Date(dayStart).getUTCDay();
+        if (dow === 0 || dow === 6)
+            continue; // weekend
+        const date = new Date(dayStart).toISOString().slice(0, 10);
+        if (date === holiday)
+            continue;
+        out.push({ date, open: dayStart + 9.5 * H, close: dayStart + 16 * H });
+    }
+    return out;
+}
+/** An early-close (half-day) variant of the last session. */
+export function withHalfDay(sessions, closeHour = 13) {
+    const last = sessions[sessions.length - 1];
+    const dayStart = last.open - 9.5 * H;
+    return [
+        ...sessions.slice(0, -1),
+        { ...last, close: dayStart + closeHour * H },
+    ];
+}
+/** A proportional trading-time provider over the sessions' `[open, close)` spans. */
+export function provider(sessions) {
+    const segs = sessions.map((s) => [s.open, s.close]);
+    const cum = [0];
+    for (const [a, b] of segs)
+        cum.push(cum[cum.length - 1] + (b - a));
+    const total = cum[cum.length - 1];
+    const liveMs = (t) => {
+        if (t <= segs[0][0])
+            return 0;
+        if (t >= segs[segs.length - 1][1])
+            return total;
+        for (let i = 0; i < segs.length; i++) {
+            const [a, b] = segs[i];
+            if (t < a)
+                return cum[i];
+            if (t < b)
+                return cum[i] + (t - a);
+        }
+        return total;
+    };
+    const inst = (L) => {
+        if (L <= 0)
+            return segs[0][0];
+        if (L >= total)
+            return segs[segs.length - 1][1];
+        for (let i = 0; i < segs.length; i++) {
+            if (L < cum[i + 1])
+                return segs[i][0] + (L - cum[i]);
+        }
+        return segs[segs.length - 1][1];
+    };
+    const self = {
+        distance: (a, b) => liveMs(b) - liveMs(a),
+        offset: (v, amt) => inst(liveMs(v) + amt),
+        clampUp: (t) => t,
+        clampDown: (t) => t,
+        copy: () => self,
+        boundaries: (from, to) => {
+            const out = [];
+            for (let i = 1; i < segs.length; i++) {
+                const start = segs[i][0];
+                if (start > segs[i - 1][1] && start > from && start < to)
+                    out.push(start);
+            }
+            return out;
+        },
+    };
+    return self;
+}
+/** A **uniform** trading-time provider — each session is one equal-width slot
+ *  regardless of duration (a half-day is as wide as a full day). */
+export function uniformProvider(sessions) {
+    const segs = sessions.map((s) => [s.open, s.close]);
+    const n = segs.length;
+    const uCoord = (t) => {
+        if (t <= segs[0][0])
+            return 0;
+        if (t >= segs[n - 1][1])
+            return n;
+        for (let i = 0; i < n; i++) {
+            const [a, b] = segs[i];
+            if (t < a)
+                return i; // in a gap before session i → the boundary
+            if (t < b)
+                return i + (t - a) / (b - a); // linear within the session
+        }
+        return n;
+    };
+    const inst = (u) => {
+        if (u <= 0)
+            return segs[0][0];
+        if (u >= n)
+            return segs[n - 1][1];
+        const i = Math.floor(u);
+        const [a, b] = segs[i];
+        return a + (u - i) * (b - a);
+    };
+    const self = {
+        distance: (x, y) => uCoord(y) - uCoord(x),
+        offset: (v, amt) => inst(uCoord(v) + amt),
+        clampUp: (t) => t,
+        clampDown: (t) => t,
+        copy: () => self,
+        boundaries: (from, to) => {
+            const out = [];
+            for (let i = 1; i < n; i++) {
+                const start = segs[i][0];
+                if (start > segs[i - 1][1] && start > from && start < to)
+                    out.push(start);
+            }
+            return out;
+        },
+    };
+    return self;
+}
+/** A structural {@link TradingCalendarLike} — the shape `@pond-ts/financial`'s
+ *  `TradingCalendar` satisfies — that the container's `spacing` prop drives. */
+export function calendarOf(sessions) {
+    return {
+        discontinuities: (options) => options?.spacing === 'uniform'
+            ? uniformProvider(sessions)
+            : provider(sessions),
+    };
+}
+/** One interval per session — the daily-bar grid. */
+export function sessionSeq(sessions) {
+    return new BoundedSequence(sessions.map((s) => new Interval({ value: s.date, start: s.open, end: s.close })));
+}
+/** Intraday `period`-ms bars within each session (never crossing a boundary). */
+export function barSeq(sessions, periodMs) {
+    const ivals = [];
+    for (const s of sessions) {
+        for (let t = s.open; t < s.close; t += periodMs) {
+            ivals.push(new Interval({
+                value: t,
+                start: t,
+                end: Math.min(t + periodMs, s.close),
+            }));
+        }
+    }
+    return new BoundedSequence(ivals);
+}
+export const tickSchema = [
+    { name: 'time', kind: 'time' },
+    { name: 'price', kind: 'number' },
+];
+/** Deterministic in-session price ticks (a smooth random-ish walk on sines). */
+export function ticks(sessions, stepMs) {
+    const rows = [];
+    let i = 0;
+    for (const s of sessions) {
+        for (let t = s.open; t < s.close; t += stepMs, i++) {
+            const price = 100 +
+                9 * Math.sin(i / 22) +
+                3 * Math.sin(i / 4.5) +
+                1.4 * Math.sin(i / 1.3);
+            rows.push([t, price]);
+        }
+    }
+    return new TimeSeries({ name: 'ticks', schema: tickSchema, rows });
+}
+/** Intraday ticks with an **overnight gap**: each session opens at a distinct
+ *  base level (a gap up from the prior close) while the intraday wiggle stays
+ *  smooth. So a session boundary is a real price jump — the connected line shows
+ *  a near-vertical bridge across the collapsed gap, `sessionBreaks` a clean
+ *  pen-up. (Plain {@link ticks} walks continuously across sessions, so close ≈
+ *  next open and the break is invisible — this is the fixture that shows it.) */
+export function gappingTicks(sessions, stepMs) {
+    const rows = [];
+    let i = 0;
+    sessions.forEach((s, si) => {
+        const base = 100 + si * 6; // each session gaps ~6 above the last
+        for (let t = s.open; t < s.close; t += stepMs, i++) {
+            const price = base + 4 * Math.sin(i / 18) + 1.5 * Math.sin(i / 3.5);
+            rows.push([t, price]);
+        }
+    });
+    return new TimeSeries({ name: 'ticks', schema: tickSchema, rows });
+}
+export const OHLC = {
+    open: { from: 'price', using: 'first' },
+    high: { from: 'price', using: 'max' },
+    low: { from: 'price', using: 'min' },
+    close: { from: 'price', using: 'last' },
+};
+/** Interval-keyed OHLC candles over a bucket sequence (immune to point-key slot
+ *  widths). Return type widened to the general `SeriesSchema`: the inferred
+ *  aggregate schema references an internal pond-ts module and can't be named
+ *  (TS2742), so an explicit annotation is required. `<Candlestick>` reads the
+ *  o/h/l/c columns by runtime name, so the widening is invisible to callers. */
+export function candles(sessions, seq, stepMs) {
+    return ticks(sessions, stepMs).aggregate(seq, OHLC);
+}
+export function rangeOf(sessions) {
+    return [sessions[0].open, sessions[sessions.length - 1].close];
+}
+//# sourceMappingURL=tradingAxis.fixture.js.map