@lynxflow/seo-engine 2.8.0 → 3.2.1

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

@@ -0,0 +1,44 @@
+export { buildBarPlan } from "./bar";
+export type { BarChartOptions, BarItem } from "./bar";
+export { buildBoxPlotPlan, computeBoxPlotStats, computeQuantile, getBoxPlotBoxWidth, getBoxPlotSymbolSize, } from "./boxplot";
+export type { BoxPlotCategory, BoxPlotColors, BoxPlotPlanOptions, BoxPlotStats, BoxPlotWhiskerType, } from "./boxplot";
+export { buildBottomAxis, buildGridLines, buildLeftAxis, AXIS_DEFAULTS, } from "./cartesian/axes";
+export type { AxisOptions, AxisTick } from "./cartesian/axes";
+export { computeCartesianLayout } from "./cartesian/layout";
+export type { CartesianBounds, CartesianLayout, CartesianLayoutInput, Padding, } from "./cartesian/layout";
+export { buildAreaPath, buildBarRects, buildLinePath, round, } from "./cartesian/series";
+export type { BarRect, SeriesPoint } from "./cartesian/series";
+export { createBandScale, createLinearScale, extent, niceTicks, } from "./cartesian/scales";
+export type { BandScale, LinearScale } from "./cartesian/scales";
+export { buildChoroplethPlan, canonicalRegionKey, getFeatureKey, getFeatures, getRegionValues, HEAT_MAP_ZERO_COLOR, interpolateScaleColor, isFeatureCollection, MAP_WIDTH, } from "./choropleth";
+export type { ChoroplethPlanOptions, ChoroplethRegion, GeoJsonData, GeoJsonFeature, GeoJsonFeatureCollection, } from "./choropleth";
+export { buildLegendMarks, buildLegendPlan, calculateLegendRows, calculateLegendRowsWithColumns, legendPalette, } from "./legend";
+export type { LegendItem, LegendLayoutInput, LegendPlanOptions, PositionedLegendItem, } from "./legend";
+export { buildFunnelPlan, calculateFunnelPolygonPoints, calculateFunnelSteps, calculateStepOpacity, groupFunnelSteps, reorderFunnelSteps, } from "./funnel";
+export type { FunnelMargin, FunnelPlanOptions, FunnelStep, FunnelStepLayout, } from "./funnel";
+export { buildGaugePlan } from "./gauge";
+export type { GaugeOptions } from "./gauge";
+export { annularSectorPath, buildSegmentedGaugePlan, calculateChartScale, calculateRelativeValueAngle, calculateSegmentLabelPosition, calculateSegmentLabelTextAnchor, calculateValueFontSize, fixSwappedMinMax, gaugeAccessor, gaugeSorter, getCirclePositionInSvgCoordinate, limit, removeDuplicateElements, } from "./gauge-segmented";
+export type { GaugeLabelData, GaugeSegmentInput, SegmentedGaugePlanOptions, } from "./gauge-segmented";
+export { buildScorecardPlan } from "./scorecard";
+export type { MetricCardInput } from "./scorecard";
+export { buildPiePlan, calculateSliceAngles, pieSlicePath, piePoint } from "./pie";
+export type { PiePlanOptions, PieSlice } from "./pie";
+export { buildProgressBarPlan, calculatePointerLabelShift, calculateProgressMetrics, progressPointerPath, PROGRESS_BAR_LAYOUT, } from "./progress-bar";
+export type { ProgressBarPlanOptions, ProgressMetrics } from "./progress-bar";
+export { buildSparklinePlan } from "./sparkline";
+export type { SparklineOptions } from "./sparkline";
+export { buildOutlinedTextPlan, buildTextPlan } from "./text";
+export type { TextPlanOptions } from "./text";
+export { buildComboPlan } from "./combo";
+export type { ComboPlanOptions, ComboSeries } from "./combo";
+export { buildSankeyPlan, buildLinkPath, computeSankeyLayout } from "./sankey";
+export type { SankeyNode, SankeyLink, SankeyPlanOptions, SankeyColors, SankeyLayoutNode, SankeyLayoutLink, } from "./sankey";
+export { buildTreemapPlan, squarifyTreemap } from "./treemap";
+export type { TreemapNode, TreemapPlanOptions, TreemapRect } from "./treemap";
+export { buildScatterPlan, computeLinearRegression, } from "./scatter";
+export type { LinearRegression, ScatterColors, ScatterPlanOptions, ScatterPoint, } from "./scatter";
+export { buildWaterfallPlan, computeWaterfallBars, } from "./waterfall";
+export type { WaterfallBar, WaterfallColors, WaterfallPlanOptions, WaterfallStep, } from "./waterfall";
+export { buildTrendPlan } from "./trend";
+export type { TimelineAnnotation, TrendChartOptions, TrendPoint, } from "./trend";

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

@@ -0,0 +1,66 @@
+import type { ChartPlan, Mark } from "../types";
+export declare const LEGEND_CIRCLE_SIZE = 10;
+export declare const LEGEND_CIRCLE_MARGIN_RIGHT = 4;
+export declare const LEGEND_ITEM_MARGIN_RIGHT = 24;
+export declare const LEGEND_ITEM_MARGIN_RIGHT_GRID = 16;
+export declare const DEFAULT_LEGEND_FONT_SIZE = 14;
+export declare const DEFAULT_LEGEND_LINE_HEIGHT = 20;
+export declare const DEFAULT_LEGEND_FONT_WEIGHT = 700;
+export interface LegendItem {
+    key: string;
+    name: string;
+    color: string;
+    percent?: string;
+}
+export interface PositionedLegendItem extends LegendItem {
+    left: number;
+    top: number;
+    width?: number;
+}
+export interface LegendLayoutInput {
+    items: LegendItem[];
+    width: number;
+    horizontalPadding?: number;
+    verticalPadding?: number;
+    lineHeight?: number;
+    fontSize?: number;
+    fontWeight?: number;
+    legendItemMarginRight?: number;
+    isReversed?: boolean;
+}
+export interface LegendPlanOptions {
+    width?: number;
+    left?: number;
+    top?: number;
+    fontSize?: number;
+    fontWeight?: number;
+    legendItemMarginRight?: number;
+    markerBorderColor?: string;
+}
+export declare function calculateLegendRows({ items, width, horizontalPadding, verticalPadding, lineHeight, fontSize, fontWeight, legendItemMarginRight, isReversed, }: LegendLayoutInput): {
+    items: PositionedLegendItem[];
+    height: number;
+    width: number;
+};
+export declare function calculateNumRowsCols(items: LegendItem[], width: number, fontSize: number, fontWeight: number, legendItemMarginRight: number): {
+    numRows: number;
+    numCols: number;
+};
+export declare function calculateLegendRowsWithColumns({ items, width, horizontalPadding, verticalPadding, lineHeight, fontSize, fontWeight, legendItemMarginRight, isReversed, }: LegendLayoutInput): {
+    items: PositionedLegendItem[];
+    height: number;
+    width: number;
+};
+/**
+ * Construit les marks d'une légende : une pastille colorée par entrée,
+ * son libellé, et son pourcentage (aligné à droite en disposition en grille,
+ * accolé au libellé sinon).
+ */
+export declare function buildLegendPlan(items: LegendItem[], options?: LegendPlanOptions): ChartPlan;
+export declare function legendPalette(items: PositionedLegendItem[]): string[];
+/**
+ * Marks d'une légende dont la disposition est déjà calculée : une pastille
+ * colorée par entrée, son libellé, et son pourcentage (aligné à droite en
+ * disposition en grille, accolé au libellé sinon).
+ */
+export declare function buildLegendMarks(items: PositionedLegendItem[], options?: LegendPlanOptions): Mark[];

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

@@ -0,0 +1,28 @@
+import type { ChartPlan } from "../types";
+export interface PieSlice {
+    label: string;
+    value: number;
+    color?: string;
+}
+export interface PiePlanOptions {
+    width?: number;
+    height?: number;
+    legend?: "none" | "bottom" | "side";
+    colors?: string[];
+    showPercent?: boolean;
+}
+/** Point du cercle, l'angle 0 correspondant au haut de l'horloge. */
+export declare function piePoint(centerX: number, centerY: number, radius: number, angle: number): [number, number];
+/** Secteur de disque entre deux angles, parcouru dans le sens horaire. */
+export declare function pieSlicePath(centerX: number, centerY: number, radius: number, startAngle: number, endAngle: number): string;
+/**
+ * Angles de chaque part, en partant de midi et en tournant dans le sens
+ * horaire. Les parts de valeur nulle sont écartées.
+ */
+export declare function calculateSliceAngles(slices: PieSlice[]): {
+    slice: PieSlice;
+    startAngle: number;
+    endAngle: number;
+    share: number;
+}[];
+export declare function buildPiePlan(slices: PieSlice[], options?: PiePlanOptions): ChartPlan;

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

@@ -0,0 +1,46 @@
+import type { ChartPlan } from "../types";
+export declare const PROGRESS_BAR_LAYOUT: {
+    readonly width: 440;
+    readonly height: 110;
+    readonly margin: {
+        readonly top: 40;
+        readonly right: 40;
+        readonly left: 40;
+    };
+    readonly barHeight: 40;
+    readonly borderRadius: 5;
+    readonly labelsMargin: 16;
+    readonly iconSize: 20;
+    readonly pointer: {
+        readonly width: 20;
+        readonly height: 10;
+    };
+    readonly fontSize: 13;
+};
+export interface ProgressBarPlanOptions {
+    width?: number;
+    height?: number;
+    goal?: number;
+    color?: string;
+    trackColor?: string;
+    showGoal?: boolean;
+    showPointer?: boolean;
+    formatValue?: (value: number) => string;
+}
+export interface ProgressMetrics {
+    value: number;
+    goal: number;
+    hasValidValue: boolean;
+    hasValidGoal: boolean;
+    barPercent: number;
+    arrowPercent: number;
+}
+export declare function calculateProgressMetrics(value: number, goal: number): ProgressMetrics;
+/**
+ * Décale horizontalement le libellé de la valeur pour qu'il ne déborde pas
+ * de la barre quand le pointeur est proche d'un bord.
+ */
+export declare function calculatePointerLabelShift(valueText: string, pointerX: number, xMin: number, xMax: number, pointerWidth: number, fontSize: number): number;
+/** Triangle du pointeur, base en haut et pointe en bas. */
+export declare function progressPointerPath(centerX: number, topY: number, width: number, height: number): string;
+export declare function buildProgressBarPlan(value: number, options?: ProgressBarPlanOptions): ChartPlan;

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

@@ -0,0 +1,90 @@
+/**
+ * Diagramme de flux (Sankey).
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/graph/sankey/`),
+ * dont la disposition des nœuds est calculée par ECharts. On la réécrit ici : le
+ * nœud est placé dans un niveau (la distance la plus longue depuis une source),
+ * sa hauteur est proportionnelle à son flux total, et les liens sont tracés en
+ * courbes de Bézier.
+ *
+ * Le placement vertical suit l'algorithme de relaxation de d3-sankey, réduit à
+ * son essentiel : les nœuds d'un niveau sont répartis puis recentrés sur le
+ * barycentre de leurs voisins.
+ *
+ * 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 SankeyNode {
+    id: string;
+    label?: string;
+}
+export interface SankeyLink {
+    source: string;
+    target: string;
+    value: number;
+    color?: string;
+}
+export interface SankeyColors {
+    node?: string;
+    link?: string;
+    label?: string;
+}
+export interface SankeyPlanOptions {
+    width?: number;
+    height?: number;
+    nodeWidth?: number;
+    nodePadding?: number;
+    colors?: SankeyColors;
+    valueFormat?: (value: number) => string;
+}
+export interface SankeyLayoutNode {
+    id: string;
+    label: string;
+    /** Niveau (colonne) du nœud, en partant de 0 pour les sources. */
+    level: number;
+    /** Flux total entrant et sortant. */
+    value: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** Flux sortant et entrant. */
+    sourceValue: number;
+    targetValue: number;
+    sourceLinks: SankeyLayoutLink[];
+    targetLinks: SankeyLayoutLink[];
+}
+export interface SankeyLayoutLink {
+    source: SankeyLayoutNode;
+    target: SankeyLayoutNode;
+    value: number;
+    color?: string;
+    /** Position verticale du bord supérieur du lien sur son nœud source. */
+    sourceY: number;
+    /** Position verticale du bord supérieur du lien sur son nœud cible. */
+    targetY: number;
+}
+/**
+ * Calcule la disposition d'un Sankey : niveaux, tailles et positions.
+ *
+ * Le niveau d'un nœud est la longueur du plus long chemin qui y mène depuis une
+ * source. Un cycle est neutralisé : le niveau d'un nœud déjà en cours de visite
+ * vaut 0, ce qui termine la récursion sans boucler.
+ */
+export declare function computeSankeyLayout(nodes: SankeyNode[], links: SankeyLink[], options: {
+    width: number;
+    height: number;
+    nodeWidth: number;
+    nodePadding: number;
+}): {
+    nodes: SankeyLayoutNode[];
+    links: SankeyLayoutLink[];
+    unit: number;
+};
+/** Courbe de Bézier entre deux points, avec une horizontale aux extrémités. */
+export declare function buildLinkPath(x0: number, y0: number, x1: number, y1: number, thickness: number): string;
+/**
+ * Construit le plan d'un diagramme de flux.
+ */
+export declare function buildSankeyPlan(nodes: SankeyNode[], links: SankeyLink[], options?: SankeyPlanOptions): ChartPlan;

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

@@ -0,0 +1,61 @@
+/**
+ * Nuage de points.
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/scatter/`).
+ * En amont, la placement des points et la droite de tendance sont calculés par
+ * les options ECharts, qui ne sont pas copiables sans embarquer ECharts ; on
+ * réécrit ici le calcul de régression et la projection des points.
+ *
+ * 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 ScatterPoint {
+    x: number;
+    y: number;
+    size?: number;
+    label?: string;
+    color?: string;
+}
+export interface ScatterColors {
+    point?: string;
+    trendLine?: string;
+    axis?: string;
+    label?: string;
+}
+export interface ScatterPlanOptions {
+    width?: number;
+    height?: number;
+    showTrendLine?: boolean;
+    pointSize?: number;
+    colors?: ScatterColors;
+    xLabel?: string;
+    yLabel?: string;
+    valueFormat?: (value: number) => string;
+    yAxisWidth?: number;
+    xAxisHeight?: number;
+}
+export interface LinearRegression {
+    slope: number;
+    intercept: number;
+    r2: number;
+    /** Point d'entrée de la droite de régression, sur le domaine des abscisses. */
+    start: {
+        x: number;
+        y: number;
+    };
+    /** Point d'arrivée de la droite de régression. */
+    end: {
+        x: number;
+        y: number;
+    };
+}
+/**
+ * Régression linéaire au sens des moindres carrés. La droite est tracée entre les
+ * abscisses extrêmes : `r2` vaut 1 quand tous les points sont alignés.
+ */
+export declare function computeLinearRegression(points: ScatterPoint[]): LinearRegression;
+/**
+ * Construit le plan d'un nuage de points.
+ */
+export declare function buildScatterPlan(points: ScatterPoint[], options?: ScatterPlanOptions): ChartPlan;

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

@@ -0,0 +1,11 @@
+import type { ChartPlan } from "../types";
+export interface MetricCardInput {
+    title: string;
+    value: string | number;
+    previousValue?: string | number;
+    changePercent?: number;
+    trend?: "up" | "down" | "flat";
+    sparkline?: number[];
+    unit?: string;
+}
+export declare function buildScorecardPlan(card: MetricCardInput): ChartPlan;

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

@@ -0,0 +1,10 @@
+import type { ChartPlan } from "../types";
+export interface SparklineOptions {
+    width?: number;
+    height?: number;
+    strokeColor?: string;
+    fillColor?: string;
+    strokeWidth?: number;
+    showEndDot?: boolean;
+}
+export declare function buildSparklinePlan(values: number[], options?: SparklineOptions): ChartPlan;

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

@@ -0,0 +1,25 @@
+import type { ChartPlan, Mark } from "../types";
+export interface TextPlanOptions {
+    x?: number;
+    y?: number;
+    size?: number;
+    weight?: number;
+    fill?: string;
+    anchor?: "start" | "middle" | "end";
+    outline?: {
+        color: string;
+        width: number;
+    };
+}
+type TextMark = Extract<Mark, {
+    kind: "text";
+}>;
+export declare function buildTextPlan(text: string, options?: TextPlanOptions): ChartPlan;
+export declare function buildOutlinedTextPlan(text: string, options?: TextPlanOptions): ChartPlan;
+/**
+ * Marks d'un texte à contour : le contour d'abord, le fond par-dessus.
+ * Utilisé tel quel par les jauges, dont les libellés sont contournés pour
+ * rester lisibles sur un secteur coloré.
+ */
+export declare function buildOutlinedTextMarks(text: string, options?: TextPlanOptions): TextMark[];
+export {};

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

@@ -0,0 +1,51 @@
+/**
+ * Carte de chaleur hiérarchique (treemap).
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/graph/treemap/`),
+ * dont la disposition des rectangles est calculée par ECharts. On la réécrit ici
+ * avec l'algorithme *squarify* de Bruls, Huizing et van Wijk (2000), qui range
+ * les éléments en rangées de rapport d'aspect le plus carré possible.
+ *
+ * Le découpage est ici plat : la liste fournie est déjà la liste des feuilles.
+ *
+ * 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 TreemapNode {
+    id: string;
+    label?: string;
+    value: number;
+    color?: string;
+}
+export interface TreemapPlanOptions {
+    width?: number;
+    height?: number;
+    padding?: number;
+    colors?: string[];
+    valueFormat?: (value: number) => string;
+}
+export interface TreemapRect {
+    id: string;
+    label: string;
+    value: number;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    color?: string;
+}
+/**
+ * Répartit les valeurs dans la boîte selon l'algorithme *squarify*.
+ * La surface totale des rectangles est égale à celle de la boîte.
+ */
+export declare function squarifyTreemap(nodes: TreemapNode[], box: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}): TreemapRect[];
+/**
+ * Construit le plan d'une carte de chaleur.
+ */
+export declare function buildTreemapPlan(nodes: TreemapNode[], options?: TreemapPlanOptions): ChartPlan;

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

@@ -0,0 +1,32 @@
+import type { ChartPlan } from "../types";
+import type { TimelineMarker } from "../../timelines/projection";
+export interface TrendPoint {
+    date: string;
+    value: number;
+}
+/**
+ * Jalon daté affiché sur la série.
+ *
+ * C'est la forme qu'un appelant fournit : il connaît une date et un libellé,
+ * pas l'identifiant stable qu'exige la projection. `buildTrendPlan` dérive
+ * cet identifiant de la position dans la liste, ce qui reste déterministe.
+ */
+export interface TimelineAnnotation {
+    /** Date ISO : `YYYY`, `YYYY-MM`, `YYYY-MM-DD` ou horodatage complet. */
+    date: string;
+    label: string;
+    color?: string;
+}
+export interface TrendChartOptions {
+    width?: number;
+    height?: number;
+    title?: string;
+    strokeColor?: string;
+    showArea?: boolean;
+    /** Jalons projetés sur l'axe des abscisses. */
+    events?: TimelineMarker[];
+    /** Raccourci pour des jalons sans identifiant explicite. */
+    annotations?: TimelineAnnotation[];
+    yAxisLabel?: string;
+}
+export declare function buildTrendPlan(points: TrendPoint[], options?: TrendChartOptions): ChartPlan;

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

@@ -0,0 +1,51 @@
+/**
+ * Diagramme en cascade (waterfall).
+ *
+ * Réécriture d'après Metabase (`frontend/src/metabase/viz-core/echarts/cartesian/waterfall/`).
+ * En amont, la géométrie est calculée par les options ECharts, qui ne sont pas
+ * copiables sans embarquer ECharts ; on réécrit donc ici la logique de cumul :
+ * chaque barre s'appuie sur la fin de la précédente, et une barre de total
+ * repart de zéro pour figurer le cumul.
+ *
+ * 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 WaterfallStep {
+    label: string;
+    value: number;
+    /** Barre de total : repart de zéro et vaut le cumul des barres précédentes. */
+    isTotal?: boolean;
+    color?: string;
+}
+export interface WaterfallColors {
+    increase?: string;
+    decrease?: string;
+    total?: string;
+}
+export interface WaterfallPlanOptions {
+    width?: number;
+    height?: number;
+    colors?: WaterfallColors;
+    showConnectors?: boolean;
+    valueFormat?: (value: number) => string;
+    yAxisWidth?: number;
+    xAxisHeight?: number;
+}
+export interface WaterfallBar {
+    label: string;
+    value: number;
+    start: number;
+    end: number;
+    isTotal: boolean;
+    color: string;
+}
+/**
+ * Calcule les positions cumulées de chaque barre. Une barre de total repart de zéro
+ * et vaut le cumul reached à ce point.
+ */
+export declare function computeWaterfallBars(steps: WaterfallStep[], colors?: Required<WaterfallColors>): WaterfallBar[];
+/**
+ * Construit le plan d'un diagramme en cascade.
+ */
+export declare function buildWaterfallPlan(steps: WaterfallStep[], options?: WaterfallPlanOptions): ChartPlan;

package/dist/chart-plan/port/color.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Adaptation, et non copie : l'upstream de Metabase s'appuie sur le paquet
+ * `color` (MIT) pour analyser et mélanger les couleurs. Le moteur LynxSEO
+ * n'ajoute pas de dépendance runtime, on réimplémente donc le strict
+ * nécessaire : les couleurs du port sont toujours des chaînes hexadécimales
+ * ou `rgb(...)`, ce qui couvre l'ensemble des besoins des graphiques.
+ */
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/** Analyse une couleur hexadécimale (`#rgb`, `#rrggbb`) ou `rgb(r,g,b)`. */
+export declare function toRgb(color: string): Rgb;
+/** Reconstruit une couleur hexadécimale à partir de ses composantes. */
+export declare function fromRgb({ r, g, b }: Rgb): string;
+/**
+ * Mélange deux couleurs. `weight` vaut 0 pour `color` et 1 pour `other`.
+ * Le résultat est arrondi au canal entier : la sortie est donc stable
+ * d'une exécution à l'autre.
+ */
+export declare function mixColors(color: string, other: string, weight: number): string;
+/**
+ * Éclaircit (`amount` > 0) ou assombrit (`amount` < 0) une couleur.
+ * `amount` est borné à [-1, 1].
+ */
+export declare function shade(color: string, amount: number): string;

package/dist/chart-plan/port/constants.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Taille de police et graisse de référence utilisées pour la mesure de texte.
+ * Ces deux valeurs sont celles de la police de référence de l'upstream ; la
+ * table de métriques complète n'est pas reprise (voir `port/text.ts` pour le
+ * motif : elle n'est décodable que par une dépendance runtime interdite).
+ */
+export declare const CHAR_SIZES_FONT_SIZE = 10;
+export declare const CHAR_SIZES_FONT_WEIGHT = 400;

package/dist/chart-plan/port/numbers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Adaptation, et non copie : Metabase formate ses nombres via `Intl`, dont le
+ * rendu dépend des données de locale installées sur l'hôte (différentes
+ * entre un Worker, Node et un navigateur). Le moteur LynxSEO produit des
+ * SVG destinés à être comparés d'une exécution à l'autre : le formatage est
+ * donc **manuel** et déterministe, avec la convention française (séparateur
+ * de milliers : espace insécable fin ; séparateur décimal : virgule).
+ */
+export interface NumberFormatOptions {
+    /** Nombre de décimales. 0 par défaut. */
+    decimals?: number;
+    /** Forme abrégée (k, M, Md). */
+    compact?: boolean;
+}
+/**
+ * Formate un nombre à la française. Une valeur non finie rend `"-"` :
+ * un `NaN` dans un SVG se lirait « NaN » à l'écran, ce qui n'aide personne.
+ */
+export declare function formatNumber(value: number, options?: NumberFormatOptions): string;
+/**
+ * Formate un ratio (0.42) en pourcentage (« 42 % »). La valeur attendue est
+ * une fraction, pas un pourcentage déjà multiplié.
+ */
+export declare function formatPercent(value: number, options?: NumberFormatOptions): string;

package/dist/chart-plan/port/text.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Adaptation, et non copie : Metabase mesure le texte via `server-text-width`
+ * (`init(CHAR_SIZES)`), où `CHAR_SIZES` est un encodage compressé de 528
+ * lignes qui n'est décodable que par ce paquet. L'ajouter violerait la
+ * contrainte « aucune nouvelle dépendance runtime » du moteur, et le moteur
+ * n'a ni DOM ni canvas.
+ *
+ * Nous utilisons donc une **approximation déterministe** : une table
+ * d'avance relative par caractère, appliquée à la taille de police. L'écart
+ * avec la police de référence reste borné à environ ±8 %, ce qui affecte le
+ * placement des libellés mais jamais la topologie des graphiques.
+ */
+/**
+ * Largeur approximative d'un texte, en unités de la taille de police.
+ * La graisse élargit légèrement le texte, comme sur la police de référence.
+ */
+export declare function measureTextWidth(text: string, fontSize: number, fontWeight?: number): number;
+/** Hauteur de ligne approximative, en unités de la taille de police. */
+export declare function measureTextHeight(fontSize: number): number;
+/**
+ * Tronque un texte pour qu'il tienne dans `maxWidth`, en ajoutant une
+ * ellipse. Si le texte tient déjà, il est rendu tel quel. La recherche du
+ * plus long préfixe qui tient se fait par **recherche dichotomique** : la
+ * largeur d'un texte n'étant pas linéaire, un balayage caractère par
+ * caractère coûterait O(n) mesures au lieu de O(log n).
+ */
+export declare function truncateText(text: string, maxWidth: number, fontSize: number, fontWeight?: number): string;

package/dist/chart-plan/renderers/svg.d.ts

@@ -0,0 +1,11 @@
+import type { ChartPlan } from "../types";
+/**
+ * Renderer SVG headless : `ChartPlan` → chaîne SVG.
+ *
+ * Zéro dépendance, zéro DOM, s'exécute dans un Worker. Utilisé par
+ * `exporters/branded-analytics-report.ts`, `seo-chart-spec.ts`,
+ * `mcp-seo-server.ts` et `PulseBrandedReport.ts`.
+ */
+export declare function escapeXml(str: string): string;
+/** Sérialise un plan en document SVG autonome. */
+export declare function renderPlanToSvg(plan: ChartPlan): string;