graphein 0.20.0 → 0.22.0

package/dist/render/pathSample.js

@@ -0,0 +1,76 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+function cubicAt(p0, p1, p2, p3, t) {
+  const u = 1 - t;
+  return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;
+}
+function quadAt(p0, p1, p2, t) {
+  const u = 1 - t;
+  return u * u * p0 + 2 * u * t * p1 + t * t * p2;
+}
+function solve(xAt, x, increasing) {
+  let lo = 0;
+  let hi = 1;
+  for (let i = 0; i < 28; i++) {
+    const mid = (lo + hi) / 2;
+    if (xAt(mid) < x === increasing) lo = mid;
+    else hi = mid;
+  }
+  return (lo + hi) / 2;
+}
+class PathSampler {
+  constructor() {
+    __publicField(this, "segments", []);
+    __publicField(this, "x", NaN);
+    __publicField(this, "y", NaN);
+  }
+  moveTo(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+  lineTo(x, y) {
+    this.segments.push({ kind: "line", x0: this.x, y0: this.y, x1: x, y1: y });
+    this.x = x;
+    this.y = y;
+  }
+  bezierCurveTo(c1x, c1y, c2x, c2y, x, y) {
+    this.segments.push({ kind: "cubic", x0: this.x, y0: this.y, c1x, c1y, c2x, c2y, x1: x, y1: y });
+    this.x = x;
+    this.y = y;
+  }
+  quadraticCurveTo(cx, cy, x, y) {
+    this.segments.push({ kind: "quad", x0: this.x, y0: this.y, cx, cy, x1: x, y1: y });
+    this.x = x;
+    this.y = y;
+  }
+  arc() {
+  }
+  arcTo(_x1, _y1, x, y) {
+    this.lineTo(x, y);
+  }
+  closePath() {
+  }
+  /** The path's y where it crosses `x`, or undefined when no segment spans it. */
+  yAt(x) {
+    for (const s of this.segments) {
+      if (!Number.isFinite(s.x0) || x < Math.min(s.x0, s.x1) || x > Math.max(s.x0, s.x1)) continue;
+      const increasing = s.x1 >= s.x0;
+      if (s.kind === "line") {
+        const span = s.x1 - s.x0;
+        return span === 0 ? s.y1 : s.y0 + (x - s.x0) / span * (s.y1 - s.y0);
+      }
+      if (s.kind === "cubic") {
+        const t2 = solve((u) => cubicAt(s.x0, s.c1x, s.c2x, s.x1, u), x, increasing);
+        return cubicAt(s.y0, s.c1y, s.c2y, s.y1, t2);
+      }
+      const t = solve((u) => quadAt(s.x0, s.cx, s.x1, u), x, increasing);
+      return quadAt(s.y0, s.cy, s.y1, t);
+    }
+    return void 0;
+  }
+}
+export {
+  PathSampler
+};
+//# sourceMappingURL=pathSample.js.map

package/dist/render/pathSample.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/render/pathSample.ts"],
+  "sourcesContent": ["/**\n * Path sampling \u2014 evaluate a drawn path at an x position.\n *\n * Curve generators write into a {@link PathSink}; this sink records the\n * segments instead of drawing them, so animation code can find exactly where an\n * x-monotone path (a line chart's stroke under any curve interpolation) passes\n * a given x \u2014 e.g. to ride a marker along the leading edge of a draw-on reveal.\n */\n\nimport type { PathSink } from '../shape/sink';\n\ntype Segment =\n  | { kind: 'line'; x0: number; y0: number; x1: number; y1: number }\n  | { kind: 'cubic'; x0: number; y0: number; c1x: number; c1y: number; c2x: number; c2y: number; x1: number; y1: number }\n  | { kind: 'quad'; x0: number; y0: number; cx: number; cy: number; x1: number; y1: number };\n\nfunction cubicAt(p0: number, p1: number, p2: number, p3: number, t: number): number {\n  const u = 1 - t;\n  return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3;\n}\n\nfunction quadAt(p0: number, p1: number, p2: number, t: number): number {\n  const u = 1 - t;\n  return u * u * p0 + 2 * u * t * p1 + t * t * p2;\n}\n\n/** Bisect the parameter where a monotone segment's x reaches `x`. */\nfunction solve(xAt: (t: number) => number, x: number, increasing: boolean): number {\n  let lo = 0;\n  let hi = 1;\n  for (let i = 0; i < 28; i++) {\n    const mid = (lo + hi) / 2;\n    if (xAt(mid) < x === increasing) lo = mid;\n    else hi = mid;\n  }\n  return (lo + hi) / 2;\n}\n\nexport class PathSampler implements PathSink {\n  private readonly segments: Segment[] = [];\n  private x = NaN;\n  private y = NaN;\n\n  moveTo(x: number, y: number): void {\n    this.x = x;\n    this.y = y;\n  }\n\n  lineTo(x: number, y: number): void {\n    this.segments.push({ kind: 'line', x0: this.x, y0: this.y, x1: x, y1: y });\n    this.x = x;\n    this.y = y;\n  }\n\n  bezierCurveTo(c1x: number, c1y: number, c2x: number, c2y: number, x: number, y: number): void {\n    this.segments.push({ kind: 'cubic', x0: this.x, y0: this.y, c1x, c1y, c2x, c2y, x1: x, y1: y });\n    this.x = x;\n    this.y = y;\n  }\n\n  quadraticCurveTo(cx: number, cy: number, x: number, y: number): void {\n    this.segments.push({ kind: 'quad', x0: this.x, y0: this.y, cx, cy, x1: x, y1: y });\n    this.x = x;\n    this.y = y;\n  }\n\n  arc(): void {\n    // Arcs never appear in x-monotone series paths.\n  }\n\n  arcTo(_x1: number, _y1: number, x: number, y: number): void {\n    this.lineTo(x, y);\n  }\n\n  closePath(): void {\n    // Open paths only.\n  }\n\n  /** The path's y where it crosses `x`, or undefined when no segment spans it. */\n  yAt(x: number): number | undefined {\n    for (const s of this.segments) {\n      if (!Number.isFinite(s.x0) || x < Math.min(s.x0, s.x1) || x > Math.max(s.x0, s.x1)) continue;\n      const increasing = s.x1 >= s.x0;\n      if (s.kind === 'line') {\n        const span = s.x1 - s.x0;\n        return span === 0 ? s.y1 : s.y0 + ((x - s.x0) / span) * (s.y1 - s.y0);\n      }\n      if (s.kind === 'cubic') {\n        const t = solve((u) => cubicAt(s.x0, s.c1x, s.c2x, s.x1, u), x, increasing);\n        return cubicAt(s.y0, s.c1y, s.c2y, s.y1, t);\n      }\n      const t = solve((u) => quadAt(s.x0, s.cx, s.x1, u), x, increasing);\n      return quadAt(s.y0, s.cy, s.y1, t);\n    }\n    return undefined;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["t"]
+}

package/dist/render/transient.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Transient surfaces — views of a Surface for frames that must never reach the
+ * render report: update-morph tweens and hover-focus repaints. A view paints
+ * onto a chosen canvas layer, has no evidence ledger (every renderer guards it
+ * with optional chaining), and remembers the surface it belongs to so per-surface
+ * state (e.g. the slices a pie last drew) is keyed by the real owner.
+ */
+import type { CanvasLayer } from './canvasLayer.js';
+import type { Surface } from './surface.js';
+/**
+ * A view of `surface` that paints onto `layer` without touching the evidence
+ * ledger. Labels it records land in a throwaway ledger, so the report keeps
+ * describing the static frame while tween frames re-lay their labels.
+ */
+export declare function transientSurface(surface: Surface, layer?: CanvasLayer): Surface;
+/** The surface a (possibly transient) view belongs to. */
+export declare function surfaceOwner(surface: Surface): Surface;
+//# sourceMappingURL=transient.d.ts.map

package/dist/render/transient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transient.d.ts","sourceRoot":"","sources":["../../src/render/transient.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIzC;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,GAAE,WAA2B,GAAG,OAAO,CAQ9F;AAED,0DAA0D;AAC1D,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAEtD"}

package/dist/render/transient.js

@@ -0,0 +1,19 @@
+import { LabelLedger } from "./labelLedger.js";
+const OWNERS = /* @__PURE__ */ new WeakMap();
+function transientSurface(surface, layer = surface.marks) {
+  const view = Object.create(surface, {
+    marks: { value: layer, enumerable: true },
+    evidence: { value: void 0, enumerable: true },
+    labels: { value: new LabelLedger(), enumerable: true }
+  });
+  OWNERS.set(view, surfaceOwner(surface));
+  return view;
+}
+function surfaceOwner(surface) {
+  return OWNERS.get(surface) ?? surface;
+}
+export {
+  surfaceOwner,
+  transientSurface
+};
+//# sourceMappingURL=transient.js.map

package/dist/render/transient.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/render/transient.ts"],
+  "sourcesContent": ["/**\n * Transient surfaces \u2014 views of a Surface for frames that must never reach the\n * render report: update-morph tweens and hover-focus repaints. A view paints\n * onto a chosen canvas layer, has no evidence ledger (every renderer guards it\n * with optional chaining), and remembers the surface it belongs to so per-surface\n * state (e.g. the slices a pie last drew) is keyed by the real owner.\n */\n\nimport type { CanvasLayer } from './canvasLayer';\nimport { LabelLedger } from './labelLedger';\nimport type { Surface } from './surface';\n\nconst OWNERS = new WeakMap<object, Surface>();\n\n/**\n * A view of `surface` that paints onto `layer` without touching the evidence\n * ledger. Labels it records land in a throwaway ledger, so the report keeps\n * describing the static frame while tween frames re-lay their labels.\n */\nexport function transientSurface(surface: Surface, layer: CanvasLayer = surface.marks): Surface {\n  const view = Object.create(surface, {\n    marks: { value: layer, enumerable: true },\n    evidence: { value: undefined, enumerable: true },\n    labels: { value: new LabelLedger(), enumerable: true },\n  }) as Surface;\n  OWNERS.set(view, surfaceOwner(surface));\n  return view;\n}\n\n/** The surface a (possibly transient) view belongs to. */\nexport function surfaceOwner(surface: Surface): Surface {\n  return OWNERS.get(surface) ?? surface;\n}\n"],
+  "mappings": "AASA,SAAS,mBAAmB;AAG5B,MAAM,SAAS,oBAAI,QAAyB;AAOrC,SAAS,iBAAiB,SAAkB,QAAqB,QAAQ,OAAgB;AAC9F,QAAM,OAAO,OAAO,OAAO,SAAS;AAAA,IAClC,OAAO,EAAE,OAAO,OAAO,YAAY,KAAK;AAAA,IACxC,UAAU,EAAE,OAAO,QAAW,YAAY,KAAK;AAAA,IAC/C,QAAQ,EAAE,OAAO,IAAI,YAAY,GAAG,YAAY,KAAK;AAAA,EACvD,CAAC;AACD,SAAO,IAAI,MAAM,aAAa,OAAO,CAAC;AACtC,SAAO;AACT;AAGO,SAAS,aAAa,SAA2B;AACtD,SAAO,OAAO,IAAI,OAAO,KAAK;AAChC;",
+  "names": []
+}

package/dist/runtime/candlestick.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Candlestick model builder.
+ *
+ * A `candlestick` reads tidy rows of `{ x, open, high, low, close }` and draws one
+ * candle per row: a wick spanning the period's true extremes and a body from the
+ * open to the close, colored by whether the period closed up or down. Like the
+ * waterfall / histogram builders, it resolves a synthetic `base`
+ * {@link CartesianModel} so the shared axis chrome (`drawAxesUnderlay` /
+ * `drawOverlay`) and annotations render the period axis, price gridlines and
+ * titles unchanged — the candles themselves are painted by `drawCandlestick`.
+ *
+ * The period axis follows the x field type: temporal → a time axis (calendar
+ * gaps such as weekends stay visible), quantitative → a linear axis, and
+ * ordinal / nominal → an evenly spaced index axis (one slot per row, so a
+ * trading-day series reads without gaps). Rows with a missing period or any
+ * non-finite price are not drawn and are counted as unrepresented; nothing is
+ * invented. Inconsistent ranges (a high below the open, say) are drawn to their
+ * true extremes rather than silently corrected.
+ */
+import type { Datum, Rect } from '../types.js';
+import type { ThemeTokens } from '../theme/index.js';
+import type { CandlestickSpec } from '../spec/types.js';
+import { type ContinuousScale } from '../scales/index.js';
+import { type Frame } from '../layout/index.js';
+import { type ResolvedSketch } from '../spec/sketch.js';
+import type { BuildOptions, CartesianModel } from './cartesian.js';
+/** Widest a candle body may grow, however few periods share the plot. */
+export declare const MAX_BODY_WIDTH = 22;
+/** How the period axis is laid out. */
+export type CandleAxisKind = 'time' | 'linear' | 'band';
+export type CandleStyle = 'candle' | 'ohlc';
+/** One drawable period. Prices are the raw row values; geometry is snapped pixels. */
+export interface Candle {
+    /** Period identity for keyed updates (epoch ms on a time axis, the raw key otherwise). */
+    key: string;
+    /** The raw period value, published by selections. */
+    x: unknown;
+    /** Formatted period (tooltip title). */
+    label: string;
+    open: number;
+    high: number;
+    low: number;
+    close: number;
+    /** True extremes of all four prices, so an inconsistent row still spans every value. */
+    lo: number;
+    hi: number;
+    /** Closed at or above its open. */
+    up: boolean;
+    color: string;
+    /** Index of the source row in `spec.data`. */
+    sourceIndex: number;
+    row: Datum;
+    /** Pixel center of the candle (snapped so a 1px wick lands on a whole pixel). */
+    cx: number;
+    /** Body width in px (the tick span for OHLC bars). */
+    width: number;
+    /** Wick / OHLC stroke width in px. */
+    stroke: number;
+    /** Pixel y of the high (top) and low (bottom) extremes. */
+    top: number;
+    bottom: number;
+    /** Pixel y of the open and close. */
+    openY: number;
+    closeY: number;
+}
+export interface CandlestickModel {
+    spec: CandlestickSpec;
+    tokens: ThemeTokens;
+    frame: Frame;
+    plot: Rect;
+    /** Drawable candles in data order. */
+    candles: Candle[];
+    /** Source rows that could not be drawn (missing period or a non-finite price). */
+    unrepresented: number;
+    axis: CandleAxisKind;
+    style: CandleStyle;
+    increaseColor: string;
+    decreaseColor: string;
+    /** Price format for tooltips (the spec's `format`, else inferred from the data's decimals). */
+    priceFormat?: string;
+    /** Snapped body width shared by every candle. */
+    bodyWidth: number;
+    /** Wick / OHLC stroke width shared by every candle. */
+    strokeWidth: number;
+    yScale: ContinuousScale;
+    /** Period-axis ticks skipped so the remaining labels read cleanly (index axis only). */
+    thinnedTicks: number;
+    /** Synthetic cartesian model that drives the axis chrome and annotations. */
+    base: CartesianModel;
+    sketch: ResolvedSketch | null;
+}
+/**
+ * Price-axis labels with consistent decimals (100.0 / 100.5, as price axes read),
+ * SI suffixes for very large prices, and a precise fallback whenever rounding
+ * would print two different ticks the same.
+ */
+export declare function priceTickLabels(values: readonly number[], format?: string): string[];
+/**
+ * Snapped body and wick widths from the pixels one body may occupy: at least
+ * 1px, at most {@link MAX_BODY_WIDTH}, and with the wick's parity so the body
+ * sits exactly centered on it.
+ */
+export declare function candleWidths(room: number): {
+    width: number;
+    stroke: number;
+};
+/**
+ * Build a {@link CandlestickModel} from a {@link CandlestickSpec}. Pure: depends
+ * only on the spec, theme tokens, and target size.
+ */
+export declare function buildCandlestickModel(spec: CandlestickSpec, tokens: ThemeTokens, opts: BuildOptions): CandlestickModel;
+//# sourceMappingURL=candlestick.d.ts.map

package/dist/runtime/candlestick.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candlestick.d.ts","sourceRoot":"","sources":["../../src/runtime/candlestick.ts"],"names":[],"mappings":"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"}