@lynxflow/seo-engine 2.8.0 → 3.2.0

package/dist/cdp-pipelines.d.ts

@@ -0,0 +1,44 @@
+import { z } from "zod";
+export type TransformOp = "rename" | "drop" | "add" | "filter";
+export interface Transform {
+    op: TransformOp;
+    from?: string;
+    to?: string;
+    value?: unknown;
+    condition?: (e: Record<string, unknown>) => boolean;
+}
+export interface Destination {
+    id: string;
+    name: string;
+    type: "webhook" | "s3" | "warehouse";
+    enabled: boolean;
+}
+export interface Pipeline {
+    id: string;
+    name: string;
+    eventTypes: string[];
+    transforms: Transform[];
+    destinations: string[];
+}
+export declare const PipelineSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    eventTypes: z.ZodArray<z.ZodString>;
+    transforms: z.ZodArray<z.ZodObject<{
+        op: z.ZodEnum<{
+            filter: "filter";
+            drop: "drop";
+            rename: "rename";
+            add: "add";
+        }>;
+    }, z.core.$strip>>;
+    destinations: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare function applyTransforms(event: Record<string, unknown>, transforms: Transform[]): Record<string, unknown> | null;
+export declare function routeEvent(pipelines: Pipeline[], event: Record<string, unknown> & {
+    type: string;
+}): {
+    pipelineId: string;
+    destinationIds: string[];
+    payload: Record<string, unknown> | null;
+}[];

package/dist/chart-annotations.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export interface ChartAnnotation {
+    id: string;
+    chartId: string;
+    text: string;
+    startDate: string;
+    endDate?: string;
+    metric?: string;
+    color?: string;
+    createdAt: string;
+}
+export declare const ChartAnnotationSchema: z.ZodObject<{
+    id: z.ZodString;
+    chartId: z.ZodString;
+    text: z.ZodString;
+    startDate: z.ZodString;
+    endDate: z.ZodOptional<z.ZodString>;
+    metric: z.ZodOptional<z.ZodString>;
+    color: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+}, z.core.$strip>;
+export declare function createAnnotation(input: Omit<ChartAnnotation, "createdAt"> & {
+    createdAt?: string;
+}): ChartAnnotation;
+export declare function annotationsForChart(list: ChartAnnotation[], chartId: string): ChartAnnotation[];
+export declare function annotationsInRange(list: ChartAnnotation[], start: string, end: string): ChartAnnotation[];

package/dist/chart-plan/__tests__/chart-types-cases.d.ts

@@ -0,0 +1,11 @@
+export interface ChartTypeCase {
+    name: string;
+    render: () => string;
+}
+/**
+ * Six cas de référence, un par type de graphique difficile. Les fixtures
+ * dorées Associated garantissent qu'un changement de géométrie ne passe pas
+ * inaperçu : la comparaison est canonique (ordre des attributs et formes
+ * numériques normalisés), jamais une égalité de chaînes.
+ */
+export declare const CHART_TYPE_CASES: ChartTypeCase[];

package/dist/chart-plan/__tests__/static-viz-cases.d.ts

@@ -0,0 +1,11 @@
+export interface StaticVizCase {
+    name: string;
+    render: () => string;
+}
+/**
+ * Cas de référence figeant la sortie ACTUELLE du moteur headless.
+ * Les libellés sont volontairement dépourvus de caractères XML spéciaux
+ * (`& < > " '`) : l'échappement des textes est couvert par un test dédié
+ * (tâche 3), pas par la comparaison de golden files.
+ */
+export declare const STATIC_VIZ_CASES: StaticVizCase[];

package/dist/chart-plan/__tests__/svg-normalize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Normalisation de SVG pour les tests de régression.
+ *
+ * Deux rendus SVG sont identiques quand ils produisent le même ARBRE
+ * d'éléments. Ce qui n'est PAS une différence :
+ * - l'ordre des attributs (`fill` avant `stroke` ou l'inverse) ;
+ * - la forme numérique d'un attribut (`"0.0"` et `"0"` sont le même nombre) ;
+ * - les espaces de mise en forme entre deux éléments.
+ * Ce qui EST une différence : l'ordre des enfants, le nom d'un élément,
+ * la valeur d'un attribut non numérique, le contenu textuel (y compris
+ * une espace initiale : `" /100"` ≠ `"/100"`).
+ *
+ * Séparateurs de la forme canonique (échappés pour rester lisibles) :
+ * `\u0001` entre deux attributs, `\u0002` devant un noeud texte,
+ * `\u0001` devant un noeud element, `\u0003` entre deux enfants.
+ */
+export interface XmlNode {
+    name: string;
+    attrs: Record<string, string>;
+    /** Enfants dans l'ordre du document ; les chaînes sont des noeuds de texte. */
+    content: (XmlNode | string)[];
+}
+export declare function parseXml(source: string): XmlNode;
+/** Forme canonique d'un document SVG : comparable par égalité stricte. */
+export declare function canonicalizeSvg(svg: string): string;

package/dist/chart-plan/dataset.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Le contrat de données : une seule forme pour l'entrée de tous les
+ * consommateurs (onglets Pulse, plans de graphique, exports, e-mail,
+ * OpenGraph, outils MCP, Agent API).
+ */
+export type DatasetValue = string | number | boolean | null;
+export type DatasetColumnType = "string" | "number" | "date" | "boolean";
+export interface DatasetColumn {
+    name: string;
+    type: DatasetColumnType;
+    values?: DatasetValue[];
+}
+export interface Dataset {
+    columns: DatasetColumn[];
+    rows: DatasetValue[][];
+}
+/**
+ * Construit un `Dataset` à partir de lignes objets. L'ordre des colonnes est
+ * l'ordre d'apparition des clés ; les clés absentes d'une ligne sont
+ * complétées par `null` (jamais par `undefined` : le `Dataset` traverse une
+ * frontière JSON).
+ */
+export declare function datasetFromRows(rows: Record<string, DatasetValue>[], types?: Record<string, DatasetColumnType>): Dataset;
+/** Valeurs d'une colonne ; tableau vide si la colonne n'existe pas. */
+export declare function columnValues(dataset: Dataset, name: string): DatasetValue[];

package/dist/chart-plan/geometry/bar.d.ts

@@ -0,0 +1,13 @@
+import type { ChartPlan } from "../types";
+export interface BarItem {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface BarChartOptions {
+    width?: number;
+    height?: number;
+    orientation?: "horizontal" | "vertical";
+    barColor?: string;
+}
+export declare function buildBarPlan(bars: BarItem[], options?: BarChartOptions): ChartPlan;

package/dist/chart-plan/geometry/boxplot.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Diagramme en boîte (box plot).
+ *
+ * Les quartiles sont interpolés linéairement et les points aberrants sont ceux
+ * qui tombent hors de l'intervalle interquartile élargi à 1,5 fois son
+ * amplitude. Le rendu de l'amont passe par ECharts : on le remplace ici par la
+ * construction directe d'un `ChartPlan`, sur le modèle des autres géométries du
+ * moteur.
+ */
+import type { ChartPlan } from "../types";
+export type BoxPlotWhiskerType = "tukey" | "min-max";
+export interface BoxPlotStats {
+    /** Borne basse de la moustache (le point aberrant le plus bas est exclu). */
+    min: number;
+    q1: number;
+    median: number;
+    q3: number;
+    /** Borne haute de la moustache. */
+    max: number;
+    mean: number;
+    outliers: number[];
+    count: number;
+    /** Valeur minimale observée, points aberrants compris. */
+    rawMin: number;
+    /** Valeur maximale observée, points aberrants compris. */
+    rawMax: number;
+}
+export interface BoxPlotCategory {
+    label: string;
+    values: number[];
+}
+export interface BoxPlotColors {
+    box?: string;
+    median?: string;
+    whisker?: string;
+    outlier?: string;
+    mean?: string;
+}
+export interface BoxPlotPlanOptions {
+    width?: number;
+    height?: number;
+    showMean?: boolean;
+    showOutliers?: boolean;
+    showDataPoints?: boolean;
+    colors?: BoxPlotColors;
+    valueFormat?: (value: number) => string;
+    whiskerType?: BoxPlotWhiskerType;
+    /** Espace horizontal réservé à l'axe des valeurs. */
+    yAxisWidth?: number;
+    /** Espace vertical réservé à l'axe des catégories. */
+    xAxisHeight?: number;
+}
+/**
+ * Quantile par interpolation linéaire (méthode 7 de Hyndman-Fan), identique à celle
+ * de l'amont : l'index vaut `(n - 1) × q` et la fraction entre les deux points
+ * voisins est appliquée.
+ */
+export declare function computeQuantile(sortedValues: number[], quantile: number): number;
+/**
+ * Statistiques d'un jeu de valeurs. Les valeurs non finies sont ignorées.
+ */
+export declare function computeBoxPlotStats(values: number[], whiskerType?: BoxPlotWhiskerType): BoxPlotStats;
+/** Largeur de la boîte, bornée comme chez l'amont. */
+export declare function getBoxPlotBoxWidth(categoryWidth: number): number;
+/** Diamètre des symboles (moyenne, points aberrants), borné comme chez l'amont. */
+export declare function getBoxPlotSymbolSize(categoryWidth: number): number;
+/**
+ * Construit le plan d'un diagramme en boîte.
+ */
+export declare function buildBoxPlotPlan(categories: BoxPlotCategory[], options?: BoxPlotPlanOptions): ChartPlan;

package/dist/chart-plan/geometry/cartesian/axes.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Axes et grille.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/option/axis.ts`
+ * et `ticks.ts`), où les axes sont des options ECharts. On produit ici directement des
+ * `Mark`s : ligne d'axe, graduations, étiquettes, lignes de grille.
+ */
+import type { Mark } from "../../types";
+export interface AxisOptions {
+    /** Position de l'axe : en bas pour X, à gauche pour Y. */
+    position: "bottom" | "left" | "right" | "top";
+    /** Longueur de l'axe, le long de sa propre direction. */
+    length: number;
+    /** Début de l'axe le long de sa propre direction : x pour un axe horizontal, y pour un axe vertical. */
+    origin: number;
+    /** Position perpendiculaire à l'axe : y pour un axe horizontal, x pour un axe vertical. */
+    cross: number;
+    color?: string;
+    labelColor?: string;
+    fontSize?: number;
+    showLine?: boolean;
+    showTicks?: boolean;
+    tickLength?: number;
+}
+export interface AxisTick {
+    /** Position sur l'axe, en pixels. */
+    position: number;
+    label: string;
+}
+export declare const AXIS_DEFAULTS: {
+    color: string;
+    labelColor: string;
+    fontSize: number;
+    tickLength: number;
+};
+/**
+ * Graduations d'un axe horizontal (graduation en `position` le long de X).
+ * Le label est ancré au milieu, sous la ligne.
+ */
+export declare function buildBottomAxis(ticks: AxisTick[], options: AxisOptions): Mark[];
+/**
+ * Graduations d'un axe vertical. Le label est ancré à droite, aligné sur la
+ * graduation. Un axe positionné à droite renvoie ses étiquettes à droite de la
+ * ligne d'axe.
+ */
+export declare function buildLeftAxis(ticks: AxisTick[], options: AxisOptions): Mark[];
+/** Lignes de grille horizontales, une par graduation. */
+export declare function buildGridLines(ticks: AxisTick[], options: {
+    from: number;
+    to: number;
+    color?: string;
+    dash?: number[];
+}): Mark[];

package/dist/chart-plan/geometry/cartesian/layout.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Zone de tracé d'un graphique cartésien.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/layout/`),
+ * où le layout calcule des `bounds` à partir du padding et de l'espace mesuré occupé
+ * par les graduations. On reprend l'idée, avec un espace réservé aux axes déclaré par
+ * l'appelant plutôt que mesuré : le moteur n'a pas de moteur de rendu de texte, donc
+ * l'espace des étiquettes d'axe est une donnée d'entrée, pas une mesure.
+ */
+export interface Padding {
+    top?: number;
+    right?: number;
+    bottom?: number;
+    left?: number;
+}
+export interface CartesianBounds {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+export interface CartesianLayout {
+    width: number;
+    height: number;
+    /** Bornes de la zone de tracé (coordonnées du SVG). */
+    bounds: CartesianBounds;
+    plotWidth: number;
+    plotHeight: number;
+    padding: Required<Padding>;
+}
+export interface CartesianLayoutInput {
+    width: number;
+    height: number;
+    padding?: Padding;
+    /** Espace horizontal réservé à l'axe Y (graduations + étiquettes). */
+    yAxisWidth?: number;
+    /** Espace vertical réservé à l'axe X (graduations + étiquettes). */
+    xAxisHeight?: number;
+    /** Second axe Y, à droite de la zone de tracé. */
+    rightAxisWidth?: number;
+}
+/**
+ * Calcule la zone de tracé. L'axe X est **sous** la zone (graduations et étiquettes en
+ * dessous), l'axe Y **à gauche** : c'est la convention de Metabase, comme de la plupart
+ * des bibliothèques de graphiques.
+ */
+export declare function computeCartesianLayout(input: CartesianLayoutInput): CartesianLayout;

package/dist/chart-plan/geometry/cartesian/scales.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Échelles du socle cartésien.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/`), dont la
+ * logique d'axe est complicated par ECharts (bornes « nice », axes logarithmiques, axes
+ * temporels avec dayjs). On n'en reprend que ce qui est nécessaire pour produire un
+ * `ChartPlan` : une interpolation linéaire, une échelle en bandes et l'algorithme du « nice
+ * number » pour les graduations.
+ */
+export interface LinearScale {
+    (value: number): number;
+    readonly domain: [number, number];
+    readonly range: [number, number];
+    /** Position en pixels d'une valeur du domaine. */
+    readonly pixel: (value: number) => number;
+    /** Valeur du domaine correspondant à une position en pixels. */
+    readonly invert: (pixel: number) => number;
+    /** Graduations « nice » contenues dans le domaine. */
+    readonly ticks: (count?: number) => number[];
+}
+/**
+ * Échelle linéaire. Le domaine peut être inversé (par exemple un axe Y dont la valeur
+ * maximale est en haut) : la fonction reste alors croissante de l'espace source vers
+ * l'espace cible.
+ */
+export declare function createLinearScale(domain: [number, number], range: [number, number]): LinearScale;
+export interface BandScale {
+    (value: string): number;
+    readonly domain: string[];
+    readonly range: [number, number];
+    readonly step: number;
+    readonly bandwidth: number;
+}
+/**
+ * Échelle en bandes : chaque catégorie occupe une bande de largeur `bandwidth`, les
+ * positions sont les centres de bande.
+ */
+export declare function createBandScale(domain: string[], range: [number, number], padding?: number): BandScale;
+/**
+ * Graduations « nice » : on choisit un pas de la forme 1, 2 ou 5 × 10^n, puis on aligne
+ * les bornes dessus. C'est l'algorithme classique du « nice number », et non celui
+ * d'ECharts — le résultat visuel est le même pour les usages courants.
+ */
+export declare function niceTicks(min: number, max: number, count?: number): number[];
+/** Bornes (minimum, maximum) d'une liste de valeurs, valeurs finies uniquement. */
+export declare function extent(values: number[]): [number, number];

package/dist/chart-plan/geometry/cartesian/series.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Primitives de tracé d'une série.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/`), où ces
+ * primitives sont des options ECharts. On les réécrit pour produire directement des
+ * `Mark`s.
+ */
+import type { Mark } from "../../types";
+/** Point d'une série, dans l'espace du graphique. */
+export interface SeriesPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Chaîne `d` d'une polyligne. Les points non finis sont ignorés : une valeur nulle
+ * doit casser la ligne, pas produire un « NaN » dans le SVG.
+ */
+export declare function buildLinePath(points: SeriesPoint[]): string;
+/** Chaîne `d` d'une aire : la polyligne refermée sur la ligne de base. */
+export declare function buildAreaPath(points: SeriesPoint[], baseline: number): string;
+/** Rectangle d'une barre, exprimé en `Mark`. */
+export interface BarRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color?: string;
+    radius?: number;
+}
+/** Convertit une liste de rectangles en `Mark`s. */
+export declare function buildBarRects(bars: BarRect[]): Mark[];
+/** Arrondi à deux décimales : les SVG restent lisibles et stables. */
+export declare function round(value: number): number;

package/dist/chart-plan/geometry/choropleth.d.ts

@@ -0,0 +1,44 @@
+import type { ChartPlan } from "../types";
+export declare const MAP_WIDTH = 1000;
+export declare const HEAT_MAP_ZERO_COLOR = "#CCC";
+export interface GeoJsonFeature {
+    id?: string | number;
+    properties?: Record<string, unknown>;
+}
+export interface GeoJsonFeatureCollection {
+    type: "FeatureCollection";
+    features: GeoJsonFeature[];
+}
+export type GeoJsonData = GeoJsonFeature | GeoJsonFeatureCollection;
+export interface ChoroplethRegion {
+    id: string;
+    path: string;
+    value?: number;
+}
+export interface ChoroplethPlanOptions {
+    width?: number;
+    height?: number;
+    colors?: string[];
+    valueFormat?: (value: number) => string;
+    legend?: "none" | "bottom" | "side";
+    emptyColor?: string;
+    borderColor?: string;
+    fontColor?: string;
+}
+export declare function isFeatureCollection(value: GeoJsonData): value is GeoJsonFeatureCollection;
+export declare function getFeatures(geoJson: GeoJsonData): GeoJsonFeature[];
+/**
+ * Clé d'une région. La clé de propriété a la priorité ; en son absence on
+ * retombe sur l'identifiant de la région.
+ */
+export declare function getFeatureKey(feature: GeoJsonFeature, keyProperty: string): string;
+/** Normalise une clé de région pour la comparer aux clés du GeoJSON. */
+export declare function canonicalRegionKey(key: unknown): string;
+/**
+ * Somme la métrique de chaque ligne par région. Une métrique non numérique
+ * compte pour zéro.
+ */
+export declare function getRegionValues(rows: unknown[][], dimensionIndex: number, metricIndex: number): Record<string, number>;
+/** Interpole une couleur dans une palette, `t` valant 0 à 1. */
+export declare function interpolateScaleColor(colors: string[], t: number): string;
+export declare function buildChoroplethPlan(regions: ChoroplethRegion[], options?: ChoroplethPlanOptions): ChartPlan;

package/dist/chart-plan/geometry/combo.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Graphique combiné : barres, courbes et aires sur un même repère.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/option/series.ts`),
+ * qui sait mixer plusieurs types de séries sur un même graphique. En amont, la
+ * mise en œuvre passe par les options ECharts, qui ne sont pas copiables sans
+ * embarquer ECharts ; on réécrit ici le placement des séries et des deux axes Y.
+ *
+ * Aucun code de l'amont n'est repris : le résultat est un `ChartPlan`, comme
+ * pour les autres géométries du moteur.
+ */
+import type { ChartPlan } from "../types";
+export interface ComboSeries {
+    key: string;
+    label: string;
+    type: "bar" | "line" | "area";
+    values: number[];
+    color?: string;
+    axis?: "left" | "right";
+}
+export interface ComboPlanOptions {
+    width?: number;
+    height?: number;
+    showLegend?: boolean;
+    colors?: string[];
+    valueFormat?: (value: number) => string;
+    yAxisWidth?: number;
+    rightAxisWidth?: number;
+    xAxisHeight?: number;
+}
+/**
+ * Construit le plan d'un graphique combiné.
+ */
+export declare function buildComboPlan(categories: string[], series: ComboSeries[], options?: ComboPlanOptions): ChartPlan;

package/dist/chart-plan/geometry/funnel.d.ts

@@ -0,0 +1,60 @@
+import type { ChartPlan } from "../types";
+export interface FunnelStep {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface FunnelPlanOptions {
+    width?: number;
+    height?: number;
+    showPercent?: boolean;
+    measureLabel?: string;
+    colors?: {
+        textMedium?: string;
+        brand?: string;
+        border?: string;
+    };
+}
+export interface FunnelStepLayout {
+    label: string;
+    value: number;
+    percent: number;
+    top: number;
+    left: number;
+    height: number;
+}
+export interface FunnelMargin {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}
+/** Dimensions d'une étape, telles que calculées par `calculateFunnelSteps`. */
+type StepDimensions = Pick<FunnelStepLayout, "top" | "left" | "height">;
+/**
+ * Regroupe les étapes qui portent le même libellé en additionnant leur
+ * mesure. L'ordre d'apparition du premier libellé est conservé.
+ */
+export declare function groupFunnelSteps(steps: FunnelStep[]): FunnelStep[];
+/**
+ * Trie les étapes par valeur décroissante — l'ordre d'un entonnoir. La
+ * liste d'entrée n'est pas mutée.
+ */
+export declare function reorderFunnelSteps(steps: FunnelStep[]): FunnelStep[];
+/**
+ * Positionne chaque étape le long de l'entonnoir : la bande est centrée
+ * verticalement et sa hauteur est proportionnelle à la mesure.
+ */
+export declare function calculateFunnelSteps(steps: FunnelStep[], stepWidth: number, funnelHeight: number): FunnelStepLayout[];
+/** Opacité décroissante des bandes, de la première à la dernière. */
+export declare function calculateStepOpacity(index: number, stepsCount: number): number;
+/**
+ * Points du quadrilatère qui relie une étape à la suivante : le bord gauche
+ * suit la hauteur de l'étape courante, le bord droit celle de l'étape
+ * suivante — la bande se resserre donc vers le bas.
+ */
+export declare function calculateFunnelPolygonPoints(step: StepDimensions, nextStep: StepDimensions, marginTop: number): [number, number][];
+/** Marges du plan : elles dépendent du texte le plus large. */
+export declare function calculateFunnelMargin(steps: FunnelStep[], measureLabel: string): FunnelMargin;
+export declare function buildFunnelPlan(steps: FunnelStep[], options?: FunnelPlanOptions): ChartPlan;
+export {};

package/dist/chart-plan/geometry/gauge-segmented.d.ts

@@ -0,0 +1,58 @@
+import type { ChartPlan, TextAnchor } from "../types";
+export declare const BASE_FONT_SIZE = 56;
+export declare const SEGMENT_LABEL_FONT_SIZE: number;
+export declare const CHART_VERTICAL_MARGIN = 40;
+export declare const VALUE_MARGIN = 30;
+export declare const SEGMENT_LABEL_MARGIN: number;
+export declare const DISTANCE_TO_MIDDLE_LABEL_ANCHOR: number;
+export declare const CHART_WIDTH = 540;
+export declare const GAUGE_OUTER_RADIUS: number;
+export declare const GAUGE_INNER_RADIUS: number;
+export declare const CHART_HEIGHT: number;
+export declare const MAX_SEGMENT_VALUE_WIDTH = 150;
+export declare const GAUGE_ARC_ANGLE: number;
+export declare const START_ANGLE: number;
+export declare const END_ANGLE: number;
+export declare const SEGMENT_LABEL_ANCHOR_THRESHOLD_ANGLE: number;
+export interface GaugeSegmentInput {
+    min: number;
+    max: number;
+    label?: string;
+    color?: string;
+}
+export interface SegmentedGaugePlanOptions {
+    value?: number;
+    width?: number;
+    height?: number;
+    showNeedle?: boolean;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    colors?: {
+        background?: string;
+        value?: string;
+        label?: string;
+        outline?: string;
+        needle?: string;
+    };
+    segmentColors?: string[];
+}
+export interface GaugeLabelData {
+    position: [number, number];
+    textAnchor: TextAnchor;
+    value: string;
+    color: string;
+}
+export declare function limit(value: number, min: number, max: number): number;
+export declare function calculateRelativeValueAngle(value: number, minValue: number, maxValue: number): number;
+export declare function getCirclePositionInSvgCoordinate(radius: number, angleRadian: number): [number, number];
+export declare function calculateValueFontSize(displayValue: string, maxWidth: number): number;
+export declare function calculateSegmentLabelPosition(angle: number): [number, number];
+export declare function calculateSegmentLabelTextAnchor(angle: number): TextAnchor;
+export declare function calculateChartScale(gaugeLabels: GaugeLabelData[]): number;
+export declare function gaugeAccessor(segment: GaugeSegmentInput): number;
+export declare function gaugeSorter(thisSegment: GaugeSegmentInput, thatSegment: GaugeSegmentInput): number;
+export declare function fixSwappedMinMax(segment: GaugeSegmentInput): GaugeSegmentInput;
+export declare function removeDuplicateElements(uniqueList: number[], element: number): number[];
+/** Secteur annulaire entre deux angles, en occupant la bande de la jauge. */
+export declare function annularSectorPath(innerRadius: number, outerRadius: number, startAngle: number, endAngle: number): string;
+export declare function buildSegmentedGaugePlan(segments: GaugeSegmentInput[], options?: SegmentedGaugePlanOptions): ChartPlan;

package/dist/chart-plan/geometry/gauge.d.ts

@@ -0,0 +1,12 @@
+import type { ChartPlan } from "../types";
+export interface GaugeOptions {
+    width?: number;
+    height?: number;
+    min?: number;
+    max?: number;
+    title?: string;
+    unit?: string;
+    lowThreshold?: number;
+    highThreshold?: number;
+}
+export declare function buildGaugePlan(score: number, options?: GaugeOptions): ChartPlan;