@pibbl/core 0.0.1 → 0.0.3-alpha.85.1

package/dist/features/viz/lib/scale-view.js

@@ -0,0 +1,21 @@
+import { computed } from "@pibbl/core";
+import { lookupScale, scaleKind } from "./scale-context.js";
+function scaleView(cache, id, receiver, accepts) {
+  const source = lookupScale(id, receiver);
+  if (!source) throw new TypeError(`${receiver} requires a scale ID.`);
+  if (accepts(scaleKind(source))) return source;
+  let view = cache.get(source);
+  if (!view) {
+    view = computed(() => {
+      const value = source.get();
+      if (!accepts(value.type)) throw new TypeError(`${receiver} cannot read a ${value.type} scale.`);
+      return value;
+    });
+    cache.set(source, view);
+  }
+  return view;
+}
+export {
+  scaleView
+};
+//# sourceMappingURL=scale-view.js.map

package/dist/features/viz/lib/scale-view.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/scale-view.ts"],
+  "sourcesContent": ["import { computed, type Signal } from \"@pibbl/core\";\nimport { lookupScale, scaleKind } from \"./scale-context.js\";\nimport type { ResolvedScale, ScaleId } from \"./types.js\";\n/** A lazy shared view: one readonly signal per provider and supported hook. */\nexport function scaleView<T extends ResolvedScale>(\n  cache: WeakMap<Signal<ResolvedScale>, Signal<T>>,\n  id: ScaleId,\n  receiver: string,\n  accepts: (kind: ResolvedScale[\"type\"] | undefined) => boolean,\n): Signal<T> {\n  const source = lookupScale(id, receiver);\n  if (!source) throw new TypeError(`${receiver} requires a scale ID.`);\n  // Return the provider transaction directly; an extra computed cache would hide\n  // candidate formulas during layout/reflow until the render commits.\n  if (accepts(scaleKind(source))) return source as Signal<T>;\n  let view = cache.get(source);\n  if (!view) {\n    view = computed(() => {\n      const value = source.get();\n      if (!accepts(value.type)) throw new TypeError(`${receiver} cannot read a ${value.type} scale.`);\n      return value as T;\n    });\n    cache.set(source, view);\n  }\n  return view;\n}\n"],
+  "mappings": "AAAA,SAAS,gBAA6B;AACtC,SAAS,aAAa,iBAAiB;AAGhC,SAAS,UACd,OACA,IACA,UACA,SACW;AACX,QAAM,SAAS,YAAY,IAAI,QAAQ;AACvC,MAAI,CAAC,OAAQ,OAAM,IAAI,UAAU,GAAG,QAAQ,uBAAuB;AAGnE,MAAI,QAAQ,UAAU,MAAM,CAAC,EAAG,QAAO;AACvC,MAAI,OAAO,MAAM,IAAI,MAAM;AAC3B,MAAI,CAAC,MAAM;AACT,WAAO,SAAS,MAAM;AACpB,YAAM,QAAQ,OAAO,IAAI;AACzB,UAAI,CAAC,QAAQ,MAAM,IAAI,EAAG,OAAM,IAAI,UAAU,GAAG,QAAQ,kBAAkB,MAAM,IAAI,SAAS;AAC9F,aAAO;AAAA,IACT,CAAC;AACD,UAAM,IAAI,QAAQ,IAAI;AAAA,EACxB;AACA,SAAO;AACT;",
+  "names": []
+}

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

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

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

@@ -0,0 +1,49 @@
+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 !== 2 || !Array.isArray(paint) || paint.length !== 2)
+    throw new RangeError(
+      "Sequential color scales require two domain endpoints and two colors."
+    );
+  const domain = Object.freeze(
+    Array.from(input, finiteColorValue)
+  ), colors = Object.freeze(Array.from(paint, hexColor));
+  const stops = Object.freeze(
+    domain.map((value, i) => Object.freeze({ value, color: colors[i] }))
+  );
+  return Object.freeze({
+    domain,
+    colors,
+    stops,
+    map(value) {
+      finiteColorValue(value);
+      return colorMix(
+        colors[0],
+        colors[1],
+        colorPosition(value, domain[0], domain[1])
+      );
+    }
+  });
+}
+function SequentialColorScale(props) {
+  provideColor(props.id, "sequential", () => resolve(props), [
+    props.domain,
+    props.colors
+  ]);
+  return props.children;
+}
+function useSequentialColorScale(id) {
+  return useColor(id, "sequential");
+}
+export {
+  SequentialColorScale,
+  useSequentialColorScale
+};
+//# sourceMappingURL=sequential-color-scale.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/sequential-color-scale.ts"],
+  "sourcesContent": ["import { resolveSignalValue, type Signal } from \"@pibbl/core\";\nimport type {\n  SequentialColorScaleProps,\n  ResolvedSequentialColorScale,\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(\n  props: SequentialColorScaleProps,\n): ResolvedSequentialColorScale {\n  const input = resolveSignalValue(props.domain),\n    paint = resolveSignalValue(props.colors);\n  if (\n    !Array.isArray(input) ||\n    input.length !== 2 ||\n    !Array.isArray(paint) ||\n    paint.length !== 2\n  )\n    throw new RangeError(\n      \"Sequential color scales require two domain endpoints and two colors.\",\n    );\n  const domain = Object.freeze(\n      Array.from(input, finiteColorValue),\n    ) as readonly [number, number],\n    colors = Object.freeze(Array.from(paint, hexColor)) as readonly [\n      string,\n      string,\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      return colorMix(\n        colors[0],\n        colors[1],\n        colorPosition(value, domain[0], domain[1]),\n      );\n    },\n  });\n}\n/** Provides an allocation-independent sequential color mapping.\n * @param props - Explicit domain, colors, identity, and children. See {@link SequentialColorScaleProps}.\n * @returns Descendant content. */\nexport function SequentialColorScale(props: SequentialColorScaleProps) {\n  provideColor(props.id, \"sequential\", () => resolve(props), [\n    props.domain,\n    props.colors,\n  ]);\n  return props.children;\n}\n/** Reads the dedicated ancestor sequential mapping.\n * @param id - Color-scale identity. See {@link ScaleId}.\n * @returns Shared readonly mapping signal. See {@link ResolvedSequentialColorScale}. */\nexport function useSequentialColorScale(\n  id: ScaleId,\n): Signal<ResolvedSequentialColorScale> {\n  return useColor(id, \"sequential\");\n}\n"],
+  "mappings": "AAAA,SAAS,0BAAuC;AAMhD,SAAS,cAAc,gBAAgB;AACvC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,QACP,OAC8B;AAC9B,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;AAIpD,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,aAAO;AAAA,QACL,OAAO,CAAC;AAAA,QACR,OAAO,CAAC;AAAA,QACR,cAAc,OAAO,OAAO,CAAC,GAAG,OAAO,CAAC,CAAC;AAAA,MAC3C;AAAA,IACF;AAAA,EACF,CAAC;AACH;AAIO,SAAS,qBAAqB,OAAkC;AACrE,eAAa,MAAM,IAAI,cAAc,MAAM,QAAQ,KAAK,GAAG;AAAA,IACzD,MAAM;AAAA,IACN,MAAM;AAAA,EACR,CAAC;AACD,SAAO,MAAM;AACf;AAIO,SAAS,wBACd,IACsC;AACtC,SAAO,SAAS,IAAI,YAAY;AAClC;",
+  "names": []
+}

package/dist/features/viz/lib/series-position.d.ts

@@ -0,0 +1,12 @@
+import type { ResolvedContinuousScale, ResolvedPointScale, ScaleId, SeriesAccessor, SeriesCoordinate } from "./types.js";
+export type NumericPositionScale = ResolvedContinuousScale | import("./trading-time-scale.js").ResolvedTradingTimeScale;
+type PositionScale = NumericPositionScale | ResolvedPointScale;
+/** Private position receiver; public scale hooks retain their dedicated contracts. */
+export declare function useSeriesPosition(id: ScaleId): PositionScale;
+export declare function seriesAccessor<D>(input: SeriesAccessor<D>): (datum: D, index: number, data: readonly D[]) => SeriesCoordinate;
+export declare function mapSeriesPosition(scale: PositionScale, value: SeriesCoordinate): number | undefined;
+/** Private numeric/trading receiver; public continuous hook stays unchanged. */
+export declare function useNumericPosition(id: ScaleId): NumericPositionScale;
+/** Returns explicit supplied time for trading positions, continuous inverse otherwise. */
+export declare function invertNumericPosition(scale: NumericPositionScale, position: number): number | undefined;
+export {};

package/dist/features/viz/lib/series-position.js

@@ -0,0 +1,44 @@
+import { scaleView } from "./scale-view.js";
+const views = /* @__PURE__ */ new WeakMap();
+function useSeriesPosition(id) {
+  return scaleView(views, id, "Series", (kind) => kind !== "band").get();
+}
+function seriesAccessor(input) {
+  return typeof input === "function" ? input : (datum) => datum[input];
+}
+function mapSeriesPosition(scale, value) {
+  if (value == null || typeof value === "number" && !Number.isFinite(value))
+    return void 0;
+  if (scale.type === "point") {
+    const mapped = scale.map(value);
+    if (mapped === void 0)
+      throw new RangeError(
+        `Series: unknown point category ${String(value)} (${typeof value}).`
+      );
+    return mapped;
+  }
+  if (typeof value !== "number")
+    throw new TypeError(
+      "Series: continuous coordinates must be numbers; use PointScale for categories."
+    );
+  return scale.map(value);
+}
+function useNumericPosition(id) {
+  const value = useSeriesPosition(id);
+  if (value.type === "point")
+    throw new TypeError(
+      "Numeric position requires a numeric or trading-time scale."
+    );
+  return value;
+}
+function invertNumericPosition(scale, position) {
+  return scale.type === "trading-time" ? scale.nearestTimeAtPosition(position) : scale.invert(position);
+}
+export {
+  invertNumericPosition,
+  mapSeriesPosition,
+  seriesAccessor,
+  useNumericPosition,
+  useSeriesPosition
+};
+//# sourceMappingURL=series-position.js.map

package/dist/features/viz/lib/series-position.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/series-position.ts"],
+  "sourcesContent": ["import type { Signal } from \"@pibbl/core\";\nimport { scaleView } from \"./scale-view.js\";\nimport type {\n  ResolvedScale,\n  ResolvedContinuousScale,\n  ResolvedPointScale,\n  ScaleId,\n  SeriesAccessor,\n  SeriesCoordinate,\n} from \"./types.js\";\nexport type NumericPositionScale =\n  | ResolvedContinuousScale\n  | import(\"./trading-time-scale.js\").ResolvedTradingTimeScale;\ntype PositionScale = NumericPositionScale | ResolvedPointScale;\nconst views = new WeakMap<Signal<ResolvedScale>, Signal<PositionScale>>();\n/** Private position receiver; public scale hooks retain their dedicated contracts. */\nexport function useSeriesPosition(id: ScaleId): PositionScale {\n  return scaleView(views, id, \"Series\", (kind) => kind !== \"band\").get();\n}\nexport function seriesAccessor<D>(\n  input: SeriesAccessor<D>,\n): (datum: D, index: number, data: readonly D[]) => SeriesCoordinate {\n  return typeof input === \"function\"\n    ? input\n    : (datum) => datum[input] as SeriesCoordinate;\n}\nexport function mapSeriesPosition(\n  scale: PositionScale,\n  value: SeriesCoordinate,\n): number | undefined {\n  if (value == null || (typeof value === \"number\" && !Number.isFinite(value)))\n    return undefined;\n  if (scale.type === \"point\") {\n    const mapped = scale.map(value);\n    if (mapped === undefined)\n      throw new RangeError(\n        `Series: unknown point category ${String(value)} (${typeof value}).`,\n      );\n    return mapped;\n  }\n  if (typeof value !== \"number\")\n    throw new TypeError(\n      \"Series: continuous coordinates must be numbers; use PointScale for categories.\",\n    );\n  return scale.map(value);\n}\n\n/** Private numeric/trading receiver; public continuous hook stays unchanged. */\nexport function useNumericPosition(id: ScaleId): NumericPositionScale {\n  const value = useSeriesPosition(id);\n  if (value.type === \"point\")\n    throw new TypeError(\n      \"Numeric position requires a numeric or trading-time scale.\",\n    );\n  return value;\n}\n/** Returns explicit supplied time for trading positions, continuous inverse otherwise. */\nexport function invertNumericPosition(\n  scale: NumericPositionScale,\n  position: number,\n): number | undefined {\n  return scale.type === \"trading-time\"\n    ? scale.nearestTimeAtPosition(position)\n    : scale.invert(position);\n}\n"],
+  "mappings": "AACA,SAAS,iBAAiB;AAa1B,MAAM,QAAQ,oBAAI,QAAsD;AAEjE,SAAS,kBAAkB,IAA4B;AAC5D,SAAO,UAAU,OAAO,IAAI,UAAU,CAAC,SAAS,SAAS,MAAM,EAAE,IAAI;AACvE;AACO,SAAS,eACd,OACmE;AACnE,SAAO,OAAO,UAAU,aACpB,QACA,CAAC,UAAU,MAAM,KAAK;AAC5B;AACO,SAAS,kBACd,OACA,OACoB;AACpB,MAAI,SAAS,QAAS,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK;AACvE,WAAO;AACT,MAAI,MAAM,SAAS,SAAS;AAC1B,UAAM,SAAS,MAAM,IAAI,KAAK;AAC9B,QAAI,WAAW;AACb,YAAM,IAAI;AAAA,QACR,kCAAkC,OAAO,KAAK,CAAC,KAAK,OAAO,KAAK;AAAA,MAClE;AACF,WAAO;AAAA,EACT;AACA,MAAI,OAAO,UAAU;AACnB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO,MAAM,IAAI,KAAK;AACxB;AAGO,SAAS,mBAAmB,IAAmC;AACpE,QAAM,QAAQ,kBAAkB,EAAE;AAClC,MAAI,MAAM,SAAS;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,SAAO;AACT;AAEO,SAAS,sBACd,OACA,UACoB;AACpB,SAAO,MAAM,SAAS,iBAClB,MAAM,sBAAsB,QAAQ,IACpC,MAAM,OAAO,QAAQ;AAC3B;",
+  "names": []
+}

package/dist/features/viz/lib/step-curves.d.ts

@@ -0,0 +1,19 @@
+import { type SeriesCurve } from "./curve-definition.js";
+/**
+ * Returns the immutable definition that jumps to the next value at the prior x coordinate.
+ *
+ * @returns The named {@link SeriesCurve} definition.
+ */
+export declare function stepBefore(): SeriesCurve;
+/**
+ * Returns the immutable definition that holds the prior value until the next x coordinate.
+ *
+ * @returns The named {@link SeriesCurve} definition.
+ */
+export declare function stepAfter(): SeriesCurve;
+/**
+ * Returns the immutable definition that places each value transition halfway between x values.
+ *
+ * @returns The named {@link SeriesCurve} definition.
+ */
+export declare function stepMidpoint(): SeriesCurve;

package/dist/features/viz/lib/step-curves.js

@@ -0,0 +1,53 @@
+import {
+  createSeriesCurve
+} from "./curve-definition.js";
+function segment(end) {
+  return Object.freeze({ end });
+}
+function stepBeforeSegments(points) {
+  const segments = [];
+  for (let i = 1; i < points.length; i++) {
+    const previous = points[i - 1], next = points[i];
+    segments.push(segment([previous[0], next[1]]), segment(next));
+  }
+  return segments;
+}
+function stepAfterSegments(points) {
+  const segments = [];
+  for (let i = 1; i < points.length; i++) {
+    const previous = points[i - 1], next = points[i];
+    segments.push(segment([next[0], previous[1]]), segment(next));
+  }
+  return segments;
+}
+function stepMidpointSegments(points) {
+  const segments = [];
+  for (let i = 1; i < points.length; i++) {
+    const previous = points[i - 1], next = points[i];
+    const midpoint2 = previous[0] / 2 + next[0] / 2;
+    segments.push(
+      segment([midpoint2, previous[1]]),
+      segment([midpoint2, next[1]]),
+      segment(next)
+    );
+  }
+  return segments;
+}
+const before = /* @__PURE__ */ createSeriesCurve(stepBeforeSegments);
+const after = /* @__PURE__ */ createSeriesCurve(stepAfterSegments);
+const midpoint = /* @__PURE__ */ createSeriesCurve(stepMidpointSegments);
+function stepBefore() {
+  return before;
+}
+function stepAfter() {
+  return after;
+}
+function stepMidpoint() {
+  return midpoint;
+}
+export {
+  stepAfter,
+  stepBefore,
+  stepMidpoint
+};
+//# sourceMappingURL=step-curves.js.map

package/dist/features/viz/lib/step-curves.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/step-curves.ts"],
+  "sourcesContent": ["import {\n  createSeriesCurve,\n  type SeriesCurve,\n  type SeriesCurvePoint,\n} from \"./curve-definition.js\";\n\nfunction segment(end: SeriesCurvePoint) {\n  return Object.freeze({ end });\n}\n\nfunction stepBeforeSegments(points: readonly SeriesCurvePoint[]) {\n  const segments = [];\n  for (let i = 1; i < points.length; i++) {\n    const previous = points[i - 1],\n      next = points[i];\n    segments.push(segment([previous[0], next[1]]), segment(next));\n  }\n  return segments;\n}\n\nfunction stepAfterSegments(points: readonly SeriesCurvePoint[]) {\n  const segments = [];\n  for (let i = 1; i < points.length; i++) {\n    const previous = points[i - 1],\n      next = points[i];\n    segments.push(segment([next[0], previous[1]]), segment(next));\n  }\n  return segments;\n}\n\nfunction stepMidpointSegments(points: readonly SeriesCurvePoint[]) {\n  const segments = [];\n  for (let i = 1; i < points.length; i++) {\n    const previous = points[i - 1],\n      next = points[i];\n    const midpoint = previous[0] / 2 + next[0] / 2;\n    segments.push(\n      segment([midpoint, previous[1]]),\n      segment([midpoint, next[1]]),\n      segment(next),\n    );\n  }\n  return segments;\n}\n\nconst before = /* @__PURE__ */ createSeriesCurve(stepBeforeSegments);\nconst after = /* @__PURE__ */ createSeriesCurve(stepAfterSegments);\nconst midpoint = /* @__PURE__ */ createSeriesCurve(stepMidpointSegments);\n\n/**\n * Returns the immutable definition that jumps to the next value at the prior x coordinate.\n *\n * @returns The named {@link SeriesCurve} definition.\n */\nexport function stepBefore(): SeriesCurve {\n  return before;\n}\n\n/**\n * Returns the immutable definition that holds the prior value until the next x coordinate.\n *\n * @returns The named {@link SeriesCurve} definition.\n */\nexport function stepAfter(): SeriesCurve {\n  return after;\n}\n\n/**\n * Returns the immutable definition that places each value transition halfway between x values.\n *\n * @returns The named {@link SeriesCurve} definition.\n */\nexport function stepMidpoint(): SeriesCurve {\n  return midpoint;\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAGK;AAEP,SAAS,QAAQ,KAAuB;AACtC,SAAO,OAAO,OAAO,EAAE,IAAI,CAAC;AAC9B;AAEA,SAAS,mBAAmB,QAAqC;AAC/D,QAAM,WAAW,CAAC;AAClB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,WAAW,OAAO,IAAI,CAAC,GAC3B,OAAO,OAAO,CAAC;AACjB,aAAS,KAAK,QAAQ,CAAC,SAAS,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,QAAQ,IAAI,CAAC;AAAA,EAC9D;AACA,SAAO;AACT;AAEA,SAAS,kBAAkB,QAAqC;AAC9D,QAAM,WAAW,CAAC;AAClB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,WAAW,OAAO,IAAI,CAAC,GAC3B,OAAO,OAAO,CAAC;AACjB,aAAS,KAAK,QAAQ,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,QAAQ,IAAI,CAAC;AAAA,EAC9D;AACA,SAAO;AACT;AAEA,SAAS,qBAAqB,QAAqC;AACjE,QAAM,WAAW,CAAC;AAClB,WAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK;AACtC,UAAM,WAAW,OAAO,IAAI,CAAC,GAC3B,OAAO,OAAO,CAAC;AACjB,UAAMA,YAAW,SAAS,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI;AAC7C,aAAS;AAAA,MACP,QAAQ,CAACA,WAAU,SAAS,CAAC,CAAC,CAAC;AAAA,MAC/B,QAAQ,CAACA,WAAU,KAAK,CAAC,CAAC,CAAC;AAAA,MAC3B,QAAQ,IAAI;AAAA,IACd;AAAA,EACF;AACA,SAAO;AACT;AAEA,MAAM,SAAyB,kCAAkB,kBAAkB;AACnE,MAAM,QAAwB,kCAAkB,iBAAiB;AACjE,MAAM,WAA2B,kCAAkB,oBAAoB;AAOhE,SAAS,aAA0B;AACxC,SAAO;AACT;AAOO,SAAS,YAAyB;AACvC,SAAO;AACT;AAOO,SAAS,eAA4B;AAC1C,SAAO;AACT;",
+  "names": ["midpoint"]
+}

package/dist/features/viz/lib/symlog-scale-component.d.ts

@@ -0,0 +1,7 @@
+import type { SymlogScaleProps } from "./types.js";
+/**
+ * Provides a named symlog mapping to descendant visualization components.
+ * @param props - Identity, domain, range, and constant. See {@link SymlogScaleProps}.
+ * @returns Descendant content within the scale scope.
+ */
+export declare function SymlogScale(props: SymlogScaleProps): import("@pibbl/core").PibblNode;

package/dist/features/viz/lib/symlog-scale-component.js

@@ -0,0 +1,19 @@
+import { resolveSignalValue, useLayoutBox } from "@pibbl/core";
+import { resolveSymlogScale } from "./symlog-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+function SymlogScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(props.id, "symlog", () => resolveSymlogScale(
+    resolveSignalValue(props.domain),
+    resolveSignalValue(props.range),
+    resolveSignalValue(props.reverse ?? false),
+    width,
+    height,
+    resolveSignalValue(props.constant ?? 1)
+  ), [props.domain, props.range, props.reverse, props.constant, width, height]);
+  return props.children;
+}
+export {
+  SymlogScale
+};
+//# sourceMappingURL=symlog-scale-component.js.map

package/dist/features/viz/lib/symlog-scale-component.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/symlog-scale-component.ts"],
+  "sourcesContent": ["import { resolveSignalValue, useLayoutBox } from \"@pibbl/core\";\nimport type { SymlogScaleProps } from \"./types.js\";\nimport { resolveSymlogScale } from \"./symlog-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\n/**\n * Provides a named symlog mapping to descendant visualization components.\n * @param props - Identity, domain, range, and constant. See {@link SymlogScaleProps}.\n * @returns Descendant content within the scale scope.\n */\nexport function SymlogScale(props: SymlogScaleProps) {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(props.id, \"symlog\", () => resolveSymlogScale(\n    resolveSignalValue(props.domain), resolveSignalValue(props.range),\n    resolveSignalValue(props.reverse ?? false), width, height, resolveSignalValue(props.constant ?? 1),\n  ), [props.domain, props.range, props.reverse, props.constant, width, height]);\n  return props.children;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB,oBAAoB;AAEjD,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AAM1B,SAAS,YAAY,OAAyB;AACnD,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC,mBAAiB,MAAM,IAAI,UAAU,MAAM;AAAA,IACzC,mBAAmB,MAAM,MAAM;AAAA,IAAG,mBAAmB,MAAM,KAAK;AAAA,IAChE,mBAAmB,MAAM,WAAW,KAAK;AAAA,IAAG;AAAA,IAAO;AAAA,IAAQ,mBAAmB,MAAM,YAAY,CAAC;AAAA,EACnG,GAAG,CAAC,MAAM,QAAQ,MAAM,OAAO,MAAM,SAAS,MAAM,UAAU,OAAO,MAAM,CAAC;AAC5E,SAAO,MAAM;AACf;",
+  "names": []
+}

package/dist/features/viz/lib/symlog-scale.d.ts

@@ -0,0 +1,2 @@
+import type { LinearDomain, ResolvedSymlogScale, ScaleRange } from "./types.js";
+export declare function resolveSymlogScale(domain: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, constant: number): ResolvedSymlogScale;

package/dist/features/viz/lib/symlog-scale.js

@@ -0,0 +1,38 @@
+import { resolveLinearScale } from "./linear-scale.js";
+import { linearTicks } from "./numeric-ticks.js";
+function resolveSymlogScale(domain, range, reverse, width, height, constant) {
+  if (typeof constant !== "number" || !Number.isFinite(constant) || constant <= 0)
+    throw new RangeError("SymlogScale constant must be finite and positive.");
+  const original = resolveLinearScale(domain, range, reverse, width, height);
+  const transform = (value) => {
+    if (typeof value !== "number" || !Number.isFinite(value)) throw new RangeError("SymlogScale map input must be finite.");
+    const ratio = Math.abs(value) / constant;
+    return Math.sign(value) * (Number.isFinite(ratio) ? Math.log1p(ratio) : Math.log(Math.abs(value)) - Math.log(constant));
+  };
+  const mapping = resolveLinearScale([transform(domain[0]), transform(domain[1])], original.range, false, width, height);
+  return Object.freeze({
+    ...original,
+    type: "symlog",
+    constant,
+    map(value) {
+      return mapping.map(transform(value));
+    },
+    invert(pixel) {
+      if (mapping.range[0] !== mapping.range[1]) {
+        if (pixel === mapping.range[0]) return original.domain[0];
+        if (pixel === mapping.range[1]) return original.domain[1];
+      }
+      const t = mapping.invert(pixel), magnitude = Math.abs(t);
+      const value = Math.sign(t) * (magnitude < 700 ? constant * Math.expm1(magnitude) : Math.exp(magnitude + Math.log(constant)) - constant);
+      if (!Number.isFinite(value)) throw new RangeError("SymlogScale inverted output must be finite.");
+      return value || 0;
+    },
+    ticks(count = 5) {
+      return linearTicks(original.domain, { count });
+    }
+  });
+}
+export {
+  resolveSymlogScale
+};
+//# sourceMappingURL=symlog-scale.js.map

package/dist/features/viz/lib/symlog-scale.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/symlog-scale.ts"],
+  "sourcesContent": ["import type { LinearDomain, ResolvedSymlogScale, ScaleRange } from \"./types.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nimport { linearTicks } from \"./numeric-ticks.js\";\nexport function resolveSymlogScale(domain: LinearDomain, range: ScaleRange, reverse: boolean, width: number, height: number, constant: number): ResolvedSymlogScale {\n  if (typeof constant !== \"number\" || !Number.isFinite(constant) || constant <= 0)\n    throw new RangeError(\"SymlogScale constant must be finite and positive.\");\n  const original = resolveLinearScale(domain, range, reverse, width, height);\n  const transform = (value: number) => {\n    if (typeof value !== \"number\" || !Number.isFinite(value)) throw new RangeError(\"SymlogScale map input must be finite.\");\n    const ratio = Math.abs(value) / constant;\n    return Math.sign(value) * (Number.isFinite(ratio) ? Math.log1p(ratio) : Math.log(Math.abs(value)) - Math.log(constant));\n  };\n  const mapping = resolveLinearScale([transform(domain[0]), transform(domain[1])], original.range, false, width, height);\n  return Object.freeze({\n    ...original, type: \"symlog\", constant,\n    map(value: number) { return mapping.map(transform(value)); },\n    invert(pixel: number) {\n      if (mapping.range[0] !== mapping.range[1]) {\n        if (pixel === mapping.range[0]) return original.domain[0];\n        if (pixel === mapping.range[1]) return original.domain[1];\n      }\n      const t = mapping.invert(pixel), magnitude = Math.abs(t);\n      const value = Math.sign(t) * (magnitude < 700 ? constant * Math.expm1(magnitude) : Math.exp(magnitude + Math.log(constant)) - constant);\n      if (!Number.isFinite(value)) throw new RangeError(\"SymlogScale inverted output must be finite.\");\n      return value || 0;\n    },\n    ticks(count = 5) { return linearTicks(original.domain, { count }); },\n  });\n}\n"],
+  "mappings": "AACA,SAAS,0BAA0B;AACnC,SAAS,mBAAmB;AACrB,SAAS,mBAAmB,QAAsB,OAAmB,SAAkB,OAAe,QAAgB,UAAuC;AAClK,MAAI,OAAO,aAAa,YAAY,CAAC,OAAO,SAAS,QAAQ,KAAK,YAAY;AAC5E,UAAM,IAAI,WAAW,mDAAmD;AAC1E,QAAM,WAAW,mBAAmB,QAAQ,OAAO,SAAS,OAAO,MAAM;AACzE,QAAM,YAAY,CAAC,UAAkB;AACnC,QAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,OAAM,IAAI,WAAW,uCAAuC;AACtH,UAAM,QAAQ,KAAK,IAAI,KAAK,IAAI;AAChC,WAAO,KAAK,KAAK,KAAK,KAAK,OAAO,SAAS,KAAK,IAAI,KAAK,MAAM,KAAK,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,QAAQ;AAAA,EACvH;AACA,QAAM,UAAU,mBAAmB,CAAC,UAAU,OAAO,CAAC,CAAC,GAAG,UAAU,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,OAAO,OAAO,OAAO,MAAM;AACrH,SAAO,OAAO,OAAO;AAAA,IACnB,GAAG;AAAA,IAAU,MAAM;AAAA,IAAU;AAAA,IAC7B,IAAI,OAAe;AAAE,aAAO,QAAQ,IAAI,UAAU,KAAK,CAAC;AAAA,IAAG;AAAA,IAC3D,OAAO,OAAe;AACpB,UAAI,QAAQ,MAAM,CAAC,MAAM,QAAQ,MAAM,CAAC,GAAG;AACzC,YAAI,UAAU,QAAQ,MAAM,CAAC,EAAG,QAAO,SAAS,OAAO,CAAC;AACxD,YAAI,UAAU,QAAQ,MAAM,CAAC,EAAG,QAAO,SAAS,OAAO,CAAC;AAAA,MAC1D;AACA,YAAM,IAAI,QAAQ,OAAO,KAAK,GAAG,YAAY,KAAK,IAAI,CAAC;AACvD,YAAM,QAAQ,KAAK,KAAK,CAAC,KAAK,YAAY,MAAM,WAAW,KAAK,MAAM,SAAS,IAAI,KAAK,IAAI,YAAY,KAAK,IAAI,QAAQ,CAAC,IAAI;AAC9H,UAAI,CAAC,OAAO,SAAS,KAAK,EAAG,OAAM,IAAI,WAAW,6CAA6C;AAC/F,aAAO,SAAS;AAAA,IAClB;AAAA,IACA,MAAM,QAAQ,GAAG;AAAE,aAAO,YAAY,SAAS,QAAQ,EAAE,MAAM,CAAC;AAAA,IAAG;AAAA,EACrE,CAAC;AACH;",
+  "names": []
+}

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

@@ -0,0 +1,43 @@
+import { type PibblNode, type Signal, type SignalValue } from "@pibbl/core";
+import type { ScaleId } from "./types.js";
+/** One lower-inclusive, upper-exclusive threshold color bucket. @see {@link ResolvedThresholdColorScale} */
+export interface ThresholdColorBand {
+    /** Lower inclusive boundary, omitted for the first bucket. */
+    readonly lower: number | undefined;
+    /** Upper exclusive boundary, omitted for the last bucket. */
+    readonly upper: number | undefined;
+    /** Validated #RRGGBB paint for this bucket. */
+    readonly color: string;
+}
+/** Immutable resolved threshold mapping shared with descendant marks. @see {@link ThresholdColorScaleProps} */
+export interface ResolvedThresholdColorScale {
+    /** Strictly ascending finite authored bucket boundaries. */
+    readonly thresholds: readonly number[];
+    /** One validated color for every bucket. */
+    readonly colors: readonly string[];
+    /** Readable bucket descriptions in authored order. */
+    readonly bands: readonly ThresholdColorBand[];
+    /** Maps a finite numeric value to its containing bucket paint.
+     * @param value - Finite input.
+     * @returns Canonical lowercase #rrggbb color. */
+    readonly map: (value: number) => string;
+}
+/** Authored threshold boundaries, bucket colors, identity, and descendant content. @see {@link ResolvedThresholdColorScale} */
+export interface ThresholdColorScaleProps {
+    /** Stable provider identity. */
+    readonly id: ScaleId;
+    /** Strictly ascending finite boundaries; each equality belongs to the upper bucket. */
+    readonly thresholds: SignalValue<readonly number[]>;
+    /** Exactly one #RRGGBB color per bucket. */
+    readonly colors: SignalValue<readonly string[]>;
+    /** Descendant content using this dedicated color context. */
+    readonly children?: PibblNode;
+}
+/** Provides a lazy, discrete threshold-to-color mapping for descendants.
+ * @param props - Boundaries, colors, identity and descendants. See {@link ThresholdColorScaleProps}.
+ * @returns Descendant content. */
+export declare function ThresholdColorScale(props: ThresholdColorScaleProps): PibblNode;
+/** Reads the matching ancestor threshold color mapping.
+ * @param id - Provider identity. See {@link ScaleId}.
+ * @returns Shared readonly mapping signal. See {@link ResolvedThresholdColorScale}. */
+export declare function useThresholdColorScale(id: ScaleId): Signal<ResolvedThresholdColorScale>;

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

@@ -0,0 +1,59 @@
+import {
+  resolveSignalValue
+} from "@pibbl/core";
+import { provideColor, useColor } from "./color-context.js";
+import { finiteColorValue, hexColor } from "./color-math.js";
+function resolve(props) {
+  const input = resolveSignalValue(props.thresholds);
+  const paint = resolveSignalValue(props.colors);
+  if (!Array.isArray(input) || !Array.isArray(paint))
+    throw new TypeError(
+      "Threshold color scales require threshold and color arrays."
+    );
+  const thresholds = Object.freeze(Array.from(input, finiteColorValue));
+  for (let index = 1; index < thresholds.length; index++)
+    if (!(thresholds[index - 1] < thresholds[index]))
+      throw new RangeError(
+        "Threshold color boundaries must be strictly ascending."
+      );
+  if (paint.length !== thresholds.length + 1)
+    throw new RangeError(
+      "Threshold color scales require one more color than thresholds."
+    );
+  const colors = Object.freeze(Array.from(paint, hexColor));
+  const bands = Object.freeze(
+    colors.map(
+      (color, index) => Object.freeze({
+        lower: index === 0 ? void 0 : thresholds[index - 1],
+        upper: index === thresholds.length ? void 0 : thresholds[index],
+        color
+      })
+    )
+  );
+  return Object.freeze({
+    thresholds,
+    colors,
+    bands,
+    map(value) {
+      finiteColorValue(value);
+      let index = 0;
+      while (index < thresholds.length && value >= thresholds[index]) index++;
+      return colors[index];
+    }
+  });
+}
+function ThresholdColorScale(props) {
+  provideColor(props.id, "threshold", () => resolve(props), [
+    props.thresholds,
+    props.colors
+  ]);
+  return props.children;
+}
+function useThresholdColorScale(id) {
+  return useColor(id, "threshold");
+}
+export {
+  ThresholdColorScale,
+  useThresholdColorScale
+};
+//# sourceMappingURL=threshold-color-scale.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/threshold-color-scale.ts"],
+  "sourcesContent": ["import {\n  resolveSignalValue,\n  type PibblNode,\n  type Signal,\n  type SignalValue,\n} from \"@pibbl/core\";\nimport { provideColor, useColor } from \"./color-context.js\";\nimport { finiteColorValue, hexColor } from \"./color-math.js\";\nimport type { ScaleId } from \"./types.js\";\n\n/** One lower-inclusive, upper-exclusive threshold color bucket. @see {@link ResolvedThresholdColorScale} */\nexport interface ThresholdColorBand {\n  /** Lower inclusive boundary, omitted for the first bucket. */\n  readonly lower: number | undefined;\n  /** Upper exclusive boundary, omitted for the last bucket. */\n  readonly upper: number | undefined;\n  /** Validated #RRGGBB paint for this bucket. */\n  readonly color: string;\n}\n\n/** Immutable resolved threshold mapping shared with descendant marks. @see {@link ThresholdColorScaleProps} */\nexport interface ResolvedThresholdColorScale {\n  /** Strictly ascending finite authored bucket boundaries. */\n  readonly thresholds: readonly number[];\n  /** One validated color for every bucket. */\n  readonly colors: readonly string[];\n  /** Readable bucket descriptions in authored order. */\n  readonly bands: readonly ThresholdColorBand[];\n  /** Maps a finite numeric value to its containing bucket paint.\n   * @param value - Finite input.\n   * @returns Canonical lowercase #rrggbb color. */\n  readonly map: (value: number) => string;\n}\n\n/** Authored threshold boundaries, bucket colors, identity, and descendant content. @see {@link ResolvedThresholdColorScale} */\nexport interface ThresholdColorScaleProps {\n  /** Stable provider identity. */\n  readonly id: ScaleId;\n  /** Strictly ascending finite boundaries; each equality belongs to the upper bucket. */\n  readonly thresholds: SignalValue<readonly number[]>;\n  /** Exactly one #RRGGBB color per bucket. */\n  readonly colors: SignalValue<readonly string[]>;\n  /** Descendant content using this dedicated color context. */\n  readonly children?: PibblNode;\n}\n\nfunction resolve(props: ThresholdColorScaleProps): ResolvedThresholdColorScale {\n  const input = resolveSignalValue(props.thresholds);\n  const paint = resolveSignalValue(props.colors);\n  if (!Array.isArray(input) || !Array.isArray(paint))\n    throw new TypeError(\n      \"Threshold color scales require threshold and color arrays.\",\n    );\n  const thresholds = Object.freeze(Array.from(input, finiteColorValue));\n  for (let index = 1; index < thresholds.length; index++)\n    if (!(thresholds[index - 1] < thresholds[index]))\n      throw new RangeError(\n        \"Threshold color boundaries must be strictly ascending.\",\n      );\n  if (paint.length !== thresholds.length + 1)\n    throw new RangeError(\n      \"Threshold color scales require one more color than thresholds.\",\n    );\n  const colors = Object.freeze(Array.from(paint, hexColor));\n  const bands = Object.freeze(\n    colors.map((color, index) =>\n      Object.freeze({\n        lower: index === 0 ? undefined : thresholds[index - 1],\n        upper: index === thresholds.length ? undefined : thresholds[index],\n        color,\n      }),\n    ),\n  );\n  return Object.freeze({\n    thresholds,\n    colors,\n    bands,\n    map(value: number) {\n      finiteColorValue(value);\n      let index = 0;\n      while (index < thresholds.length && value >= thresholds[index]) index++;\n      return colors[index];\n    },\n  });\n}\n\n/** Provides a lazy, discrete threshold-to-color mapping for descendants.\n * @param props - Boundaries, colors, identity and descendants. See {@link ThresholdColorScaleProps}.\n * @returns Descendant content. */\nexport function ThresholdColorScale(props: ThresholdColorScaleProps) {\n  provideColor(props.id, \"threshold\", () => resolve(props), [\n    props.thresholds,\n    props.colors,\n  ]);\n  return props.children;\n}\n\n/** Reads the matching ancestor threshold color mapping.\n * @param id - Provider identity. See {@link ScaleId}.\n * @returns Shared readonly mapping signal. See {@link ResolvedThresholdColorScale}. */\nexport function useThresholdColorScale(\n  id: ScaleId,\n): Signal<ResolvedThresholdColorScale> {\n  return useColor(id, \"threshold\");\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAIK;AACP,SAAS,cAAc,gBAAgB;AACvC,SAAS,kBAAkB,gBAAgB;AAuC3C,SAAS,QAAQ,OAA8D;AAC7E,QAAM,QAAQ,mBAAmB,MAAM,UAAU;AACjD,QAAM,QAAQ,mBAAmB,MAAM,MAAM;AAC7C,MAAI,CAAC,MAAM,QAAQ,KAAK,KAAK,CAAC,MAAM,QAAQ,KAAK;AAC/C,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,QAAM,aAAa,OAAO,OAAO,MAAM,KAAK,OAAO,gBAAgB,CAAC;AACpE,WAAS,QAAQ,GAAG,QAAQ,WAAW,QAAQ;AAC7C,QAAI,EAAE,WAAW,QAAQ,CAAC,IAAI,WAAW,KAAK;AAC5C,YAAM,IAAI;AAAA,QACR;AAAA,MACF;AACJ,MAAI,MAAM,WAAW,WAAW,SAAS;AACvC,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACF,QAAM,SAAS,OAAO,OAAO,MAAM,KAAK,OAAO,QAAQ,CAAC;AACxD,QAAM,QAAQ,OAAO;AAAA,IACnB,OAAO;AAAA,MAAI,CAAC,OAAO,UACjB,OAAO,OAAO;AAAA,QACZ,OAAO,UAAU,IAAI,SAAY,WAAW,QAAQ,CAAC;AAAA,QACrD,OAAO,UAAU,WAAW,SAAS,SAAY,WAAW,KAAK;AAAA,QACjE;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACA,SAAO,OAAO,OAAO;AAAA,IACnB;AAAA,IACA;AAAA,IACA;AAAA,IACA,IAAI,OAAe;AACjB,uBAAiB,KAAK;AACtB,UAAI,QAAQ;AACZ,aAAO,QAAQ,WAAW,UAAU,SAAS,WAAW,KAAK,EAAG;AAChE,aAAO,OAAO,KAAK;AAAA,IACrB;AAAA,EACF,CAAC;AACH;AAKO,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;AAKO,SAAS,uBACd,IACqC;AACrC,SAAO,SAAS,IAAI,WAAW;AACjC;",
+  "names": []
+}

package/dist/features/viz/lib/trading-time-mapping.d.ts

@@ -0,0 +1,32 @@
+/** Input used to resolve gapless trading-time coordinates. */
+export interface TradingTimeMappingInput {
+    /** Strictly increasing, unique UTC millisecond observations. */
+    readonly timestamps: readonly number[];
+    /** Visible logical slot endpoints; fractional values reserve viewport whitespace. */
+    readonly logicalRange: readonly [number, number];
+    /** Physical local-coordinate endpoints. */
+    readonly range: readonly [number, number];
+}
+/** Immutable conversion operations for one owned trading-time observation list. */
+export interface TradingTimeMapping {
+    /** Maps an exact supplied timestamp to its physical local coordinate. */
+    mapTime(time: number): number;
+    /** Finds an exact supplied timestamp's consecutive logical slot. */
+    slotAtTime(time: number): number | undefined;
+    /** Finds the supplied timestamp at an exact integer logical slot. */
+    timeAtSlot(slot: number): number | undefined;
+    /** Selects the nearest supplied timestamp to a physical coordinate. */
+    nearestTimeAtPosition(position: number): number | undefined;
+    /** Inverts a physical coordinate to a possibly fractional logical slot. */
+    slotAtPosition(position: number): number;
+}
+/**
+ * Creates pure mappings between exact supplied UTC observations, logical slots, and local positions.
+ *
+ * The mapping owns a frozen copy of timestamps. It creates no timestamps for gaps: exact mapping
+ * rejects unknown values, while inverse position mapping can intentionally produce fractional slots.
+ *
+ * @param input - Observation timestamps plus logical and physical viewport endpoints.
+ * @returns Immutable mapping operations with logarithmic timestamp lookup and constant-time slot lookup.
+ */
+export declare function createTradingTimeMapping(input: TradingTimeMappingInput): TradingTimeMapping;

package/dist/features/viz/lib/trading-time-mapping.js

@@ -0,0 +1,89 @@
+const DATE_LIMIT = 864e13;
+function finite(value, name) {
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new RangeError(`${name} must be finite.`);
+  return value;
+}
+function endpointPair(value, name) {
+  const first = finite(value[0], `${name}[0]`);
+  const second = finite(value[1], `${name}[1]`);
+  if (first === second) throw new RangeError(`${name} endpoints must differ.`);
+  return Object.freeze([first, second]);
+}
+function timestamp(value, index) {
+  if (!Number.isSafeInteger(value) || Math.abs(value) > DATE_LIMIT)
+    throw new RangeError(
+      `timestamps[${index}] must be safe integers within Date range UTC milliseconds.`
+    );
+  return value;
+}
+function indexOf(timestamps, time) {
+  let first = 0;
+  let last = timestamps.length - 1;
+  while (first <= last) {
+    const middle = first + Math.floor((last - first) / 2);
+    const candidate = timestamps[middle];
+    if (candidate === time) return middle;
+    if (candidate < time) first = middle + 1;
+    else last = middle - 1;
+  }
+  return -1;
+}
+function createTradingTimeMapping(input) {
+  const timestamps = input.timestamps.map(
+    (value, index) => timestamp(value, index)
+  );
+  for (let index = 1; index < timestamps.length; index++) {
+    if (timestamps[index - 1] >= timestamps[index])
+      throw new RangeError(
+        "timestamps must be strictly increasing and unique."
+      );
+  }
+  Object.freeze(timestamps);
+  const logicalRange = endpointPair(input.logicalRange, "logicalRange");
+  const range = endpointPair(input.range, "range");
+  const slotAtPosition = (position) => {
+    finite(position, "position");
+    return logicalRange[0] + (position - range[0]) * (logicalRange[1] - logicalRange[0]) / (range[1] - range[0]);
+  };
+  const positionAtSlot = (slot) => range[0] + (slot - logicalRange[0]) * (range[1] - range[0]) / (logicalRange[1] - logicalRange[0]);
+  const slotAtTime = (time) => {
+    if (!Number.isSafeInteger(time) || Math.abs(time) > DATE_LIMIT)
+      return void 0;
+    const index = indexOf(timestamps, time);
+    return index < 0 ? void 0 : index;
+  };
+  return Object.freeze({
+    mapTime(time) {
+      const slot = slotAtTime(time);
+      if (slot === void 0)
+        throw new RangeError(
+          "TradingTimeScale cannot map an unknown timestamp."
+        );
+      return positionAtSlot(slot);
+    },
+    slotAtTime,
+    timeAtSlot(slot) {
+      if (!Number.isInteger(slot)) return void 0;
+      return timestamps[slot];
+    },
+    nearestTimeAtPosition(position) {
+      if (timestamps.length === 0) return void 0;
+      const slot = slotAtPosition(position);
+      const earlier = Math.floor(slot);
+      const index = Math.max(
+        0,
+        Math.min(
+          timestamps.length - 1,
+          earlier + (slot - earlier > 0.5 ? 1 : 0)
+        )
+      );
+      return timestamps[index];
+    },
+    slotAtPosition
+  });
+}
+export {
+  createTradingTimeMapping
+};
+//# sourceMappingURL=trading-time-mapping.js.map

package/dist/features/viz/lib/trading-time-mapping.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/trading-time-mapping.ts"],
+  "sourcesContent": ["const DATE_LIMIT = 8_640_000_000_000_000;\n\n/** Input used to resolve gapless trading-time coordinates. */\nexport interface TradingTimeMappingInput {\n  /** Strictly increasing, unique UTC millisecond observations. */\n  readonly timestamps: readonly number[];\n  /** Visible logical slot endpoints; fractional values reserve viewport whitespace. */\n  readonly logicalRange: readonly [number, number];\n  /** Physical local-coordinate endpoints. */\n  readonly range: readonly [number, number];\n}\n\n/** Immutable conversion operations for one owned trading-time observation list. */\nexport interface TradingTimeMapping {\n  /** Maps an exact supplied timestamp to its physical local coordinate. */\n  mapTime(time: number): number;\n  /** Finds an exact supplied timestamp's consecutive logical slot. */\n  slotAtTime(time: number): number | undefined;\n  /** Finds the supplied timestamp at an exact integer logical slot. */\n  timeAtSlot(slot: number): number | undefined;\n  /** Selects the nearest supplied timestamp to a physical coordinate. */\n  nearestTimeAtPosition(position: number): number | undefined;\n  /** Inverts a physical coordinate to a possibly fractional logical slot. */\n  slotAtPosition(position: number): number;\n}\n\nfunction finite(value: number, name: string): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value))\n    throw new RangeError(`${name} must be finite.`);\n  return value;\n}\n\nfunction endpointPair(\n  value: readonly [number, number],\n  name: string,\n): readonly [number, number] {\n  const first = finite(value[0], `${name}[0]`);\n  const second = finite(value[1], `${name}[1]`);\n  if (first === second) throw new RangeError(`${name} endpoints must differ.`);\n  return Object.freeze([first, second]);\n}\n\nfunction timestamp(value: number, index: number): number {\n  if (!Number.isSafeInteger(value) || Math.abs(value) > DATE_LIMIT)\n    throw new RangeError(\n      `timestamps[${index}] must be safe integers within Date range UTC milliseconds.`,\n    );\n  return value;\n}\n\nfunction indexOf(timestamps: readonly number[], time: number): number {\n  let first = 0;\n  let last = timestamps.length - 1;\n  while (first <= last) {\n    const middle = first + Math.floor((last - first) / 2);\n    const candidate = timestamps[middle]!;\n    if (candidate === time) return middle;\n    if (candidate < time) first = middle + 1;\n    else last = middle - 1;\n  }\n  return -1;\n}\n\n/**\n * Creates pure mappings between exact supplied UTC observations, logical slots, and local positions.\n *\n * The mapping owns a frozen copy of timestamps. It creates no timestamps for gaps: exact mapping\n * rejects unknown values, while inverse position mapping can intentionally produce fractional slots.\n *\n * @param input - Observation timestamps plus logical and physical viewport endpoints.\n * @returns Immutable mapping operations with logarithmic timestamp lookup and constant-time slot lookup.\n */\nexport function createTradingTimeMapping(\n  input: TradingTimeMappingInput,\n): TradingTimeMapping {\n  const timestamps = input.timestamps.map((value, index) =>\n    timestamp(value, index),\n  );\n  for (let index = 1; index < timestamps.length; index++) {\n    if (timestamps[index - 1]! >= timestamps[index]!)\n      throw new RangeError(\n        \"timestamps must be strictly increasing and unique.\",\n      );\n  }\n  Object.freeze(timestamps);\n  const logicalRange = endpointPair(input.logicalRange, \"logicalRange\");\n  const range = endpointPair(input.range, \"range\");\n  const slotAtPosition = (position: number): number => {\n    finite(position, \"position\");\n    return (\n      logicalRange[0] +\n      ((position - range[0]) * (logicalRange[1] - logicalRange[0])) /\n        (range[1] - range[0])\n    );\n  };\n  const positionAtSlot = (slot: number): number =>\n    range[0] +\n    ((slot - logicalRange[0]) * (range[1] - range[0])) /\n      (logicalRange[1] - logicalRange[0]);\n  const slotAtTime = (time: number): number | undefined => {\n    if (!Number.isSafeInteger(time) || Math.abs(time) > DATE_LIMIT)\n      return undefined;\n    const index = indexOf(timestamps, time);\n    return index < 0 ? undefined : index;\n  };\n  return Object.freeze({\n    mapTime(time: number): number {\n      const slot = slotAtTime(time);\n      if (slot === undefined)\n        throw new RangeError(\n          \"TradingTimeScale cannot map an unknown timestamp.\",\n        );\n      return positionAtSlot(slot);\n    },\n    slotAtTime,\n    timeAtSlot(slot: number): number | undefined {\n      if (!Number.isInteger(slot)) return undefined;\n      return timestamps[slot];\n    },\n    nearestTimeAtPosition(position: number): number | undefined {\n      if (timestamps.length === 0) return undefined;\n      const slot = slotAtPosition(position);\n      const earlier = Math.floor(slot);\n      const index = Math.max(\n        0,\n        Math.min(\n          timestamps.length - 1,\n          earlier + (slot - earlier > 0.5 ? 1 : 0),\n        ),\n      );\n      return timestamps[index];\n    },\n    slotAtPosition,\n  });\n}\n"],
+  "mappings": "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",
+  "names": []
+}