@pibbl/core 0.0.2 → 0.0.3-alpha.90.1

package/dist/features/viz/lib/censored-point-series.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/censored-point-series.tsx"],
+  "sourcesContent": ["import { Path, resolveSignalValue } from \"@pibbl/core\";\nimport type {\n  FillStyle,\n  PibblEventHandlers,\n  PibblEventParticipationOptions,\n  SignalValue,\n  StrokeStyle,\n} from \"@pibbl/core\";\nimport type { SignalStyle } from \"@pibbl/core/internal\";\nimport { validateTexturePaint, withHooksForbidden } from \"@pibbl/core/internal\";\nimport type { LineAccessor, ScaleId } from \"./types.js\";\nimport { finiteCoordinate, pointAccessor, pointData } from \"./point-data.js\";\nimport { opacity, width } from \"./paint.js\";\nimport { useContinuousScale } from \"./use-continuous-scale.js\";\n\n/** A supplied assay reporting status. `below` and `above` retain the supplied reporting limit.\n * @see {@link CensoredPointSeriesProps}\n */\nexport type CensoringStatus = \"observed\" | \"below\" | \"above\";\n\n/** Extracts an observation's supplied reporting status.\n * @param datum - Original record being read.\n * @param index - Zero-based source index.\n * @param data - Complete supplied record array.\n * @returns The supplied status, or a nullish sentinel that omits the record.\n * @see {@link CensoringStatus}\n */\nexport type CensoringAccessor<D> =\n  | {\n      [K in keyof D]-?: D[K] extends CensoringStatus | null | undefined\n        ? K\n        : never;\n    }[keyof D]\n  | ((\n      datum: D,\n      index: number,\n      data: readonly D[],\n    ) => CensoringStatus | null | undefined);\n\n/** Shared mark paint and local-pixel geometry for {@link CensoredPointSeries}. */\nexport interface CensoredPointSeriesStyle {\n  /** Circle and open censor marker radius in local pixels; defaults to 4. */\n  readonly radius?: number;\n  /** Fill for observed circles; defaults to #087f8c. Censor markers remain open. */\n  readonly fill?: FillStyle;\n  /** Outline for circles and open directional censor markers; defaults to #087f8c. */\n  readonly stroke?: StrokeStyle;\n  /** Outline width in local pixels; defaults to 1.5. */\n  readonly strokeWidth?: number;\n  /** Shared paint opacity from zero to one; defaults to 1. */\n  readonly opacity?: number;\n  /** Cursor for painted mark targets. */\n  readonly cursor?: string;\n}\n\n/** Authored inputs for supplied observed and censored numeric observations.\n * @see {@link CensoredPointSeries}\n */\nexport interface CensoredPointSeriesProps<D>\n  extends PibblEventHandlers, PibblEventParticipationOptions {\n  /** Original records, or a signal of records. The series performs no imputation or inference. */\n  readonly data: SignalValue<readonly D[]>;\n  /** Property or callback supplying the numeric horizontal coordinate. */\n  readonly x: LineAccessor<D>;\n  /** Property or callback supplying the numeric vertical value or reporting limit. */\n  readonly y: LineAccessor<D>;\n  /** Property or callback yielding `observed`, `below`, or `above`. */\n  readonly censoring: CensoringAccessor<D>;\n  /** Ancestor continuous numeric scale mapping x. */\n  readonly xScale: ScaleId;\n  /** Ancestor continuous numeric scale mapping y and its reporting limit. */\n  readonly yScale: ScaleId;\n  /** Optional synchronous predicate; excluded rows contribute no mark.\n   * @param datum - Original record being tested.\n   * @param index - Zero-based source index.\n   * @param data - Complete supplied record array.\n   * @returns Whether this record contributes a mark.\n   */\n  readonly defined?: (datum: D, index: number, data: readonly D[]) => boolean;\n  /** Shared style; whole-object and shallow field signals are observed by the series. */\n  readonly style?: SignalValue<SignalStyle<CensoredPointSeriesStyle>>;\n}\n\nconst fields = [\"radius\", \"fill\", \"stroke\", \"strokeWidth\", \"opacity\", \"cursor\"];\n\nfunction paint(\n  value: unknown,\n  name: string,\n): FillStyle | StrokeStyle | undefined {\n  if (\n    value === undefined ||\n    typeof value === \"string\" ||\n    value instanceof CanvasGradient ||\n    value instanceof CanvasPattern\n  )\n    return value;\n  try {\n    validateTexturePaint(value as never);\n    return value as FillStyle | StrokeStyle;\n  } catch {\n    // Fall through to the local series error rather than leaking protocol detail.\n  }\n  throw new TypeError(`CensoredPointSeries: invalid ${name}.`);\n}\n\nfunction triangle(\n  path: Path2D,\n  x: number,\n  y: number,\n  radius: number,\n  direction: number,\n) {\n  path.moveTo(x, y + direction * radius);\n  path.lineTo(x - radius * 0.78, y - direction * radius * 0.55);\n  path.lineTo(x + radius * 0.78, y - direction * radius * 0.55);\n  path.closePath();\n}\n\n/**\n * Draws supplied numeric observations as circles and below/above reporting limits as open arrows.\n *\n * `below` points toward decreasing y-domain values and `above` toward increasing y-domain values,\n * including when the y scale uses a reversed domain or range. The supplied `y` value remains the\n * reporting limit; this component never substitutes a measurement, imputes a value, or fits a model.\n *\n * @param props - Supplied observations, coordinates, reporting statuses, scales, and paint.\n * See {@link CensoredPointSeriesProps}.\n * @returns Two ordinary batched paths for observed and open censored marks.\n * @see {@link CensoredPointSeriesProps}\n */\nexport function CensoredPointSeries<D>({\n  data: input,\n  x: xInput,\n  y: yInput,\n  censoring: censoringInput,\n  xScale: xId,\n  yScale: yId,\n  defined,\n  style: styleInput,\n  pointerEvents,\n  ...events\n}: CensoredPointSeriesProps<D>) {\n  const xScale = useContinuousScale(xId).get();\n  const yScale = useContinuousScale(yId).get();\n  const data = pointData(resolveSignalValue(input), \"CensoredPointSeries\");\n  const x = pointAccessor(xInput),\n    y = pointAccessor(yInput);\n  const censoring =\n    typeof censoringInput === \"function\"\n      ? censoringInput\n      : (datum: D) =>\n          datum[censoringInput] as CensoringStatus | null | undefined;\n  const specified = resolveSignalValue(styleInput) ?? {};\n  if (\n    specified === null ||\n    typeof specified !== \"object\" ||\n    Array.isArray(specified)\n  )\n    throw new TypeError(\"CensoredPointSeries: style must be an object.\");\n  const style: Record<string, unknown> = {};\n  for (const key of Object.keys(specified)) {\n    if (!fields.includes(key))\n      throw new TypeError(\n        `CensoredPointSeries: unsupported style field ${key}.`,\n      );\n    style[key] = resolveSignalValue(\n      (specified as Record<string, unknown>)[key],\n    );\n  }\n  const resolved = style as CensoredPointSeriesStyle;\n  const radius = width(resolved.radius ?? 4, \"CensoredPointSeries radius\");\n  const strokeWidth = width(resolved.strokeWidth ?? 1.5, \"CensoredPointSeries\");\n  const alpha = opacity(resolved.opacity ?? 1, \"CensoredPointSeries\");\n  if (resolved.cursor !== undefined && typeof resolved.cursor !== \"string\")\n    throw new TypeError(\"CensoredPointSeries: cursor must be a string.\");\n  const fill = paint(resolved.fill ?? \"#087f8c\", \"fill\");\n  const stroke = paint(resolved.stroke ?? \"#087f8c\", \"stroke\");\n  const observed = new Path2D();\n  const censored = new Path2D();\n  // The sign is a property of the domain-to-range mapping, rather than canvas orientation.\n  const increasingY = Math.sign(\n    (yScale.domain[1] - yScale.domain[0]) * (yScale.range[1] - yScale.range[0]),\n  );\n  for (let i = 0; i < data.length; i++) {\n    const datum = data[i];\n    const coordinates = withHooksForbidden(\n      \"CensoredPointSeries: accessors cannot call hooks.\",\n      () => {\n        if (defined && !defined(datum, i, data)) return undefined;\n        return {\n          x: x(datum, i, data),\n          y: y(datum, i, data),\n          censoring: censoring(datum, i, data),\n        };\n      },\n    );\n    if (\n      !coordinates ||\n      !finiteCoordinate(coordinates.x) ||\n      !finiteCoordinate(coordinates.y) ||\n      coordinates.censoring == null\n    )\n      continue;\n    if (\n      !([\"observed\", \"below\", \"above\"] as const).includes(coordinates.censoring)\n    )\n      throw new TypeError(\n        `CensoredPointSeries: unknown censoring status ${String(coordinates.censoring)} (row ${i}).`,\n      );\n    const px = xScale.map(coordinates.x),\n      py = yScale.map(coordinates.y);\n    if (!Number.isFinite(px) || !Number.isFinite(py))\n      throw new RangeError(\n        `CensoredPointSeries: mapped coordinates must be finite (row ${i}).`,\n      );\n    if (radius === 0) continue;\n    if (coordinates.censoring === \"observed\") {\n      observed.moveTo(px + radius, py);\n      observed.arc(px, py, radius, 0, Math.PI * 2);\n      observed.closePath();\n    } else {\n      const direction =\n        coordinates.censoring === \"above\" ? increasingY : -increasingY;\n      triangle(censored, px, py, radius, direction || 1);\n    }\n  }\n  const common = {\n    stroke,\n    strokeWidth,\n    opacity: alpha,\n    cursor: resolved.cursor,\n  };\n  return (\n    <>\n      <Path\n        {...events}\n        pointerEvents={pointerEvents}\n        style={{ d: observed, fill, ...common }}\n      />\n      <Path\n        {...events}\n        pointerEvents={pointerEvents}\n        style={{ d: censored, fill: \"transparent\", ...common }}\n      />\n    </>\n  );\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/color-context.d.ts

@@ -0,0 +1,4 @@
+import { type Signal } from "@pibbl/core";
+import type { ScaleId } from "./types.js";
+export declare function provideColor<T>(id: ScaleId, kind: string, resolve: () => T, deps: readonly unknown[]): void;
+export declare function useColor<T>(id: ScaleId, kind: string): Signal<T>;

package/dist/features/viz/lib/color-context.js

@@ -0,0 +1,41 @@
+import { useComputed } from "@pibbl/core";
+import {
+  getCurrentBackendHostCanvas,
+  setCurrentComponentAfterRender,
+  useInternalHookSlot
+} from "@pibbl/core/internal";
+let current;
+function provideColor(id, kind, resolve, deps) {
+  if ((typeof id !== "string" || id.length === 0) && typeof id !== "symbol")
+    throw new TypeError("Color scale id requires a nonempty string or symbol.");
+  const value = useComputed(resolve, deps), parent = current;
+  current = { id, kind, value, canvas: getCurrentBackendHostCanvas(), parent };
+  const restore = () => {
+    current = parent;
+  };
+  try {
+    setCurrentComponentAfterRender(restore);
+  } catch (error) {
+    restore();
+    throw error;
+  }
+}
+function useColor(id, kind) {
+  useInternalHookSlot("vizColorScaleLookup", () => void 0);
+  for (let scope = current; scope; scope = scope.parent) {
+    if (scope.id !== id) continue;
+    if (scope.canvas !== getCurrentBackendHostCanvas())
+      throw new Error("Color scale cannot cross a Layer boundary.");
+    if (scope.kind !== kind)
+      throw new TypeError(`Expected ${kind} color scale; found ${scope.kind}.`);
+    return scope.value;
+  }
+  throw new Error(
+    `Unknown color scale ${String(id)}; add the matching ancestor provider.`
+  );
+}
+export {
+  provideColor,
+  useColor
+};
+//# sourceMappingURL=color-context.js.map

package/dist/features/viz/lib/color-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/color-context.ts"],
+  "sourcesContent": ["import { useComputed, type Signal } from \"@pibbl/core\";\nimport {\n  getCurrentBackendHostCanvas,\n  setCurrentComponentAfterRender,\n  useInternalHookSlot,\n} from \"@pibbl/core/internal\";\nimport type { ScaleId } from \"./types.js\";\ninterface Scope {\n  id: ScaleId;\n  kind: string;\n  value: Signal<unknown>;\n  canvas: ReturnType<typeof getCurrentBackendHostCanvas>;\n  parent: Scope | undefined;\n}\nlet current: Scope | undefined;\nexport function provideColor<T>(\n  id: ScaleId,\n  kind: string,\n  resolve: () => T,\n  deps: readonly unknown[],\n): void {\n  if ((typeof id !== \"string\" || id.length === 0) && typeof id !== \"symbol\")\n    throw new TypeError(\"Color scale id requires a nonempty string or symbol.\");\n  const value = useComputed(resolve, deps),\n    parent = current;\n  current = { id, kind, value, canvas: getCurrentBackendHostCanvas(), parent };\n  const restore = () => {\n    current = parent;\n  };\n  try {\n    setCurrentComponentAfterRender(restore);\n  } catch (error) {\n    restore();\n    throw error;\n  }\n}\nexport function useColor<T>(id: ScaleId, kind: string): Signal<T> {\n  useInternalHookSlot(\"vizColorScaleLookup\", () => undefined);\n  for (let scope = current; scope; scope = scope.parent) {\n    if (scope.id !== id) continue;\n    if (scope.canvas !== getCurrentBackendHostCanvas())\n      throw new Error(\"Color scale cannot cross a Layer boundary.\");\n    if (scope.kind !== kind)\n      throw new TypeError(`Expected ${kind} color scale; found ${scope.kind}.`);\n    return scope.value as Signal<T>;\n  }\n  throw new Error(\n    `Unknown color scale ${String(id)}; add the matching ancestor provider.`,\n  );\n}\n"],
+  "mappings": "AAAA,SAAS,mBAAgC;AACzC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AASP,IAAI;AACG,SAAS,aACd,IACA,MACA,SACA,MACM;AACN,OAAK,OAAO,OAAO,YAAY,GAAG,WAAW,MAAM,OAAO,OAAO;AAC/D,UAAM,IAAI,UAAU,sDAAsD;AAC5E,QAAM,QAAQ,YAAY,SAAS,IAAI,GACrC,SAAS;AACX,YAAU,EAAE,IAAI,MAAM,OAAO,QAAQ,4BAA4B,GAAG,OAAO;AAC3E,QAAM,UAAU,MAAM;AACpB,cAAU;AAAA,EACZ;AACA,MAAI;AACF,mCAA+B,OAAO;AAAA,EACxC,SAAS,OAAO;AACd,YAAQ;AACR,UAAM;AAAA,EACR;AACF;AACO,SAAS,SAAY,IAAa,MAAyB;AAChE,sBAAoB,uBAAuB,MAAM,MAAS;AAC1D,WAAS,QAAQ,SAAS,OAAO,QAAQ,MAAM,QAAQ;AACrD,QAAI,MAAM,OAAO,GAAI;AACrB,QAAI,MAAM,WAAW,4BAA4B;AAC/C,YAAM,IAAI,MAAM,4CAA4C;AAC9D,QAAI,MAAM,SAAS;AACjB,YAAM,IAAI,UAAU,YAAY,IAAI,uBAAuB,MAAM,IAAI,GAAG;AAC1E,WAAO,MAAM;AAAA,EACf;AACA,QAAM,IAAI;AAAA,IACR,uBAAuB,OAAO,EAAE,CAAC;AAAA,EACnC;AACF;",
+  "names": []
+}

package/dist/features/viz/lib/color-math.d.ts

@@ -0,0 +1,4 @@
+export declare function finiteColorValue(value: number): number;
+export declare function hexColor(color: string): string;
+export declare function colorMix(a: string, b: string, t: number): string;
+export declare function colorPosition(value: number, a: number, b: number): number;

package/dist/features/viz/lib/color-math.js

@@ -0,0 +1,31 @@
+function finiteColorValue(value) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new RangeError("Color scale values must be finite numbers.");
+  return value;
+}
+function hexColor(color) {
+  if (typeof color !== "string" || !/^#[0-9a-f]{6}$/i.test(color))
+    throw new TypeError("Color scales require #RRGGBB colors.");
+  return color.toLowerCase();
+}
+function colorMix(a, b, t) {
+  return "#" + [1, 3, 5].map(
+    (i) => Math.round(
+      parseInt(a.slice(i, i + 2), 16) * (1 - t) + parseInt(b.slice(i, i + 2), 16) * t
+    ).toString(16).padStart(2, "0")
+  ).join("");
+}
+function colorPosition(value, a, b) {
+  if (a === b) return 0.5;
+  if (a < b && value <= a || a > b && value >= a) return 0;
+  if (a < b && value >= b || a > b && value <= b) return 1;
+  const span = b - a;
+  return Number.isFinite(span) ? (value - a) / span : (value / 2 - a / 2) / (b / 2 - a / 2);
+}
+export {
+  colorMix,
+  colorPosition,
+  finiteColorValue,
+  hexColor
+};
+//# sourceMappingURL=color-math.js.map

package/dist/features/viz/lib/color-math.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/color-math.ts"],
+  "sourcesContent": ["export function finiteColorValue(value: number): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(\"Color scale values must be finite numbers.\");\n  return value;\n}\nexport function hexColor(color: string): string {\n  if (typeof color !== \"string\" || !/^#[0-9a-f]{6}$/i.test(color))\n    throw new TypeError(\"Color scales require #RRGGBB colors.\");\n  return color.toLowerCase();\n}\nexport function colorMix(a: string, b: string, t: number): string {\n  return (\n    \"#\" +\n    [1, 3, 5]\n      .map((i) =>\n        Math.round(\n          parseInt(a.slice(i, i + 2), 16) * (1 - t) +\n            parseInt(b.slice(i, i + 2), 16) * t,\n        )\n          .toString(16)\n          .padStart(2, \"0\"),\n      )\n      .join(\"\")\n  );\n}\nexport function colorPosition(value: number, a: number, b: number): number {\n  if (a === b) return 0.5;\n  if ((a < b && value <= a) || (a > b && value >= a)) return 0;\n  if ((a < b && value >= b) || (a > b && value <= b)) return 1;\n  const span = b - a;\n  return Number.isFinite(span)\n    ? (value - a) / span\n    : (value / 2 - a / 2) / (b / 2 - a / 2);\n}\n"],
+  "mappings": "AAAO,SAAS,iBAAiB,OAAuB;AACtD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK;AACrD,UAAM,IAAI,WAAW,4CAA4C;AACnE,SAAO;AACT;AACO,SAAS,SAAS,OAAuB;AAC9C,MAAI,OAAO,UAAU,YAAY,CAAC,kBAAkB,KAAK,KAAK;AAC5D,UAAM,IAAI,UAAU,sCAAsC;AAC5D,SAAO,MAAM,YAAY;AAC3B;AACO,SAAS,SAAS,GAAW,GAAW,GAAmB;AAChE,SACE,MACA,CAAC,GAAG,GAAG,CAAC,EACL;AAAA,IAAI,CAAC,MACJ,KAAK;AAAA,MACH,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,KAAK,IAAI,KACrC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,EAAE,IAAI;AAAA,IACtC,EACG,SAAS,EAAE,EACX,SAAS,GAAG,GAAG;AAAA,EACpB,EACC,KAAK,EAAE;AAEd;AACO,SAAS,cAAc,OAAe,GAAW,GAAmB;AACzE,MAAI,MAAM,EAAG,QAAO;AACpB,MAAK,IAAI,KAAK,SAAS,KAAO,IAAI,KAAK,SAAS,EAAI,QAAO;AAC3D,MAAK,IAAI,KAAK,SAAS,KAAO,IAAI,KAAK,SAAS,EAAI,QAAO;AAC3D,QAAM,OAAO,IAAI;AACjB,SAAO,OAAO,SAAS,IAAI,KACtB,QAAQ,KAAK,QACb,QAAQ,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI;AACzC;",
+  "names": []
+}

package/dist/features/viz/lib/color-types.d.ts

@@ -0,0 +1,53 @@
+import type { PibblNode, SignalValue } from "@pibbl/core";
+import type { ScaleId } from "./types.js";
+/** One authored domain/color association. @see {@link ResolvedSequentialColorScale} */
+export interface ColorScaleStop {
+    /** Numeric data value at the color stop. */ readonly value: number;
+    /** Canonical lowercase six-digit hexadecimal sRGB color. */ readonly color: string;
+}
+/** Readonly continuous two-stop color mapping. @see {@link SequentialColorScaleProps} */
+export interface ResolvedSequentialColorScale {
+    /** Authored finite endpoints, preserving ascending or descending order. */ readonly domain: readonly [
+        number,
+        number
+    ];
+    /** Canonical endpoint colors, in authored order. */ readonly colors: readonly [
+        string,
+        string
+    ];
+    /** Frozen endpoint/value pairs for scale-derived annotations. */ readonly stops: readonly ColorScaleStop[];
+    /** Maps finite data to a clamped color.
+     * @param value - Numeric input.
+     * @returns Canonical #rrggbb color. */ map(value: number): string;
+}
+/** Readonly continuous mapping with an explicit center. @see {@link DivergingColorScaleProps} */
+export interface ResolvedDivergingColorScale {
+    /** Strictly monotonic finite endpoints and center, in authored order. */ readonly domain: readonly [
+        number,
+        number,
+        number
+    ];
+    /** Canonical endpoint and center colors. */ readonly colors: readonly [
+        string,
+        string,
+        string
+    ];
+    /** Frozen endpoint/center pairs for scale-derived annotations. */ readonly stops: readonly ColorScaleStop[];
+    /** Maps finite data through the authored center.
+     * @param value - Numeric input.
+     * @returns Canonical #rrggbb color. */ map(value: number): string;
+}
+/** Inputs for a dedicated sequential color provider. @see {@link ResolvedSequentialColorScale} */
+export interface SequentialColorScaleProps {
+    /** Identity in the color-scale namespace. See {@link ScaleId}. */ readonly id: ScaleId;
+    /** Finite endpoints; equal endpoints map all finite inputs to the color midpoint. */ readonly domain: SignalValue<readonly [number, number]>;
+    /** Required #RRGGBB endpoint colors. No default palette is chosen. */ readonly colors: SignalValue<readonly [string, string]>;
+    /** Descendants consuming the mapping. See {@link PibblNode}. */ readonly children?: PibblNode;
+}
+/** Inputs for a dedicated diverging color provider. @see {@link ResolvedDivergingColorScale} */
+export interface DivergingColorScaleProps {
+    /** Identity in the color-scale namespace. See {@link ScaleId}. */ readonly id: ScaleId;
+    /** Strictly increasing or decreasing finite endpoints and center. */ readonly domain: SignalValue<readonly [number, number, number]>;
+    /** Required #RRGGBB endpoint and center colors. */ readonly colors: SignalValue<readonly [string, string, string]>;
+    /** Descendants consuming the mapping. See {@link PibblNode}. */ readonly children?: PibblNode;
+}

package/dist/features/viz/lib/curve-definition.d.ts

@@ -0,0 +1,49 @@
+import type { LineSeriesProps } from "./types.js";
+/** A mapped Cartesian coordinate used by private series curve rendering. */
+export type SeriesCurvePoint = readonly [number, number];
+/**
+ * A private generated segment. Cubic controls reserve the representation needed by a later
+ * smooth-curve implementation; current step definitions generate straight segments only.
+ */
+export interface SeriesCurveSegment {
+    /** Endpoint of this segment. */
+    readonly end: SeriesCurvePoint;
+    /** First cubic Bézier control point when the segment is cubic. */
+    readonly control1?: SeriesCurvePoint;
+    /** Second cubic Bézier control point when the segment is cubic. */
+    readonly control2?: SeriesCurvePoint;
+}
+/** A private immutable path beginning at one point and continuing through generated segments. */
+export interface SeriesCurveGeometry {
+    /** Initial coordinate for the geometry. */
+    readonly start: SeriesCurvePoint;
+    /** Ordered segments after {@link SeriesCurveGeometry.start}. */
+    readonly segments: readonly SeriesCurveSegment[];
+}
+declare const seriesCurveBrand: unique symbol;
+/**
+ * An opaque immutable definition controlling how a series connects adjacent observations.
+ *
+ * Obtain a definition from one of the named curve factories. Definitions intentionally expose
+ * no algorithm selector or custom callback surface.
+ *
+ * @see {@link LineSeriesProps}
+ */
+export interface SeriesCurve {
+    /** Nominal marker that prevents callers from forging a recognized definition. */
+    readonly [seriesCurveBrand]: true;
+}
+type SeriesCurveBuilder = (points: readonly SeriesCurvePoint[]) => readonly SeriesCurveSegment[];
+/** @internal Creates one module-recognized immutable curve definition. */
+export declare function createSeriesCurve(builder: SeriesCurveBuilder): SeriesCurve;
+/** @internal Rejects values that were not created by a named curve factory. */
+export declare function resolveSeriesCurve(value: unknown): SeriesCurve | undefined;
+/** @internal Builds the curve geometry for one already-valid contiguous run. */
+export declare function curveGeometry(curve: SeriesCurve | undefined, points: readonly SeriesCurvePoint[]): SeriesCurveGeometry;
+/** @internal Appends one generated geometry in its authored forward direction. */
+export declare function appendCurveForward(path: Path2D, geometry: SeriesCurveGeometry): void;
+/** @internal Appends one generated geometry in reverse without rebuilding its curve strategy. */
+export declare function appendCurveReverse(path: Path2D, geometry: SeriesCurveGeometry): void;
+/** @internal Rejects interval-band cubics whose paired boundaries cross between observations. */
+export declare function validatePairedCurveGeometry(upper: SeriesCurveGeometry, lower: SeriesCurveGeometry): void;
+export {};

package/dist/features/viz/lib/curve-definition.js

@@ -0,0 +1,148 @@
+const builders = /* @__PURE__ */ new WeakMap();
+function createSeriesCurve(builder) {
+  const definition = Object.freeze({});
+  builders.set(definition, builder);
+  return definition;
+}
+function resolveSeriesCurve(value) {
+  if (value === void 0 || value === "linear") return void 0;
+  if (typeof value !== "object" || value === null || !builders.has(value))
+    throw new TypeError(
+      'Series curve must be "linear" or a definition from a named factory.'
+    );
+  return value;
+}
+function curveGeometry(curve, points) {
+  const start = points[0];
+  return Object.freeze({
+    start,
+    segments: Object.freeze(
+      curve ? [...builders.get(curve)(points)] : points.slice(1).map((end) => Object.freeze({ end }))
+    )
+  });
+}
+function appendCurveForward(path, geometry) {
+  for (const segment of geometry.segments) {
+    if (segment.control1 && segment.control2)
+      path.bezierCurveTo(
+        segment.control1[0],
+        segment.control1[1],
+        segment.control2[0],
+        segment.control2[1],
+        segment.end[0],
+        segment.end[1]
+      );
+    else path.lineTo(segment.end[0], segment.end[1]);
+  }
+}
+function appendCurveReverse(path, geometry) {
+  const ends = geometry.segments.map((segment) => segment.end);
+  path.lineTo(
+    (ends.at(-1) ?? geometry.start)[0],
+    (ends.at(-1) ?? geometry.start)[1]
+  );
+  for (let i = geometry.segments.length - 1; i >= 0; i--) {
+    const segment = geometry.segments[i];
+    const start = i === 0 ? geometry.start : geometry.segments[i - 1].end;
+    if (segment.control1 && segment.control2)
+      path.bezierCurveTo(
+        segment.control2[0],
+        segment.control2[1],
+        segment.control1[0],
+        segment.control1[1],
+        start[0],
+        start[1]
+      );
+    else path.lineTo(start[0], start[1]);
+  }
+}
+function cubicValue(values, t) {
+  const [p0, p1, p2, p3] = values;
+  const inverse = 1 - t;
+  return inverse ** 3 * p0 + 3 * inverse ** 2 * t * p1 + 3 * inverse * t ** 2 * p2 + t ** 3 * p3;
+}
+function derivativeRoots(values) {
+  const [p0, p1, p2, p3] = values;
+  const a = -p0 + 3 * p1 - 3 * p2 + p3;
+  const b = 3 * p0 - 6 * p1 + 3 * p2;
+  const c = -3 * p0 + 3 * p1;
+  if (a === 0) {
+    if (b === 0) return [];
+    return [-c / (2 * b)];
+  }
+  const discriminant = 4 * b * b - 12 * a * c;
+  if (discriminant < 0) return [];
+  const root = Math.sqrt(discriminant);
+  const q = -b - (b >= 0 ? root / 2 : -root / 2);
+  return q === 0 ? [-b / (3 * a)] : [q / (3 * a), c / q];
+}
+function cubicY(start, segment) {
+  const end = segment.end;
+  const control1 = segment.control1 ?? [
+    start[0] + (end[0] - start[0]) / 3,
+    start[1] + (end[1] - start[1]) / 3
+  ];
+  const control2 = segment.control2 ?? [
+    start[0] + (end[0] - start[0]) * 2 / 3,
+    start[1] + (end[1] - start[1]) * 2 / 3
+  ];
+  return [start[1], control1[1], control2[1], end[1]];
+}
+function validatePairedCurveGeometry(upper, lower) {
+  if (upper.segments.length !== lower.segments.length)
+    throw new RangeError(
+      "IntervalBandSeries curve boundaries have incompatible geometry."
+    );
+  let upperStart = upper.start;
+  let lowerStart = lower.start;
+  let orientation = 0;
+  for (let i = 0; i < upper.segments.length && orientation === 0; i++) {
+    for (const value of [
+      upperStart[1] - lowerStart[1],
+      upper.segments[i].end[1] - lower.segments[i].end[1]
+    ]) {
+      if (value !== 0) {
+        orientation = Math.sign(value);
+        break;
+      }
+    }
+    upperStart = upper.segments[i].end;
+    lowerStart = lower.segments[i].end;
+  }
+  upperStart = upper.start;
+  lowerStart = lower.start;
+  for (let i = 0; i < upper.segments.length; i++) {
+    const upperSegment = upper.segments[i], lowerSegment = lower.segments[i];
+    const upperY = cubicY(upperStart, upperSegment);
+    const lowerY = cubicY(lowerStart, lowerSegment);
+    const difference = upperY.map((value, index) => value - lowerY[index]);
+    if (!difference.every(Number.isFinite))
+      throw new RangeError(
+        "IntervalBandSeries curve boundaries must be finite."
+      );
+    const magnitude = Math.max(...difference.map(Math.abs));
+    const normalized = difference.map(
+      (value) => magnitude === 0 ? 0 : value / magnitude
+    );
+    const candidates = [0, 1, ...derivativeRoots(normalized)].filter(
+      (value) => value >= 0 && value <= 1
+    );
+    for (const t of candidates) {
+      const value = cubicValue(normalized, t);
+      if (!Number.isFinite(value) || // Relative tolerance accounts only for floating-point evaluation at tangencies.
+      orientation !== 0 && value * orientation < -64 * Number.EPSILON)
+        throw new RangeError("IntervalBandSeries curve boundaries cross.");
+    }
+    upperStart = upperSegment.end;
+    lowerStart = lowerSegment.end;
+  }
+}
+export {
+  appendCurveForward,
+  appendCurveReverse,
+  createSeriesCurve,
+  curveGeometry,
+  resolveSeriesCurve,
+  validatePairedCurveGeometry
+};
+//# sourceMappingURL=curve-definition.js.map

package/dist/features/viz/lib/curve-definition.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/curve-definition.ts"],
+  "sourcesContent": ["import type { LineSeriesProps } from \"./types.js\";\n/** A mapped Cartesian coordinate used by private series curve rendering. */\nexport type SeriesCurvePoint = readonly [number, number];\n\n/**\n * A private generated segment. Cubic controls reserve the representation needed by a later\n * smooth-curve implementation; current step definitions generate straight segments only.\n */\nexport interface SeriesCurveSegment {\n  /** Endpoint of this segment. */\n  readonly end: SeriesCurvePoint;\n  /** First cubic B\u00E9zier control point when the segment is cubic. */\n  readonly control1?: SeriesCurvePoint;\n  /** Second cubic B\u00E9zier control point when the segment is cubic. */\n  readonly control2?: SeriesCurvePoint;\n}\n\n/** A private immutable path beginning at one point and continuing through generated segments. */\nexport interface SeriesCurveGeometry {\n  /** Initial coordinate for the geometry. */\n  readonly start: SeriesCurvePoint;\n  /** Ordered segments after {@link SeriesCurveGeometry.start}. */\n  readonly segments: readonly SeriesCurveSegment[];\n}\n\ndeclare const seriesCurveBrand: unique symbol;\n\n/**\n * An opaque immutable definition controlling how a series connects adjacent observations.\n *\n * Obtain a definition from one of the named curve factories. Definitions intentionally expose\n * no algorithm selector or custom callback surface.\n *\n * @see {@link LineSeriesProps}\n */\nexport interface SeriesCurve {\n  /** Nominal marker that prevents callers from forging a recognized definition. */\n  readonly [seriesCurveBrand]: true;\n}\n\ntype SeriesCurveBuilder = (\n  points: readonly SeriesCurvePoint[],\n) => readonly SeriesCurveSegment[];\n\nconst builders = new WeakMap<SeriesCurve, SeriesCurveBuilder>();\n\n/** @internal Creates one module-recognized immutable curve definition. */\nexport function createSeriesCurve(builder: SeriesCurveBuilder): SeriesCurve {\n  const definition = Object.freeze({}) as unknown as SeriesCurve;\n  builders.set(definition, builder);\n  return definition;\n}\n\n/** @internal Rejects values that were not created by a named curve factory. */\nexport function resolveSeriesCurve(value: unknown): SeriesCurve | undefined {\n  if (value === undefined || value === \"linear\") return undefined;\n  if (\n    typeof value !== \"object\" ||\n    value === null ||\n    !builders.has(value as SeriesCurve)\n  )\n    throw new TypeError(\n      'Series curve must be \"linear\" or a definition from a named factory.',\n    );\n  return value as SeriesCurve;\n}\n\n/** @internal Builds the curve geometry for one already-valid contiguous run. */\nexport function curveGeometry(\n  curve: SeriesCurve | undefined,\n  points: readonly SeriesCurvePoint[],\n): SeriesCurveGeometry {\n  const start = points[0];\n  return Object.freeze({\n    start,\n    segments: Object.freeze(\n      curve\n        ? [...builders.get(curve)!(points)]\n        : points.slice(1).map((end) => Object.freeze({ end })),\n    ),\n  });\n}\n\n/** @internal Appends one generated geometry in its authored forward direction. */\nexport function appendCurveForward(\n  path: Path2D,\n  geometry: SeriesCurveGeometry,\n): void {\n  for (const segment of geometry.segments) {\n    if (segment.control1 && segment.control2)\n      path.bezierCurveTo(\n        segment.control1[0],\n        segment.control1[1],\n        segment.control2[0],\n        segment.control2[1],\n        segment.end[0],\n        segment.end[1],\n      );\n    else path.lineTo(segment.end[0], segment.end[1]);\n  }\n}\n\n/** @internal Appends one generated geometry in reverse without rebuilding its curve strategy. */\nexport function appendCurveReverse(\n  path: Path2D,\n  geometry: SeriesCurveGeometry,\n): void {\n  const ends = geometry.segments.map((segment) => segment.end);\n  path.lineTo(\n    (ends.at(-1) ?? geometry.start)[0],\n    (ends.at(-1) ?? geometry.start)[1],\n  );\n  for (let i = geometry.segments.length - 1; i >= 0; i--) {\n    const segment = geometry.segments[i];\n    const start = i === 0 ? geometry.start : geometry.segments[i - 1].end;\n    if (segment.control1 && segment.control2)\n      path.bezierCurveTo(\n        segment.control2[0],\n        segment.control2[1],\n        segment.control1[0],\n        segment.control1[1],\n        start[0],\n        start[1],\n      );\n    else path.lineTo(start[0], start[1]);\n  }\n}\n\nfunction cubicValue(\n  values: readonly [number, number, number, number],\n  t: number,\n): number {\n  const [p0, p1, p2, p3] = values;\n  const inverse = 1 - t;\n  return (\n    inverse ** 3 * p0 +\n    3 * inverse ** 2 * t * p1 +\n    3 * inverse * t ** 2 * p2 +\n    t ** 3 * p3\n  );\n}\n\nfunction derivativeRoots(\n  values: readonly [number, number, number, number],\n): readonly number[] {\n  const [p0, p1, p2, p3] = values;\n  const a = -p0 + 3 * p1 - 3 * p2 + p3;\n  const b = 3 * p0 - 6 * p1 + 3 * p2;\n  const c = -3 * p0 + 3 * p1;\n  if (a === 0) {\n    if (b === 0) return [];\n    return [-c / (2 * b)];\n  }\n  const discriminant = 4 * b * b - 12 * a * c;\n  if (discriminant < 0) return [];\n  const root = Math.sqrt(discriminant);\n  const q = -b - (b >= 0 ? root / 2 : -root / 2);\n  return q === 0 ? [-b / (3 * a)] : [q / (3 * a), c / q];\n}\n\nfunction cubicY(\n  start: SeriesCurvePoint,\n  segment: SeriesCurveSegment,\n): readonly [number, number, number, number] {\n  const end = segment.end;\n  const control1 = segment.control1 ?? [\n    start[0] + (end[0] - start[0]) / 3,\n    start[1] + (end[1] - start[1]) / 3,\n  ];\n  const control2 = segment.control2 ?? [\n    start[0] + ((end[0] - start[0]) * 2) / 3,\n    start[1] + ((end[1] - start[1]) * 2) / 3,\n  ];\n  return [start[1], control1[1], control2[1], end[1]];\n}\n\n/** @internal Rejects interval-band cubics whose paired boundaries cross between observations. */\nexport function validatePairedCurveGeometry(\n  upper: SeriesCurveGeometry,\n  lower: SeriesCurveGeometry,\n): void {\n  if (upper.segments.length !== lower.segments.length)\n    throw new RangeError(\n      \"IntervalBandSeries curve boundaries have incompatible geometry.\",\n    );\n  let upperStart = upper.start;\n  let lowerStart = lower.start;\n  let orientation = 0;\n  for (let i = 0; i < upper.segments.length && orientation === 0; i++) {\n    for (const value of [\n      upperStart[1] - lowerStart[1],\n      upper.segments[i].end[1] - lower.segments[i].end[1],\n    ]) {\n      if (value !== 0) {\n        orientation = Math.sign(value);\n        break;\n      }\n    }\n    upperStart = upper.segments[i].end;\n    lowerStart = lower.segments[i].end;\n  }\n  upperStart = upper.start;\n  lowerStart = lower.start;\n  for (let i = 0; i < upper.segments.length; i++) {\n    const upperSegment = upper.segments[i],\n      lowerSegment = lower.segments[i];\n    const upperY = cubicY(upperStart, upperSegment);\n    const lowerY = cubicY(lowerStart, lowerSegment);\n    const difference = upperY.map((value, index) => value - lowerY[index]) as [\n      number,\n      number,\n      number,\n      number,\n    ];\n    if (!difference.every(Number.isFinite))\n      throw new RangeError(\n        \"IntervalBandSeries curve boundaries must be finite.\",\n      );\n    const magnitude = Math.max(...difference.map(Math.abs));\n    const normalized = difference.map((value) =>\n      magnitude === 0 ? 0 : value / magnitude,\n    ) as [number, number, number, number];\n    const candidates = [0, 1, ...derivativeRoots(normalized)].filter(\n      (value) => value >= 0 && value <= 1,\n    );\n    for (const t of candidates) {\n      const value = cubicValue(normalized, t);\n      if (\n        !Number.isFinite(value) ||\n        // Relative tolerance accounts only for floating-point evaluation at tangencies.\n        (orientation !== 0 && value * orientation < -64 * Number.EPSILON)\n      )\n        throw new RangeError(\"IntervalBandSeries curve boundaries cross.\");\n    }\n    upperStart = upperSegment.end;\n    lowerStart = lowerSegment.end;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/features/viz/lib/diverging-color-scale.d.ts

@@ -0,0 +1,11 @@
+import { type Signal } from "@pibbl/core";
+import type { DivergingColorScaleProps, ResolvedDivergingColorScale } from "./color-types.js";
+import type { ScaleId } from "./types.js";
+/** Provides an allocation-independent color mapping with an authored center.
+ * @param props - Explicit domain, colors, identity, and children. See {@link DivergingColorScaleProps}.
+ * @returns Descendant content. */
+export declare function DivergingColorScale(props: DivergingColorScaleProps): import("@pibbl/core").PibblNode;
+/** Reads the dedicated ancestor diverging mapping.
+ * @param id - Color-scale identity. See {@link ScaleId}.
+ * @returns Shared readonly mapping signal. See {@link ResolvedDivergingColorScale}. */
+export declare function useDivergingColorScale(id: ScaleId): Signal<ResolvedDivergingColorScale>;

package/dist/features/viz/lib/diverging-color-scale.js

@@ -0,0 +1,51 @@
+import { resolveSignalValue } from "@pibbl/core";
+import { provideColor, useColor } from "./color-context.js";
+import {
+  colorMix,
+  colorPosition,
+  finiteColorValue,
+  hexColor
+} from "./color-math.js";
+function resolve(props) {
+  const input = resolveSignalValue(props.domain), paint = resolveSignalValue(props.colors);
+  if (!Array.isArray(input) || input.length !== 3 || !Array.isArray(paint) || paint.length !== 3)
+    throw new RangeError(
+      "Diverging color scales require three domain values and three colors."
+    );
+  const domain = Object.freeze(
+    Array.from(input, finiteColorValue)
+  ), colors = Object.freeze(Array.from(paint, hexColor));
+  const [a, m, b] = domain;
+  if (!(a < m && m < b || a > m && m > b))
+    throw new RangeError(
+      "Diverging color domain must be strictly monotonic around its center."
+    );
+  const stops = Object.freeze(
+    domain.map((value, i) => Object.freeze({ value, color: colors[i] }))
+  );
+  return Object.freeze({
+    domain,
+    colors,
+    stops,
+    map(value) {
+      finiteColorValue(value);
+      if (value === m) return colors[1];
+      return (a < m ? value < m : value > m) ? colorMix(colors[0], colors[1], colorPosition(value, a, m)) : colorMix(colors[1], colors[2], colorPosition(value, m, b));
+    }
+  });
+}
+function DivergingColorScale(props) {
+  provideColor(props.id, "diverging", () => resolve(props), [
+    props.domain,
+    props.colors
+  ]);
+  return props.children;
+}
+function useDivergingColorScale(id) {
+  return useColor(id, "diverging");
+}
+export {
+  DivergingColorScale,
+  useDivergingColorScale
+};
+//# sourceMappingURL=diverging-color-scale.js.map

package/dist/features/viz/lib/diverging-color-scale.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/diverging-color-scale.ts"],
+  "sourcesContent": ["import { resolveSignalValue, type Signal } from \"@pibbl/core\";\nimport type {\n  DivergingColorScaleProps,\n  ResolvedDivergingColorScale,\n} from \"./color-types.js\";\nimport type { ScaleId } from \"./types.js\";\nimport { provideColor, useColor } from \"./color-context.js\";\nimport {\n  colorMix,\n  colorPosition,\n  finiteColorValue,\n  hexColor,\n} from \"./color-math.js\";\nfunction resolve(props: DivergingColorScaleProps): ResolvedDivergingColorScale {\n  const input = resolveSignalValue(props.domain),\n    paint = resolveSignalValue(props.colors);\n  if (\n    !Array.isArray(input) ||\n    input.length !== 3 ||\n    !Array.isArray(paint) ||\n    paint.length !== 3\n  )\n    throw new RangeError(\n      \"Diverging color scales require three domain values and three colors.\",\n    );\n  const domain = Object.freeze(\n      Array.from(input, finiteColorValue),\n    ) as readonly [number, number, number],\n    colors = Object.freeze(Array.from(paint, hexColor)) as readonly [\n      string,\n      string,\n      string,\n    ];\n  const [a, m, b] = domain;\n  if (!((a < m && m < b) || (a > m && m > b)))\n    throw new RangeError(\n      \"Diverging color domain must be strictly monotonic around its center.\",\n    );\n  const stops = Object.freeze(\n    domain.map((value, i) => Object.freeze({ value, color: colors[i] })),\n  );\n  return Object.freeze({\n    domain,\n    colors,\n    stops,\n    map(value: number) {\n      finiteColorValue(value);\n      if (value === m) return colors[1];\n      return (a < m ? value < m : value > m)\n        ? colorMix(colors[0], colors[1], colorPosition(value, a, m))\n        : colorMix(colors[1], colors[2], colorPosition(value, m, b));\n    },\n  });\n}\n/** Provides an allocation-independent color mapping with an authored center.\n * @param props - Explicit domain, colors, identity, and children. See {@link DivergingColorScaleProps}.\n * @returns Descendant content. */\nexport function DivergingColorScale(props: DivergingColorScaleProps) {\n  provideColor(props.id, \"diverging\", () => resolve(props), [\n    props.domain,\n    props.colors,\n  ]);\n  return props.children;\n}\n/** Reads the dedicated ancestor diverging mapping.\n * @param id - Color-scale identity. See {@link ScaleId}.\n * @returns Shared readonly mapping signal. See {@link ResolvedDivergingColorScale}. */\nexport function useDivergingColorScale(\n  id: ScaleId,\n): Signal<ResolvedDivergingColorScale> {\n  return useColor(id, \"diverging\");\n}\n"],
+  "mappings": "AAAA,SAAS,0BAAuC;AAMhD,SAAS,cAAc,gBAAgB;AACvC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,QAAQ,OAA8D;AAC7E,QAAM,QAAQ,mBAAmB,MAAM,MAAM,GAC3C,QAAQ,mBAAmB,MAAM,MAAM;AACzC,MACE,CAAC,MAAM,QAAQ,KAAK,KACpB,MAAM,WAAW,KACjB,CAAC,MAAM,QAAQ,KAAK,KACpB,MAAM,WAAW;AAEjB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,QAAM,SAAS,OAAO;AAAA,IAClB,MAAM,KAAK,OAAO,gBAAgB;AAAA,EACpC,GACA,SAAS,OAAO,OAAO,MAAM,KAAK,OAAO,QAAQ,CAAC;AAKpD,QAAM,CAAC,GAAG,GAAG,CAAC,IAAI;AAClB,MAAI,EAAG,IAAI,KAAK,IAAI,KAAO,IAAI,KAAK,IAAI;AACtC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,QAAM,QAAQ,OAAO;AAAA,IACnB,OAAO,IAAI,CAAC,OAAO,MAAM,OAAO,OAAO,EAAE,OAAO,OAAO,OAAO,CAAC,EAAE,CAAC,CAAC;AAAA,EACrE;AACA,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA,IAAI,OAAe;AACjB,uBAAiB,KAAK;AACtB,UAAI,UAAU,EAAG,QAAO,OAAO,CAAC;AAChC,cAAQ,IAAI,IAAI,QAAQ,IAAI,QAAQ,KAChC,SAAS,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,cAAc,OAAO,GAAG,CAAC,CAAC,IACzD,SAAS,OAAO,CAAC,GAAG,OAAO,CAAC,GAAG,cAAc,OAAO,GAAG,CAAC,CAAC;AAAA,IAC/D;AAAA,EACF,CAAC;AACH;AAIO,SAAS,oBAAoB,OAAiC;AACnE,eAAa,MAAM,IAAI,aAAa,MAAM,QAAQ,KAAK,GAAG;AAAA,IACxD,MAAM;AAAA,IACN,MAAM;AAAA,EACR,CAAC;AACD,SAAO,MAAM;AACf;AAIO,SAAS,uBACd,IACqC;AACrC,SAAO,SAAS,IAAI,WAAW;AACjC;",
+  "names": []
+}

package/dist/features/viz/lib/domain-navigation.d.ts

@@ -0,0 +1,40 @@
+import type { LinearDomain, ResolvedContinuousScale } from "./types.js";
+/** Explicit hard bounds and minimum mapped extent for continuous-domain navigation. @see {@link panDomain} @see {@link zoomDomain} */
+export interface DomainNavigationConstraints {
+    /** Finite hard domain endpoints, in either order, valid for the supplied scale. See {@link LinearDomain}. */
+    readonly bounds: LinearDomain;
+    /** Minimum span as a fraction of the mapped hard bounds, greater than zero through one. Defaults to 0.01. */
+    readonly minimumSpanRatio?: number;
+}
+/** Named pan settings with explicit navigation limits. @see {@link panDomain} */
+export interface PanDomainOptions extends DomainNavigationConstraints {
+    /** Finite displacement in range units; positive shifts mapped values toward increasing range coordinates. */
+    readonly rangeDelta: number;
+}
+/** Named zoom settings with explicit navigation limits. @see {@link zoomDomain} */
+export interface ZoomDomainOptions extends DomainNavigationConstraints {
+    /** Finite anchor in the scale's range coordinates, using the same units as its range. */
+    readonly rangeAnchor: number;
+    /** Finite positive magnification; greater than one zooms in. */
+    readonly factor: number;
+}
+/**
+ * Moves the visible continuous domain by a displacement expressed in range units.
+ * Positive displacement shifts mapped values toward increasing range coordinates; the returned domain moves oppositely.
+ * @param scale - Current resolved continuous mapping. See {@link ResolvedContinuousScale}.
+ * @param options - Displacement, bounds, and minimum span. See {@link PanDomainOptions}.
+ * @returns A new immutable domain pair. See {@link LinearDomain}.
+ * @throws When inputs, bounds, or the resulting extent are invalid or collapsed.
+ * @see {@link zoomDomain}
+ */
+export declare function panDomain(scale: ResolvedContinuousScale, options: PanDomainOptions): LinearDomain;
+/**
+ * Magnifies a continuous domain around an anchor in range coordinates.
+ * Factor greater than one zooms in; hard bounds and minimum span may limit anchor preservation.
+ * @param scale - Current resolved continuous mapping. See {@link ResolvedContinuousScale}.
+ * @param options - Anchor, magnification, bounds, and minimum span. See {@link ZoomDomainOptions}.
+ * @returns A new immutable domain pair. See {@link LinearDomain}.
+ * @throws When factor, mapping, bounds, or the resulting extent are invalid or collapsed.
+ * @see {@link panDomain}
+ */
+export declare function zoomDomain(scale: ResolvedContinuousScale, options: ZoomDomainOptions): LinearDomain;

package/dist/features/viz/lib/domain-navigation.js

@@ -0,0 +1,77 @@
+function finite(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new RangeError(`${name} must be finite.`);
+  return value;
+}
+function navigate(scale, start, end, constraints, requestedSpan) {
+  const [r0, r1] = scale.range;
+  if (r0 === r1 || scale.domain[0] === scale.domain[1])
+    throw new RangeError(
+      "Domain navigation requires noncollapsed domain and range."
+    );
+  const { bounds, minimumSpanRatio = 0.01 } = constraints;
+  if (!Array.isArray(bounds) || bounds.length !== 2)
+    throw new RangeError("Navigation bounds require two endpoints.");
+  if (scale.type === "utc" && !bounds.every(Number.isSafeInteger))
+    throw new RangeError(
+      "UTC navigation bounds must be safe integer milliseconds."
+    );
+  const b0 = scale.map(finite(bounds[0], "Lower bound")), b1 = scale.map(finite(bounds[1], "Upper bound"));
+  const lo = Math.min(b0, b1), hi = Math.max(b0, b1), extent = hi - lo;
+  if (!Number.isFinite(extent) || extent <= 0)
+    throw new RangeError(
+      "Navigation bounds must have a finite nonzero mapped extent."
+    );
+  if (!Number.isFinite(minimumSpanRatio) || minimumSpanRatio <= 0 || minimumSpanRatio > 1)
+    throw new RangeError(
+      "minimumSpanRatio must be greater than zero and at most one."
+    );
+  finite(start, "Mapped start");
+  finite(end, "Mapped end");
+  const requested = requestedSpan ?? Math.abs(end - start);
+  if (!Number.isFinite(requested))
+    throw new RangeError("Navigation span must be finite.");
+  const span = Math.min(extent, Math.max(extent * minimumSpanRatio, requested));
+  const center = start / 2 + end / 2;
+  const low = Math.max(lo, Math.min(hi - span, center - span / 2)), high = low + span;
+  let a = scale.invert(r0 < r1 ? low : high), b = scale.invert(r0 < r1 ? high : low);
+  if (scale.type === "utc") {
+    a = Math.round(a);
+    b = Math.round(b);
+  }
+  finite(a, "Domain start");
+  finite(b, "Domain end");
+  if (a === b)
+    throw new RangeError(
+      "Navigation result collapses at the scale's numeric precision."
+    );
+  return Object.freeze([a, b]);
+}
+function panDomain(scale, options) {
+  const { rangeDelta } = options;
+  finite(rangeDelta, "Pan displacement");
+  return navigate(
+    scale,
+    scale.range[0] - rangeDelta,
+    scale.range[1] - rangeDelta,
+    options,
+    Math.abs(scale.range[1] - scale.range[0])
+  );
+}
+function zoomDomain(scale, options) {
+  const { rangeAnchor, factor } = options;
+  finite(rangeAnchor, "Zoom anchor");
+  finite(factor, "Zoom factor");
+  if (factor <= 0) throw new RangeError("Zoom factor must be positive.");
+  return navigate(
+    scale,
+    rangeAnchor + (scale.range[0] - rangeAnchor) / factor,
+    rangeAnchor + (scale.range[1] - rangeAnchor) / factor,
+    options
+  );
+}
+export {
+  panDomain,
+  zoomDomain
+};
+//# sourceMappingURL=domain-navigation.js.map