@pibbl/core 0.0.2 → 0.0.3-alpha.109.1

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/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": []
+}

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

@@ -0,0 +1,83 @@
+import { type SignalValue, type PibblNode, type Signal } from "@pibbl/core";
+import type { ScaleId, ScaleRange, ScaleLayoutStyle } from "./types.js";
+import type { SignalStyle } from "@pibbl/core/internal";
+/** Controlled gapless observation slots; UTCScale retains elapsed-time semantics.
+ * @see {@link TradingTimeScale}
+ */
+export interface TradingTimeScaleProps {
+    /** Ancestor scale identity. */ readonly id: ScaleId;
+    /** Strictly increasing, unique UTC-millisecond observations; copied by the mapping. */ readonly timestamps: SignalValue<readonly number[]>;
+    /** Visible logical slot endpoints, possibly fractional/reversed; default covers supplied slots. */ readonly logicalRange?: SignalValue<readonly [number, number]>;
+    /** Output in local logical units or the receiving allocation's width/height. */ readonly range: SignalValue<ScaleRange>;
+    /** Reverses physical output without reordering supplied observations. */ readonly reverse?: SignalValue<boolean>;
+    /** Receiving scale frame allocation and layout participation. */ readonly style?: SignalValue<SignalStyle<ScaleLayoutStyle>>;
+    /** Descendant visualization composition. */ readonly children?: PibblNode;
+}
+/** Dedicated exact-time/slot mapping; no interpolated UTC timestamps are fabricated.
+ * @see {@link TradingTimeScale}
+ */
+export interface ResolvedTradingTimeScale {
+    /** Describes this resolved mapping. */ readonly type: "trading-time";
+    /** Owned supplied timestamps in ascending order, also used as the data domain. */ readonly timestamps: readonly number[];
+    /** Owned supplied timestamp domain, not logical slot endpoints. */ readonly domain: readonly number[];
+    /** Controlled viewport endpoints in logical slot units. */ readonly logicalRange: readonly [
+        number,
+        number
+    ];
+    /** Output local-logical endpoints. */ readonly range: readonly [
+        number,
+        number
+    ];
+    /** Receiving allocation in local logical units. */ readonly frame: Readonly<{
+        /** Local allocation x. */ x: number;
+        /** Local allocation y. */ y: number;
+        /** Local width. */ width: number;
+        /** Local height. */ height: number;
+    }>;
+    /** Maps an exact supplied UTC timestamp; unknown timestamps throw.
+     * @param time - Supplied UTC milliseconds.
+     * @returns Series-local coordinate.
+     */ map(time: number): number;
+    /** Maps a possibly fractional logical slot, including viewport whitespace.
+     * @param slot - Logical observation slot.
+     * @returns Series-local coordinate.
+     */ mapSlot(slot: number): number;
+    /** Exact timestamp lookup.
+     * @param time - UTC milliseconds.
+     * @returns Supplied slot index, or undefined.
+     */ slotAtTime(time: number): number | undefined;
+    /** Exact integer slot lookup.
+     * @param slot - Integer logical observation slot.
+     * @returns Supplied timestamp, or undefined.
+     */ timeAtSlot(slot: number): number | undefined;
+    /** Inverts local geometry to fractional slots.
+     * @param position - Series-local logical coordinate.
+     * @returns Fractional logical slot.
+     */ slotAtPosition(position: number): number;
+    /** Selects a supplied timestamp; ties choose earlier, outside positions clamp.
+     * @param position - Series-local logical coordinate.
+     * @returns Supplied UTC milliseconds, or undefined for empty input.
+     */ nearestTimeAtPosition(position: number): number | undefined;
+    /** Chooses at most count visible supplied observations as date ticks.
+     * @param count - Integer maximum from zero through 100, default five.
+     * @returns Original UTC timestamps in physical axis order.
+     */ ticks(count?: number): readonly number[];
+    /** Formats supplied or finite valid UTC timestamps without inferring sessions.
+     * @param time - UTC milliseconds in Date range.
+     * @returns ISO UTC timestamp.
+     */ formatTick(time: number): string;
+}
+/**
+ * Reads a stable dedicated ancestor trading-time signal.
+ * @param id - Ancestor TradingTimeScale identity.
+ * @returns Readonly mapping with explicit timestamp and logical-slot operations.
+ * @see {@link TradingTimeScale}
+ */
+export declare function useTradingTimeScale(id: ScaleId): Signal<ResolvedTradingTimeScale>;
+/**
+ * Provides gapless positions for ordered supplied observations, leaving application-owned viewport control explicit.
+ * @param props - Timestamps, optional logical viewport, output range and children.
+ * @returns Descendant composition in the named mapping scope.
+ * @see {@link TradingTimeScaleProps}
+ */
+export declare function TradingTimeScale(props: TradingTimeScaleProps): PibblNode;

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

@@ -0,0 +1,96 @@
+import {
+  resolveSignalValue,
+  useLayoutBox
+} from "@pibbl/core";
+import { createTradingTimeMapping } from "./trading-time-mapping.js";
+import { resolveLinearScale } from "./linear-scale.js";
+import { useScaleProvider } from "./scale-provider.js";
+import { scaleView } from "./scale-view.js";
+const views = /* @__PURE__ */ new WeakMap();
+function useTradingTimeScale(id) {
+  return scaleView(
+    views,
+    id,
+    "useTradingTimeScale",
+    (kind) => kind === "trading-time"
+  );
+}
+function TradingTimeScale(props) {
+  const { width, height } = useLayoutBox();
+  useScaleProvider(
+    props.id,
+    "trading-time",
+    () => {
+      const timestamps = Object.freeze([
+        ...resolveSignalValue(props.timestamps)
+      ]);
+      const logicalRange = Object.freeze([
+        ...props.logicalRange ? resolveSignalValue(props.logicalRange) : [-0.5, Math.max(0.5, timestamps.length - 0.5)]
+      ]);
+      const linear = resolveLinearScale(
+        logicalRange,
+        resolveSignalValue(props.range),
+        resolveSignalValue(props.reverse ?? false),
+        width,
+        height
+      );
+      const mapping = createTradingTimeMapping({
+        timestamps,
+        logicalRange,
+        range: linear.range
+      });
+      return Object.freeze({
+        type: "trading-time",
+        timestamps,
+        domain: timestamps,
+        logicalRange,
+        range: linear.range,
+        frame: linear.frame,
+        map: mapping.mapTime,
+        mapSlot: linear.map,
+        slotAtTime: mapping.slotAtTime,
+        timeAtSlot: mapping.timeAtSlot,
+        slotAtPosition: mapping.slotAtPosition,
+        nearestTimeAtPosition: mapping.nearestTimeAtPosition,
+        ticks(count = 5) {
+          if (!Number.isInteger(count) || count < 0 || count > 100)
+            throw new RangeError(
+              "TradingTime ticks count must be an integer 0\u2013100."
+            );
+          const lo = Math.max(0, Math.ceil(Math.min(...logicalRange))), hi = Math.min(
+            timestamps.length - 1,
+            Math.floor(Math.max(...logicalRange))
+          ), n = Math.max(0, hi - lo + 1), m = Math.min(n, count);
+          const result = Array.from(
+            { length: m },
+            (_, i) => timestamps[lo + (m === 1 ? 0 : Math.round(i * (n - 1) / (m - 1)))]
+          );
+          return Object.freeze(
+            logicalRange[0] > logicalRange[1] ? result.reverse() : result
+          );
+        },
+        formatTick(time) {
+          if (!Number.isFinite(time) || Math.abs(time) > 864e13)
+            throw new RangeError(
+              "TradingTime format requires UTC milliseconds within Date range."
+            );
+          return new Date(time).toISOString();
+        }
+      });
+    },
+    [
+      props.timestamps,
+      props.logicalRange,
+      props.range,
+      props.reverse,
+      width,
+      height
+    ]
+  );
+  return props.children;
+}
+export {
+  TradingTimeScale,
+  useTradingTimeScale
+};
+//# sourceMappingURL=trading-time-scale.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/features/viz/lib/trading-time-scale.ts"],
+  "sourcesContent": ["import {\n  resolveSignalValue,\n  useLayoutBox,\n  type SignalValue,\n  type PibblNode,\n  type Signal,\n} from \"@pibbl/core\";\nimport type {\n  ScaleId,\n  ScaleRange,\n  ScaleLayoutStyle,\n  ResolvedScale,\n} from \"./types.js\";\nimport type { SignalStyle } from \"@pibbl/core/internal\";\nimport { createTradingTimeMapping } from \"./trading-time-mapping.js\";\nimport { resolveLinearScale } from \"./linear-scale.js\";\nimport { useScaleProvider } from \"./scale-provider.js\";\nimport { scaleView } from \"./scale-view.js\";\n\n/** Controlled gapless observation slots; UTCScale retains elapsed-time semantics.\n * @see {@link TradingTimeScale}\n */\nexport interface TradingTimeScaleProps {\n  /** Ancestor scale identity. */ readonly id: ScaleId;\n  /** Strictly increasing, unique UTC-millisecond observations; copied by the mapping. */ readonly timestamps: SignalValue<\n    readonly number[]\n  >;\n  /** Visible logical slot endpoints, possibly fractional/reversed; default covers supplied slots. */ readonly logicalRange?: SignalValue<\n    readonly [number, number]\n  >;\n  /** Output in local logical units or the receiving allocation's width/height. */ readonly range: SignalValue<ScaleRange>;\n  /** Reverses physical output without reordering supplied observations. */ readonly reverse?: SignalValue<boolean>;\n  /** Receiving scale frame allocation and layout participation. */ readonly style?: SignalValue<\n    SignalStyle<ScaleLayoutStyle>\n  >;\n  /** Descendant visualization composition. */ readonly children?: PibblNode;\n}\n/** Dedicated exact-time/slot mapping; no interpolated UTC timestamps are fabricated.\n * @see {@link TradingTimeScale}\n */\nexport interface ResolvedTradingTimeScale {\n  /** Describes this resolved mapping. */ readonly type: \"trading-time\";\n  /** Owned supplied timestamps in ascending order, also used as the data domain. */ readonly timestamps: readonly number[];\n  /** Owned supplied timestamp domain, not logical slot endpoints. */ readonly domain: readonly number[];\n  /** Controlled viewport endpoints in logical slot units. */ readonly logicalRange: readonly [\n    number,\n    number,\n  ];\n  /** Output local-logical endpoints. */ readonly range: readonly [\n    number,\n    number,\n  ];\n  /** Receiving allocation in local logical units. */ readonly frame: Readonly<{\n    /** Local allocation x. */ x: number;\n    /** Local allocation y. */ y: number;\n    /** Local width. */ width: number;\n    /** Local height. */ height: number;\n  }>;\n  /** Maps an exact supplied UTC timestamp; unknown timestamps throw.\n   * @param time - Supplied UTC milliseconds.\n   * @returns Series-local coordinate.\n   */ map(time: number): number;\n  /** Maps a possibly fractional logical slot, including viewport whitespace.\n   * @param slot - Logical observation slot.\n   * @returns Series-local coordinate.\n   */ mapSlot(slot: number): number;\n  /** Exact timestamp lookup.\n   * @param time - UTC milliseconds.\n   * @returns Supplied slot index, or undefined.\n   */ slotAtTime(time: number): number | undefined;\n  /** Exact integer slot lookup.\n   * @param slot - Integer logical observation slot.\n   * @returns Supplied timestamp, or undefined.\n   */ timeAtSlot(slot: number): number | undefined;\n  /** Inverts local geometry to fractional slots.\n   * @param position - Series-local logical coordinate.\n   * @returns Fractional logical slot.\n   */ slotAtPosition(position: number): number;\n  /** Selects a supplied timestamp; ties choose earlier, outside positions clamp.\n   * @param position - Series-local logical coordinate.\n   * @returns Supplied UTC milliseconds, or undefined for empty input.\n   */ nearestTimeAtPosition(position: number): number | undefined;\n  /** Chooses at most count visible supplied observations as date ticks.\n   * @param count - Integer maximum from zero through 100, default five.\n   * @returns Original UTC timestamps in physical axis order.\n   */ ticks(count?: number): readonly number[];\n  /** Formats supplied or finite valid UTC timestamps without inferring sessions.\n   * @param time - UTC milliseconds in Date range.\n   * @returns ISO UTC timestamp.\n   */ formatTick(time: number): string;\n}\nconst views = new WeakMap<\n  Signal<ResolvedScale>,\n  Signal<ResolvedTradingTimeScale>\n>();\n/**\n * Reads a stable dedicated ancestor trading-time signal.\n * @param id - Ancestor TradingTimeScale identity.\n * @returns Readonly mapping with explicit timestamp and logical-slot operations.\n * @see {@link TradingTimeScale}\n */\nexport function useTradingTimeScale(\n  id: ScaleId,\n): Signal<ResolvedTradingTimeScale> {\n  return scaleView(\n    views,\n    id,\n    \"useTradingTimeScale\",\n    (kind) => kind === \"trading-time\",\n  );\n}\n/**\n * Provides gapless positions for ordered supplied observations, leaving application-owned viewport control explicit.\n * @param props - Timestamps, optional logical viewport, output range and children.\n * @returns Descendant composition in the named mapping scope.\n * @see {@link TradingTimeScaleProps}\n */\nexport function TradingTimeScale(props: TradingTimeScaleProps): PibblNode {\n  const { width, height } = useLayoutBox();\n  useScaleProvider(\n    props.id,\n    \"trading-time\",\n    () => {\n      const timestamps = Object.freeze([\n        ...resolveSignalValue(props.timestamps),\n      ]);\n      const logicalRange = Object.freeze([\n        ...(props.logicalRange\n          ? resolveSignalValue(props.logicalRange)\n          : [-0.5, Math.max(0.5, timestamps.length - 0.5)]),\n      ]) as readonly [number, number];\n      const linear = resolveLinearScale(\n        logicalRange,\n        resolveSignalValue(props.range),\n        resolveSignalValue(props.reverse ?? false),\n        width,\n        height,\n      );\n      const mapping = createTradingTimeMapping({\n        timestamps,\n        logicalRange,\n        range: linear.range,\n      });\n      return Object.freeze({\n        type: \"trading-time\" as const,\n        timestamps,\n        domain: timestamps,\n        logicalRange,\n        range: linear.range,\n        frame: linear.frame,\n        map: mapping.mapTime,\n        mapSlot: linear.map,\n        slotAtTime: mapping.slotAtTime,\n        timeAtSlot: mapping.timeAtSlot,\n        slotAtPosition: mapping.slotAtPosition,\n        nearestTimeAtPosition: mapping.nearestTimeAtPosition,\n        ticks(count = 5) {\n          if (!Number.isInteger(count) || count < 0 || count > 100)\n            throw new RangeError(\n              \"TradingTime ticks count must be an integer 0\u2013100.\",\n            );\n          const lo = Math.max(0, Math.ceil(Math.min(...logicalRange))),\n            hi = Math.min(\n              timestamps.length - 1,\n              Math.floor(Math.max(...logicalRange)),\n            ),\n            n = Math.max(0, hi - lo + 1),\n            m = Math.min(n, count);\n          const result = Array.from(\n            { length: m },\n            (_, i) =>\n              timestamps[\n                lo + (m === 1 ? 0 : Math.round((i * (n - 1)) / (m - 1)))\n              ]!,\n          );\n          return Object.freeze(\n            logicalRange[0] > logicalRange[1] ? result.reverse() : result,\n          );\n        },\n        formatTick(time: number) {\n          if (!Number.isFinite(time) || Math.abs(time) > 8_640_000_000_000_000)\n            throw new RangeError(\n              \"TradingTime format requires UTC milliseconds within Date range.\",\n            );\n          return new Date(time).toISOString();\n        },\n      });\n    },\n    [\n      props.timestamps,\n      props.logicalRange,\n      props.range,\n      props.reverse,\n      width,\n      height,\n    ],\n  );\n  return props.children;\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,OAIK;AAQP,SAAS,gCAAgC;AACzC,SAAS,0BAA0B;AACnC,SAAS,wBAAwB;AACjC,SAAS,iBAAiB;AA0E1B,MAAM,QAAQ,oBAAI,QAGhB;AAOK,SAAS,oBACd,IACkC;AAClC,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,CAAC,SAAS,SAAS;AAAA,EACrB;AACF;AAOO,SAAS,iBAAiB,OAAyC;AACxE,QAAM,EAAE,OAAO,OAAO,IAAI,aAAa;AACvC;AAAA,IACE,MAAM;AAAA,IACN;AAAA,IACA,MAAM;AACJ,YAAM,aAAa,OAAO,OAAO;AAAA,QAC/B,GAAG,mBAAmB,MAAM,UAAU;AAAA,MACxC,CAAC;AACD,YAAM,eAAe,OAAO,OAAO;AAAA,QACjC,GAAI,MAAM,eACN,mBAAmB,MAAM,YAAY,IACrC,CAAC,MAAM,KAAK,IAAI,KAAK,WAAW,SAAS,GAAG,CAAC;AAAA,MACnD,CAAC;AACD,YAAM,SAAS;AAAA,QACb;AAAA,QACA,mBAAmB,MAAM,KAAK;AAAA,QAC9B,mBAAmB,MAAM,WAAW,KAAK;AAAA,QACzC;AAAA,QACA;AAAA,MACF;AACA,YAAM,UAAU,yBAAyB;AAAA,QACvC;AAAA,QACA;AAAA,QACA,OAAO,OAAO;AAAA,MAChB,CAAC;AACD,aAAO,OAAO,OAAO;AAAA,QACnB,MAAM;AAAA,QACN;AAAA,QACA,QAAQ;AAAA,QACR;AAAA,QACA,OAAO,OAAO;AAAA,QACd,OAAO,OAAO;AAAA,QACd,KAAK,QAAQ;AAAA,QACb,SAAS,OAAO;AAAA,QAChB,YAAY,QAAQ;AAAA,QACpB,YAAY,QAAQ;AAAA,QACpB,gBAAgB,QAAQ;AAAA,QACxB,uBAAuB,QAAQ;AAAA,QAC/B,MAAM,QAAQ,GAAG;AACf,cAAI,CAAC,OAAO,UAAU,KAAK,KAAK,QAAQ,KAAK,QAAQ;AACnD,kBAAM,IAAI;AAAA,cACR;AAAA,YACF;AACF,gBAAM,KAAK,KAAK,IAAI,GAAG,KAAK,KAAK,KAAK,IAAI,GAAG,YAAY,CAAC,CAAC,GACzD,KAAK,KAAK;AAAA,YACR,WAAW,SAAS;AAAA,YACpB,KAAK,MAAM,KAAK,IAAI,GAAG,YAAY,CAAC;AAAA,UACtC,GACA,IAAI,KAAK,IAAI,GAAG,KAAK,KAAK,CAAC,GAC3B,IAAI,KAAK,IAAI,GAAG,KAAK;AACvB,gBAAM,SAAS,MAAM;AAAA,YACnB,EAAE,QAAQ,EAAE;AAAA,YACZ,CAAC,GAAG,MACF,WACE,MAAM,MAAM,IAAI,IAAI,KAAK,MAAO,KAAK,IAAI,MAAO,IAAI,EAAE,EACxD;AAAA,UACJ;AACA,iBAAO,OAAO;AAAA,YACZ,aAAa,CAAC,IAAI,aAAa,CAAC,IAAI,OAAO,QAAQ,IAAI;AAAA,UACzD;AAAA,QACF;AAAA,QACA,WAAW,MAAc;AACvB,cAAI,CAAC,OAAO,SAAS,IAAI,KAAK,KAAK,IAAI,IAAI,IAAI;AAC7C,kBAAM,IAAI;AAAA,cACR;AAAA,YACF;AACF,iBAAO,IAAI,KAAK,IAAI,EAAE,YAAY;AAAA,QACpC;AAAA,MACF,CAAC;AAAA,IACH;AAAA,IACA;AAAA,MACE,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM;AAAA,MACN,MAAM;AAAA,MACN;AAAA,MACA;AAAA,IACF;AAAA,EACF;AACA,SAAO,MAAM;AACf;",
+  "names": []
+}