@pond-ts/charts 0.44.0 → 0.45.0

package/dist/tradingTimeScale.js

@@ -1,73 +1,39 @@
 import { scaleTime } from 'd3-scale';
+import { boundaryFormatFor, boundaryGrainFor, boundaryTicks, buildTicks, majorFormatFor, } from './tickLadder.js';
+// Grain selection lives in `tickLadder.ts` (the full hour1…year ladder plus
+// the boundary-row helpers); re-exported here so existing imports keep working.
+export { coarsenCalendar } from './tickLadder.js';
 /**
- * The local-time bucket key for `t` at grain `g` — two instants in the same
- * week / month / quarter / year share a key. Local time (not UTC) so it agrees
- * with the local `scaleTime` label formatter; the exchange's own time zone is
- * unknown to the scale (the deferred refinement), and a session open sits well
- * inside its local day, so runtime-local grouping matches the exchange day in
- * every ordinary case.
+ * The trivial gap-free {@link DiscontinuityProvider}: live time **is** wall
+ * time, and every local midnight is a "session open". Backing a plain
+ * continuous time axis with `scaleTradingTime(identityProvider())` runs it
+ * through the same logical tick ladder as a trading-calendar axis — calendar
+ * days are the day anchors, so a year of data ticks on month starts and an
+ * afternoon ticks on clock-aligned hours, instead of d3's mixed multi-scale
+ * default.
  */
-function bucketKey(t, g) {
-    if (g === 'session')
-        return t; // every open its own bucket
-    const d = new Date(t);
-    switch (g) {
-        case 'week': {
-            const dow = (d.getDay() + 6) % 7; // 0 = Monday
-            // Local midnight of this week's Monday (Date normalizes a negative date).
-            return new Date(d.getFullYear(), d.getMonth(), d.getDate() - dow).getTime();
-        }
-        case 'month':
-            return d.getFullYear() * 12 + d.getMonth();
-        case 'quarter':
-            return d.getFullYear() * 4 + Math.floor(d.getMonth() / 3);
-        case 'year':
-            return d.getFullYear();
-    }
-}
-/** The first instant of each distinct `g`-bucket in the ascending list `opens`. */
-function firstOfEachBucket(opens, g) {
-    const out = [];
-    let prev;
-    for (const t of opens) {
-        const k = bucketKey(t, g);
-        if (k !== prev) {
-            out.push(t);
-            prev = k;
-        }
-    }
-    return out;
-}
-const COARSENING_LADDER = [
-    'week',
-    'month',
-    'quarter',
-    'year',
-];
-/**
- * Thin an ascending run of **session opens** down to about `count` axis ticks by
- * **calendar grain** — the trading-terminal habit of labelling week / month /
- * year starts rather than an arbitrary every-nth session. Picks the finest grain
- * on the ladder (session → week → month → quarter → year) that yields at most
- * `count` buckets and returns the first open in each; beyond yearly it decimates
- * every-nth so the axis never crowds. Exported so the container can draw session
- * dividers at the same instants the axis labels.
- */
-export function coarsenCalendar(opens, count) {
-    if (opens.length <= count)
-        return { ticks: [...opens], granularity: 'session' };
-    for (const g of COARSENING_LADDER) {
-        const ticks = firstOfEachBucket(opens, g);
-        if (ticks.length <= count)
-            return { ticks, granularity: g };
-    }
-    // Coarser than yearly isn't a calendar grain — decimate the year starts.
-    const yearly = firstOfEachBucket(opens, 'year');
-    const step = Math.ceil(yearly.length / count);
-    return {
-        ticks: yearly.filter((_, i) => i % step === 0),
-        granularity: 'year',
+export function identityProvider() {
+    const self = {
+        clampUp: (t) => t,
+        clampDown: (t) => t,
+        distance: (from, to) => to - from,
+        offset: (v, amount) => v + amount,
+        copy: () => self,
+        boundaries: (from, to) => {
+            const out = [];
+            const d = new Date(from);
+            // First local midnight strictly after `from`; step by calendar day (not
+            // 24h) so DST transitions stay on midnight.
+            let cur = new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1);
+            while (cur.getTime() < to) {
+                if (cur.getTime() > from)
+                    out.push(cur.getTime());
+                cur = new Date(cur.getFullYear(), cur.getMonth(), cur.getDate() + 1);
+            }
+            return out;
+        },
     };
+    return self;
 }
 /**
  * Build a {@link TradingTimeScale} over the given discontinuity `provider`.
@@ -97,17 +63,35 @@ export function scaleTradingTime(provider) {
         const bounds = provider.boundaries?.(domain[0], domain[1]) ?? [];
         return [domain[0], ...bounds];
     };
+    /** Whether the provider has calendar structure to ladder on. Without a
+     *  `boundaries` method there are no anchors — the even-spacing fallback. */
+    const hasCalendar = () => provider.boundaries !== undefined;
+    /** The ladder result for this domain at `count` — the single source `ticks`,
+     *  `tickFormat`, and `tickBoundaries` all derive from, so the three agree.
+     *  Memoized on `(domain, count)`: the three callers (plus gridlines /
+     *  dividers) hit the same resolution per render, and on a wide continuous
+     *  domain re-walking every day-open is the expensive part. */
+    let laddered = null;
+    const resolved = (count) => {
+        const key = `${domain[0]}:${domain[1]}:${count}`;
+        if (laddered?.key !== key) {
+            laddered = {
+                key,
+                value: buildTicks(provider, sessionOpens(), domain[1], count),
+            };
+        }
+        return laddered.value;
+    };
     scale.ticks = (count = 10) => {
         const live = totalLive();
         if (live <= 0 || count < 1)
             return [domain[0]];
-        const opens = sessionOpens();
-        // Calendar-aware: label the session opens (each a new day), thinned to
-        // week / month / year starts by grain rather than an arbitrary every-nth
-        // session — the trading-terminal look.
-        if (opens.length > 1)
-            return coarsenCalendar(opens, count).ticks;
-        // No boundaries (a single session / no calendar): fall back to interior
+        // Calendar-aware: walk the logical ladder over the session-open anchors
+        // (hour steps inside sessions, then day / week / month / quarter / year
+        // starts) — the trading-terminal look, never an arbitrary every-nth.
+        if (hasCalendar())
+            return resolved(count).ticks;
+        // No boundaries (no calendar structure at all): fall back to interior
         // even-spaced ticks — endpoints excluded so none sits on the plot edge.
         const out = [];
         for (let i = 1; i < count; i++) {
@@ -118,20 +102,34 @@ export function scaleTradingTime(provider) {
     scale.tickFormat = (count = 10, specifier) => {
         if (specifier !== undefined)
             return base.tickFormat(count, specifier);
-        const opens = sessionOpens();
         const defFmt = base.tickFormat(count);
-        if (opens.length <= 1)
+        if (!hasCalendar())
             return defFmt; // no calendar → d3 multi-scale default
-        // Anchor label at each coarsened session-open tick: a **date** (`%b %d`), or
-        // the **year** when ticks are a year apart (a plain date would drop the year
-        // the reader needs). Any other instant — a cursor readout — uses the d3
-        // multi-scale default. Same grain as {@link ticks}, so labels and the
-        // dividers drawn at these instants agree.
-        const { ticks, granularity } = coarsenCalendar(opens, count);
+        // Anchor labels at the grain {@link ticks} chose — one uniform format per
+        // grain (hours as `%H:%M`, days/weeks as `%b %d`, months/quarters as `%b`,
+        // years as `%Y`); the coarser context the label omits is the second row
+        // ({@link tickBoundaries}). Any other instant — a cursor readout — uses
+        // the d3 multi-scale default. Same grain as {@link ticks}, so labels and
+        // the dividers drawn at these instants agree.
+        const { ticks, granularity } = resolved(count);
         const anchors = new Set(ticks);
-        const anchorFmt = base.tickFormat(count, granularity === 'year' ? '%Y' : '%b %d');
+        const anchorFmt = base.tickFormat(count, majorFormatFor(granularity));
         return (d) => (anchors.has(+d) ? anchorFmt(d) : defFmt(d));
     };
+    scale.tickBoundaries = (count = 10) => {
+        if (!hasCalendar())
+            return () => undefined;
+        const { ticks, granularity } = resolved(count);
+        const bg = boundaryGrainFor(granularity);
+        if (bg === undefined)
+            return () => undefined;
+        const fmt = base.tickFormat(count, boundaryFormatFor(bg));
+        const labelled = new Map();
+        for (const t of boundaryTicks(ticks, granularity)) {
+            labelled.set(t, fmt(new Date(t)));
+        }
+        return (value) => labelled.get(value);
+    };
     function domainFn(next) {
         if (next === undefined)
             return [domain[0], domain[1]];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pond-ts/charts",
-  "version": "0.44.0",
+  "version": "0.45.0",
   "private": false,
   "description": "Canvas-rendered, streaming-first time-series charts for pond-ts",
   "license": "MIT",
@@ -38,8 +38,8 @@
     "perf": "PERF_BENCH=1 playwright test perf.spec.ts --workers=1"
   },
   "peerDependencies": {
-    "@pond-ts/react": "^0.44.0",
-    "pond-ts": "^0.44.0",
+    "@pond-ts/react": "^0.45.0",
+    "pond-ts": "^0.45.0",
     "react": "^18.0.0 || ^19.0.0"
   },
   "devDependencies": {