@ledgerhq/lumen-ui-react 0.1.56 → 0.1.57

package/dist/lib/Components/visualization/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../../src/lib/Components/visualization/config.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEhD;;;;GAIG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;8BAwBqC,UAAU;;;;;;;;;;;;;;;;;;;;;;;QA2BnE,yDAAyD;;;;;;;;;;;;;;QAezD,oEAAoE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8CpE,2EAA2E;;;;;QAE3E,wEAAwE;;;;YAItE,8EAA8E;;YAE9E;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,CAAC"}

package/dist/lib/Components/visualization/config.js

@@ -0,0 +1,156 @@
+import { cssVar as e } from "../../../libs/design-core/dist/lib/cssVar/cssVar.js";
+const t = {
+  color: {
+    stroke: e("var(--border-muted)"),
+    gridLine: e("var(--border-muted-subtle-transparent)"),
+    mutedLine: e("var(--border-muted-subtle)"),
+    markOutline: e("var(--background-canvas)"),
+    textMuted: e("var(--text-muted)"),
+    text: e("var(--text-base)")
+  },
+  strokeWidth: {
+    hairline: e("var(--stroke-1)"),
+    line: e("var(--stroke-2)")
+  },
+  font: {
+    family: e("var(--font-family-font)"),
+    labelSize: e("var(--font-style-body-4-size)"),
+    labelWeightMedium: e("var(--font-style-body-4-weight-medium)"),
+    bodySize: e("var(--font-style-body-3-size)"),
+    bodyWeightMedium: e("var(--font-style-body-3-weight-medium)"),
+    bodyWeightSemiBold: e("var(--font-style-body-3-weight-semi-bold)")
+  },
+  root: {
+    defaultHeight: 240,
+    zeroPadding: { top: 0, right: 0, bottom: 0, left: 0 }
+  },
+  axis: {
+    defaultHeight: 28,
+    defaultWidth: 40,
+    tickMarkSize: 4,
+    tickLabelOffset: 6,
+    gridDashArray: "3 3",
+    lineColor: e("var(--border-muted)")
+  },
+  line: {
+    areaGradientOpacity: 0.25
+  },
+  referenceLine: {
+    dashArray: "0.1 6"
+  },
+  point: {
+    defaultSize: 10,
+    arrowWidth: 6,
+    arrowHeight: 4,
+    labelGap: 4,
+    labelFontSize: 10,
+    defaultColor: e("var(--background-muted-strong)"),
+    /** Character width as a ratio of the label font size. */
+    labelCharWidthRatio: 0.6
+  },
+  scrubber: {
+    beaconRadius: 5,
+    beaconStrokeWidth: 2,
+    lineColor: e("var(--border-base)"),
+    overlayColor: e("var(--background-base)"),
+    overlayOffset: 2,
+    overlayLineInset: 0.5,
+    overlayOpacity: 0.8,
+    lineGradientEdgeOpacity: 0.1,
+    defaultMagnetRadius: 8,
+    keyboardStep: 1,
+    /** Fraction of the data range moved per shift + arrow-key press. */
+    keyboardPageStepRatio: 0.1,
+    keyboardPageStepMin: 1,
+    keyboardPageStepMax: 10
+  },
+  tooltip: {
+    defaultOffset: 10,
+    paddingX: 8,
+    paddingY: 8,
+    rowHeight: 16,
+    rowGap: 4,
+    titleGap: 6,
+    labelValueGap: 12,
+    transition: "opacity 0.15s ease-out 0.05s",
+    defaultMinWidth: 80,
+    background: e("var(--background-muted)"),
+    borderRadius: e("var(--border-radius-sm)")
+  },
+  emptyState: {
+    minDrawablePoints: 2,
+    loadingAriaLabel: "Loading chart",
+    defaultLabel: "No data",
+    gridLineRatios: [0.3, 0.5, 0.7],
+    placeholderViewWidth: 728,
+    placeholderViewHeight: 208,
+    placeholderLinePath: "M1.00 128.27 C4.02 127.46 13.09 125.96 19.13 123.47 C25.19 120.97 31.23 116.53 37.28 113.31 C43.33 110.10 49.38 106.15 55.42 104.20 C61.48 102.24 67.52 102.53 73.57 101.61 C79.61 100.69 85.65 99.89 91.71 98.70 C97.75 97.51 103.80 95.67 109.84 94.47 C115.90 93.27 121.94 91.71 127.99 91.49 C134.03 91.26 140.09 91.53 146.13 93.16 C152.19 94.79 158.23 98.37 164.27 101.25 C170.32 104.13 176.36 108.16 182.42 110.45 C188.46 112.74 194.51 114.41 200.55 115.00 C206.61 115.60 212.65 114.56 218.70 114.03 C224.75 113.50 230.80 112.56 236.84 111.86 C242.88 111.17 248.94 110.27 254.98 109.87 C261.03 109.48 267.07 109.14 273.13 109.49 C279.17 109.82 285.22 110.90 291.26 111.90 C297.32 112.90 303.36 114.47 309.41 115.50 C315.46 116.54 321.50 118.12 327.55 118.11 C333.59 118.10 339.65 118.08 345.69 115.45 C351.74 112.81 357.78 107.02 363.84 102.29 C369.88 97.54 375.93 90.87 381.97 87.01 C388.03 83.16 394.07 79.81 400.11 79.12 C406.17 78.43 412.21 80.79 418.26 82.88 C424.30 84.99 430.36 88.88 436.40 91.74 C442.45 94.59 448.49 98.24 454.55 100.02 C460.59 101.80 466.64 102.08 472.68 102.44 C478.72 102.81 484.78 102.31 490.82 102.21 C496.87 102.11 502.92 101.95 508.97 101.84 C515.01 101.74 521.07 101.47 527.11 101.58 C533.16 101.68 539.20 101.57 545.26 102.48 C551.30 103.39 557.34 105.37 563.39 107.02 C569.43 108.68 575.49 111.02 581.53 112.40 C587.59 113.79 593.63 114.62 599.68 115.30 C605.72 115.98 611.78 115.81 617.82 116.48 C623.87 117.16 629.91 118.39 635.95 119.32 C642.01 120.25 648.05 121.51 654.10 122.04 C660.15 122.57 666.20 123.89 672.24 122.47 C678.30 121.07 684.34 117.39 690.39 113.54 C696.43 109.69 702.49 103.53 708.53 99.38 C714.57 95.23 722.31 90.65 726.66 88.61"
+  },
+  reveal: {
+    durationInSeconds: 0.8,
+    easing: "linear",
+    pointFadeDurationInSeconds: 0.2,
+    pointFadeInAfterClipInSeconds: -0.1
+  },
+  shimmer: {
+    pulseDurationInSeconds: 2,
+    pulseEasing: "cubic-bezier(0.4, 0, 0.6, 1)"
+  },
+  donut: {
+    defaultSegmentColor: e("var(--background-muted-strong)"),
+    emptyRingColor: e("var(--background-muted)"),
+    /** Horizontal inset (px per side) so center text clears the inner ring. */
+    centerContentInset: { md: 4, sm: 2 },
+    /** Defaults applied by `useDonutSeries` when preparing a raw series. */
+    series: {
+      maxSegments: 7,
+      otherId: "other",
+      /** A tail shorter than this is kept as-is rather than folded into `other`. */
+      minGroupedSegments: 2,
+      /**
+       * Floor on the segments kept before the tail, so an out-of-range
+       * `groupBelowShare` (`1`, or `4` misread as "4%") can never fold the
+       * whole series away.
+       */
+      minKeptSegments: 1
+    },
+    hover: {
+      dimOpacity: 0.3,
+      opacityTransition: "opacity 150ms ease",
+      popTransition: "transform 180ms cubic-bezier(0.2, 0.8, 0.2, 1)",
+      centerTextTransition: "opacity 180ms ease, transform 180ms ease"
+    },
+    placeholder: {
+      segmentValues: [25, 19, 15, 13, 10, 10, 8]
+    },
+    loading: {
+      durationInSeconds: 2,
+      minOpacity: 0.5,
+      easing: "cubic-bezier(0.4, 0, 0.6, 1)",
+      ariaLabel: "Loading donut chart"
+    },
+    size: {
+      md: {
+        box: 168,
+        innerRadius: 61,
+        outerRadius: 83,
+        cornerRadius: 4,
+        padAngle: 0.06,
+        hoverOffset: 3.36,
+        minSegmentArc: 8
+      },
+      sm: {
+        box: 80,
+        innerRadius: 28,
+        outerRadius: 39,
+        cornerRadius: 2,
+        padAngle: 0.08,
+        hoverOffset: 2,
+        minSegmentArc: 4
+      }
+    }
+  }
+};
+export {
+  t as chartConfig
+};

package/dist/lib/Components/visualization/index.d.ts

@@ -0,0 +1,8 @@
+export * from './DonutChart';
+export * from './Legend';
+export * from './LineChart';
+export * from './Point';
+export * from './ReferenceLine';
+export * from './Scrubber';
+export * from './utils';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/Components/visualization/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}

package/dist/lib/Components/visualization/index.js

@@ -0,0 +1,27 @@
+import { DonutChart as o } from "./DonutChart/DonutChart.js";
+import { DonutChartCenter as n } from "./DonutChart/DonutChartCenter.js";
+import { DonutChartDescription as f } from "./DonutChart/DonutChartDescription.js";
+import { DonutChartTitle as m } from "./DonutChart/DonutChartTitle.js";
+import { prepareDonutSeries as i } from "./DonutChart/useDonutSeries/utils.js";
+import { useDonutSeries as C } from "./DonutChart/useDonutSeries/useDonutSeries.js";
+import { Legend as b } from "./Legend/Legend.js";
+import { LineChart as s } from "./LineChart/LineChart.js";
+import { Point as L, PointLabel as S } from "./Point/Point.js";
+import { ReferenceLine as P } from "./ReferenceLine/ReferenceLine.js";
+import { Scrubber as g } from "./Scrubber/Scrubber.js";
+import { useScrubberContext as T } from "./Scrubber/context/scrubberContext.js";
+export {
+  o as DonutChart,
+  n as DonutChartCenter,
+  f as DonutChartDescription,
+  m as DonutChartTitle,
+  b as Legend,
+  s as LineChart,
+  L as Point,
+  S as PointLabel,
+  P as ReferenceLine,
+  g as Scrubber,
+  i as prepareDonutSeries,
+  C as useDonutSeries,
+  T as useScrubberContext
+};

package/dist/lib/Components/visualization/utils/domain/domain.d.ts

@@ -0,0 +1,18 @@
+import { AxisBounds, BaseAxisProps } from '../../Axis';
+import { Series } from '../types';
+/**
+ * Compute the X domain (index-based) from series data and axis config.
+ * For the X axis the domain is typically 0..N-1 where N = longest series length,
+ * unless explicit `data` is provided on the axis config.
+ */
+export declare const computeXDomain: (series: Series[], axisConfig?: Partial<BaseAxisProps>) => AxisBounds;
+/**
+ * Compute the Y domain (value-based) from series data and axis config.
+ * Scans all non-null values across all series to find min/max.
+ */
+export declare const computeYDomain: (series: Series[], axisConfig?: Partial<BaseAxisProps>) => AxisBounds;
+/**
+ * Compute the data length (number of discrete positions on the index axis).
+ */
+export declare const computeDataLength: (series: Series[], axisConfig?: Partial<BaseAxisProps>) => number;
+//# sourceMappingURL=domain.d.ts.map

package/dist/lib/Components/visualization/utils/domain/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/utils/domain/domain.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAWvC;;;;GAIG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,MAAM,EAAE,EAChB,aAAa,OAAO,CAAC,aAAa,CAAC,KAClC,UAIA,CAAC;AAEJ;;;GAGG;AACH,eAAO,MAAM,cAAc,GACzB,QAAQ,MAAM,EAAE,EAChB,aAAa,OAAO,CAAC,aAAa,CAAC,KAClC,UAC8D,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,MAAM,EAAE,EAChB,aAAa,OAAO,CAAC,aAAa,CAAC,KAClC,MAAiE,CAAC"}

package/dist/lib/Components/visualization/utils/domain/domain.js

@@ -0,0 +1,35 @@
+const h = (t, n) => r(
+  f(t, n?.data),
+  n?.domain
+), p = (t, n) => r(u(t), n?.domain), g = (t, n) => n?.data?.length || c(t), f = (t, n) => n?.length ? a(n) ? x(n, { min: 0, max: 0 }) : { min: 0, max: n.length - 1 } : { min: 0, max: Math.max(0, c(t) - 1) }, u = (t) => {
+  const n = o();
+  for (const { data: e } of t)
+    if (e)
+      for (const m of e)
+        m !== null && i(n, m);
+  return s(n, { min: 0, max: 1 });
+}, a = (t) => typeof t[0] == "number", x = (t, n) => {
+  const e = o();
+  for (const m of t) i(e, m);
+  return s(e, n);
+}, o = () => ({
+  min: 0,
+  max: 0,
+  hasValue: !1
+}), i = (t, n) => {
+  if (Number.isFinite(n)) {
+    if (!t.hasValue) {
+      t.min = n, t.max = n, t.hasValue = !0;
+      return;
+    }
+    n < t.min && (t.min = n), n > t.max && (t.max = n);
+  }
+}, s = ({ min: t, max: n, hasValue: e }, m) => e ? { min: t, max: n } : m, c = (t) => t.reduce((n, e) => Math.max(n, e.data?.length ?? 0), 0), r = (t, n) => n ? typeof n == "function" ? n(t) : {
+  min: n.min ?? t.min,
+  max: n.max ?? t.max
+} : t;
+export {
+  g as computeDataLength,
+  h as computeXDomain,
+  p as computeYDomain
+};

package/dist/lib/Components/visualization/utils/index.d.ts

@@ -0,0 +1,2 @@
+export type { CategoricalScale, ChartInset, ChartScaleFunction, CurveType, DrawingArea, NumericScale, Series, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/Components/visualization/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/utils/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,SAAS,EACT,WAAW,EACX,YAAY,EACZ,MAAM,GACP,MAAM,SAAS,CAAC"}

package/dist/lib/Components/visualization/utils/numbers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Type guard for a finite number. Narrows out `null`, `undefined`, `NaN` and
+ * `Infinity`, i.e. any value that cannot be projected to a valid coordinate or
+ * counted as a drawable data point.
+ */
+export declare const isFiniteNumber: (value: unknown) => value is number;
+/**
+ * Constrains `value` to the inclusive `[min, max]` range. For a degenerate
+ * range where `min > max` (e.g. an index range `[0, length - 1]` for empty
+ * data), `min` takes precedence and is returned — matching `lodash.clamp`.
+ */
+export declare const clamp: (value: number, min: number, max: number) => number;
+//# sourceMappingURL=numbers.d.ts.map

package/dist/lib/Components/visualization/utils/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/utils/numbers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MACjC,CAAC;AAEzB;;;;GAIG;AACH,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,KAAK,MAAM,EAAE,KAAK,MAAM,KAAG,MAC3B,CAAC"}

package/dist/lib/Components/visualization/utils/numbers.js

@@ -0,0 +1,5 @@
+const m = (i) => Number.isFinite(i), n = (i, t, e) => Math.max(Math.min(i, e), t);
+export {
+  n as clamp,
+  m as isFiniteNumber
+};

package/dist/lib/Components/visualization/utils/scales/scales.d.ts

@@ -0,0 +1,47 @@
+import { AxisBounds, BaseAxisProps } from '../../Axis';
+import { CategoricalScale, ChartScaleFunction, NumericScale } from '../types';
+/**
+ * Creates a numeric scale.
+ *
+ * When `nice` is `true` (default), the domain is rounded outward to clean
+ * boundaries via d3's `.nice()` (e.g. `[4, 98]` → `[0, 100]`). Set `nice` to
+ * `false` to keep the domain exactly as provided so data fills the range
+ * boundary-to-boundary.
+ */
+export declare const getNumericScale: ({ scaleType, domain, range, nice, }: {
+    scaleType: "linear" | "log";
+    domain: AxisBounds;
+    range: AxisBounds;
+    nice?: boolean;
+}) => NumericScale;
+export declare const getCategoricalScale: ({ domain, range, padding, }: {
+    domain: AxisBounds;
+    range: AxisBounds;
+    padding?: number;
+}) => CategoricalScale;
+/**
+ * Checks if a scale type config value refers to a band (categorical) scale.
+ */
+export declare const isBandScaleType: (scaleType: BaseAxisProps["scaleType"]) => scaleType is "band";
+/**
+ * Checks if a scale is a categorical scale.
+ */
+export declare const isCategoricalScale: (scale: ChartScaleFunction) => scale is CategoricalScale;
+/**
+ * Checks if a scale is a numeric scale.
+ */
+export declare const isNumericScale: (scale: ChartScaleFunction) => scale is NumericScale;
+/**
+ * Converts a single data-space value to pixel-space on a given scale.
+ * For band scales the result is centered within the band.
+ */
+export declare const getPointOnScale: (value: number, scale: ChartScaleFunction) => number;
+/**
+ * Projects a single data-space coordinate pair into pixel-space.
+ * Handles centering for categorical (band) scales.
+ */
+export declare const projectPoint: (dataX: number, dataY: number, xScale: ChartScaleFunction, yScale: ChartScaleFunction) => {
+    x: number;
+    y: number;
+};
+//# sourceMappingURL=scales.d.ts.map

package/dist/lib/Components/visualization/utils/scales/scales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scales.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/utils/scales/scales.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,YAAY,EACb,MAAM,UAAU,CAAC;AAElB;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,GAAI,qCAK7B;IACD,SAAS,EAAE,QAAQ,GAAG,KAAK,CAAC;IAC5B,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB,KAAG,YAOH,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,6BAIjC;IACD,MAAM,EAAE,UAAU,CAAC;IACnB,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,KAAG,gBAUH,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,eAAe,GAC1B,WAAW,aAAa,CAAC,WAAW,CAAC,KACpC,SAAS,IAAI,MAA8B,CAAC;AAE/C;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,kBAAkB,KACxB,KAAK,IAAI,gBAEX,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,kBAAkB,KACxB,KAAK,IAAI,YAEX,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,MAAM,EACb,OAAO,kBAAkB,KACxB,MAKF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GACvB,OAAO,MAAM,EACb,OAAO,MAAM,EACb,QAAQ,kBAAkB,EAC1B,QAAQ,kBAAkB,KACzB;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAGvB,CAAC"}

package/dist/lib/Components/visualization/utils/scales/scales.js

@@ -0,0 +1,32 @@
+import { scaleBand as m, scaleLog as s, scaleLinear as d } from "d3-scale";
+const g = ({
+  scaleType: n,
+  domain: t,
+  range: r,
+  nice: e = !0
+}) => {
+  const i = n === "log" ? s() : d();
+  return i.domain([t.min, t.max]), e && i.nice(), i.range([r.min, r.max]);
+}, l = ({
+  domain: n,
+  range: t,
+  padding: r = 0.1
+}) => {
+  const e = Array.from(
+    { length: n.max - n.min + 1 },
+    (i, o) => n.min + o
+  );
+  return m().domain(e).range([t.min, t.max]).paddingInner(r).paddingOuter(r / 2);
+}, f = (n) => n === "band", c = (n) => "bandwidth" in n && typeof n.bandwidth == "function", p = (n) => !c(n), a = (n, t) => c(t) ? (t(n) ?? 0) + t.bandwidth() / 2 : t(n), x = (n, t, r, e) => ({
+  x: a(n, r),
+  y: a(t, e)
+});
+export {
+  l as getCategoricalScale,
+  g as getNumericScale,
+  a as getPointOnScale,
+  f as isBandScaleType,
+  c as isCategoricalScale,
+  p as isNumericScale,
+  x as projectPoint
+};

package/dist/lib/Components/visualization/utils/ticks/ticks.d.ts

@@ -0,0 +1,35 @@
+import { BaseAxisProps } from '../../Axis';
+import { ChartScaleFunction } from '../types';
+export declare const APPROXIMATE_TICK_COUNT = 5;
+export type TickData = {
+    position: number;
+    value: number;
+    label: string;
+};
+/**
+ * Resolves which numeric tick values should appear on the axis.
+ *
+ * Priority:
+ * 1. Explicit `ticks` provided by the consumer.
+ * 2. Axis `data` — when provided, ticks come from the data itself (numeric
+ *    values for numeric data, indices for string data) so the rendered ticks
+ *    mirror exactly what the consumer asked for, with no d3-invented
+ *    intermediate values.
+ * 3. Scale-specific defaults (band domain, or `scale.ticks()` for numeric).
+ */
+export declare const getTickValues: (scale: ChartScaleFunction, explicitTicks?: number[], axisData?: BaseAxisProps["data"]) => number[];
+/**
+ * Converts a tick value to its pixel position on the axis.
+ * Band scales are centered within the band.
+ */
+export declare const getTickPosition: (scale: ChartScaleFunction, tick: number) => number;
+/**
+ * Resolves the display label for a tick value.
+ * Priority: formatter > string label lookup > raw value.
+ */
+export declare const getTickLabel: (tick: number, axisData: BaseAxisProps["data"], formatter?: (value: number | string) => string) => string;
+/**
+ * Builds the complete tick data array from a scale and axis configuration.
+ */
+export declare const buildTicksData: (scale: ChartScaleFunction, axisConfig?: BaseAxisProps, explicitTicks?: number[], formatter?: (value: number | string) => string) => TickData[];
+//# sourceMappingURL=ticks.d.ts.map

package/dist/lib/Components/visualization/utils/ticks/ticks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ticks.d.ts","sourceRoot":"","sources":["../../../../../../src/lib/Components/visualization/utils/ticks/ticks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAEhD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAEnD,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GACxB,OAAO,kBAAkB,EACzB,gBAAgB,MAAM,EAAE,EACxB,WAAW,aAAa,CAAC,MAAM,CAAC,KAC/B,MAAM,EAUR,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,eAAe,GAC1B,OAAO,kBAAkB,EACzB,MAAM,MAAM,KACX,MAKF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,YAAY,GACvB,MAAM,MAAM,EACZ,UAAU,aAAa,CAAC,MAAM,CAAC,EAC/B,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,MAAM,KAC7C,MAeF,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,cAAc,GACzB,OAAO,kBAAkB,EACzB,aAAa,aAAa,EAC1B,gBAAgB,MAAM,EAAE,EACxB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,KAAK,MAAM,KAC7C,QAAQ,EASV,CAAC"}

package/dist/lib/Components/visualization/utils/ticks/ticks.js

@@ -0,0 +1,23 @@
+import { isCategoricalScale as i, isNumericScale as g } from "../scales/scales.js";
+const f = 5, d = (r, n, e) => n || (e && e.length > 0 ? typeof e[0] == "number" ? e : e.map((o, t) => t) : i(r) ? r.domain() : g(r) ? r.ticks(f) : []), b = (r, n) => i(r) ? (r(n) ?? 0) + r.bandwidth() / 2 : r(n), l = (r, n, e) => {
+  const o = n && Array.isArray(n) && typeof n[0] == "string";
+  if (e) {
+    const t = o && n[r] !== void 0 ? n[r] : r;
+    return String(e(t));
+  }
+  return o && n[r] !== void 0 ? String(n[r]) : String(r);
+}, S = (r, n, e, o) => {
+  const t = n?.data;
+  return d(r, e, t).map((u) => ({
+    position: b(r, u),
+    value: u,
+    label: l(u, t, o)
+  }));
+};
+export {
+  f as APPROXIMATE_TICK_COUNT,
+  S as buildTicksData,
+  l as getTickLabel,
+  b as getTickPosition,
+  d as getTickValues
+};

package/dist/lib/Components/visualization/utils/types.d.ts

@@ -0,0 +1,63 @@
+import { ScaleBand, ScaleLinear, ScaleLogarithmic } from 'd3-scale';
+export type ChartInset = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+/**
+ * Pixel bounds of the drawable region.
+ */
+export type DrawingArea = {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * Interpolation used to draw a line (and its area) between data points.
+ * Each value maps to a [d3-shape](https://d3js.org/d3-shape/curve) curve:
+ * - `'bump'` — smooth cubic curve with horizontal tangents (`curveBumpX`).
+ * - `'natural'` — natural cubic spline through every point (`curveNatural`).
+ * - `'monotone'` — smooth curve that preserves monotonicity (`curveMonotoneX`).
+ * - `'linear'` — straight segments between points (`curveLinear`).
+ * - `'step'` — stepped, piecewise-constant line (`curveStep`).
+ * - `'stepAfter'` — stepped line where changes occur after the x-coordinate (`curveStepAfter`).
+ * - `'stepBefore'` — stepped line where changes occur before the x-coordinate (`curveStepBefore`).
+ */
+export type CurveType = 'bump' | 'natural' | 'monotone' | 'linear' | 'step' | 'stepAfter' | 'stepBefore';
+export type Series = {
+    /**
+     * Unique identifier for the series.
+     */
+    id: string;
+    /**
+     * Numeric data points; `null` entries represent gaps.
+     */
+    data?: (number | null)[];
+    /**
+     * Human-readable label used in legends and tooltips.
+     */
+    label?: string;
+    /**
+     * CSS color applied to the series line/mark.
+     * @default border-muted
+     */
+    stroke?: string;
+    /**
+     * Interpolation used to draw the line between data points.
+     * @default 'bump'
+     */
+    curve?: CurveType;
+    /**
+     * When true, skips null values and draws a continuous line across gaps.
+     * When false (default), null values create gaps in the line.
+     * Overridden by the chart-level `connectNulls` prop when that is set.
+     * @default false
+     */
+    connectNulls?: boolean;
+};
+export type NumericScale = ScaleLinear<number, number> | ScaleLogarithmic<number, number>;
+export type CategoricalScale = ScaleBand<number>;
+export type ChartScaleFunction = NumericScale | CategoricalScale;
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/Components/visualization/utils/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/visualization/utils/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEzE,MAAM,MAAM,UAAU,GAAG;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,SAAS,GACT,UAAU,GACV,QAAQ,GACR,MAAM,GACN,WAAW,GACX,YAAY,CAAC;AAEjB,MAAM,MAAM,MAAM,GAAG;IACnB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX;;OAEG;IACH,IAAI,CAAC,EAAE,CAAC,MAAM,GAAG,IAAI,CAAC,EAAE,CAAC;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,KAAK,CAAC,EAAE,SAAS,CAAC;IAClB;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,MAAM,MAAM,YAAY,GACpB,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAC3B,gBAAgB,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG,SAAS,CAAC,MAAM,CAAC,CAAC;AAEjD,MAAM,MAAM,kBAAkB,GAAG,YAAY,GAAG,gBAAgB,CAAC"}

package/dist/libs/design-core/dist/lib/colorContrast/colorContrast.js

@@ -0,0 +1,15 @@
+import { hexToHsl as i } from "./hexToHsl.js";
+import { hslToHex as l } from "./hslToHex.js";
+const o = /^#[a-f\d]{6}$/i;
+function x(e, n, s = 20) {
+  if (!o.test(e) || !o.test(n))
+    return e;
+  const t = i(e), a = i(n), f = Math.abs(t.l - a.l);
+  if (f >= s)
+    return e;
+  const r = s - f;
+  return t.l = t.l >= a.l ? Math.min(100, t.l + r) : Math.max(0, t.l - r), l(t);
+}
+export {
+  x as getContrastSafeColor
+};

package/dist/libs/design-core/dist/lib/colorContrast/hexToHsl.js

@@ -0,0 +1,14 @@
+function x(h) {
+  const c = /^#([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(h);
+  if (c === null)
+    throw new Error("could not parse hex color");
+  const [, d, f, i] = c, o = Number.parseInt(d, 16) / 255, n = Number.parseInt(f, 16) / 255, r = Number.parseInt(i, 16) / 255, e = Math.max(o, n, r), s = Math.min(o, n, r);
+  let t = (e + s) / 2, u = t, a = t;
+  if (e === s)
+    return { h: 0, s: 0, l: Math.round(a * 100) };
+  const l = e - s;
+  return u = a > 0.5 ? l / (2 - e - s) : l / (e + s), e === o ? t = (n - r) / l + (n < r ? 6 : 0) : e === n ? t = (r - o) / l + 2 : e === r && (t = (o - n) / l + 4), t /= 6, t = Math.round(t * 360), u = Math.round(u * 100), a = Math.round(a * 100), { h: t, s: u, l: a };
+}
+export {
+  x as hexToHsl
+};

package/dist/libs/design-core/dist/lib/colorContrast/hslToHex.js

@@ -0,0 +1,10 @@
+function l(a) {
+  const { h: c, s: r, l: s } = a, t = s / 100, h = r * Math.min(t, 1 - t) / 100, n = (e) => {
+    const o = (e + c / 30) % 12, i = t - h * Math.max(Math.min(o - 3, 9 - o, 1), -1);
+    return Math.round(255 * i).toString(16).padStart(2, "0");
+  };
+  return `#${n(0)}${n(8)}${n(4)}`;
+}
+export {
+  l as hslToHex
+};

package/dist/libs/design-core/dist/lib/themes/js/primitives/primitive.colors.js

@@ -0,0 +1,15 @@
+const f = {
+  light: {
+    grey: {
+      "050": "#ffffff"
+    }
+  },
+  dark: {
+    grey: {
+      "050": "#000000"
+    }
+  }
+};
+export {
+  f as primitiveColorTokens
+};