@opendata-ai/openchart-engine 6.11.0 → 6.13.0

package/src/compiler/__tests__/normalize.test.ts

@@ -1,12 +1,15 @@
 import type {
   ChartSpec,
   GraphSpec,
+  LayerSpec,
   RangeAnnotation,
   RefLineAnnotation,
+  SankeySpec,
   TableSpec,
   TextAnnotation,
 } from '@opendata-ai/openchart-core';
 import { describe, expect, it } from 'vitest';
+import type { NormalizedSankeySpec } from '../../sankey/types';
 import { normalizeSpec } from '../normalize';
 import type { NormalizedChartSpec, NormalizedGraphSpec, NormalizedTableSpec } from '../types';
 
@@ -52,6 +55,17 @@ describe('normalizeSpec', () => {
       });
     });
 
+    it('watermark defaults to true when not specified', () => {
+      const result = normalizeSpec(lineSpec) as NormalizedChartSpec;
+      expect(result.watermark).toBe(true);
+    });
+
+    it('watermark respects explicit false', () => {
+      const spec: ChartSpec = { ...lineSpec, watermark: false };
+      const result = normalizeSpec(spec) as NormalizedChartSpec;
+      expect(result.watermark).toBe(false);
+    });
+
     it('preserves explicit values', () => {
       const spec: ChartSpec = {
         ...lineSpec,
@@ -205,6 +219,27 @@ describe('normalizeSpec', () => {
       expect(result.responsive).toBe(true);
       expect(result.darkMode).toBe('off');
     });
+
+    it('watermark defaults to true when not specified', () => {
+      const spec: TableSpec = {
+        type: 'table',
+        data: [{ name: 'Alice', age: 30 }],
+        columns: [{ key: 'name' }, { key: 'age' }],
+      };
+      const result = normalizeSpec(spec) as NormalizedTableSpec;
+      expect(result.watermark).toBe(true);
+    });
+
+    it('watermark respects explicit false', () => {
+      const spec: TableSpec = {
+        type: 'table',
+        data: [{ name: 'Alice', age: 30 }],
+        columns: [{ key: 'name' }, { key: 'age' }],
+        watermark: false,
+      };
+      const result = normalizeSpec(spec) as NormalizedTableSpec;
+      expect(result.watermark).toBe(false);
+    });
   });
 
   describe('graph spec normalization', () => {
@@ -221,5 +256,80 @@ describe('normalizeSpec', () => {
       expect(result.annotations).toEqual([]);
       expect(result.darkMode).toBe('off');
     });
+
+    it('watermark defaults to true when not specified', () => {
+      const spec: GraphSpec = {
+        type: 'graph',
+        nodes: [{ id: 'a' }, { id: 'b' }],
+        edges: [{ source: 'a', target: 'b' }],
+      };
+      const result = normalizeSpec(spec) as NormalizedGraphSpec;
+      expect(result.watermark).toBe(true);
+    });
+
+    it('watermark respects explicit false', () => {
+      const spec: GraphSpec = {
+        type: 'graph',
+        nodes: [{ id: 'a' }, { id: 'b' }],
+        edges: [{ source: 'a', target: 'b' }],
+        watermark: false,
+      };
+      const result = normalizeSpec(spec) as NormalizedGraphSpec;
+      expect(result.watermark).toBe(false);
+    });
+  });
+
+  describe('sankey spec normalization', () => {
+    const baseSankeySpec: SankeySpec = {
+      type: 'sankey',
+      data: [{ source: 'A', target: 'B', value: 10 }],
+      encoding: {
+        source: { field: 'source' },
+        target: { field: 'target' },
+        value: { field: 'value' },
+      },
+    };
+
+    it('watermark defaults to true when not specified', () => {
+      const result = normalizeSpec(baseSankeySpec) as NormalizedSankeySpec;
+      expect(result.watermark).toBe(true);
+    });
+
+    it('watermark respects explicit false', () => {
+      const spec: SankeySpec = { ...baseSankeySpec, watermark: false };
+      const result = normalizeSpec(spec) as NormalizedSankeySpec;
+      expect(result.watermark).toBe(false);
+    });
+  });
+
+  describe('layer spec normalization', () => {
+    const baseLeaf: ChartSpec = {
+      mark: 'line',
+      data: [{ x: 1, y: 2 }],
+      encoding: {
+        x: { field: 'x', type: 'quantitative' },
+        y: { field: 'y', type: 'quantitative' },
+      },
+    };
+
+    it('watermark defaults to true for layer leaves', () => {
+      const layerSpec: LayerSpec = { layer: [baseLeaf] };
+      const result = normalizeSpec(layerSpec) as NormalizedChartSpec;
+      expect(result.watermark).toBe(true);
+    });
+
+    it('layer-level watermark: false propagates to leaves', () => {
+      const layerSpec: LayerSpec = { layer: [baseLeaf], watermark: false };
+      const result = normalizeSpec(layerSpec) as NormalizedChartSpec;
+      expect(result.watermark).toBe(false);
+    });
+
+    it('leaf-level watermark overrides layer-level', () => {
+      const leaf: ChartSpec = { ...baseLeaf, watermark: true };
+      const layerSpec: LayerSpec = { layer: [leaf], watermark: false };
+      const result = normalizeSpec(layerSpec) as NormalizedChartSpec;
+      // Leaf explicitly sets true, which should be preserved
+      expect(result.watermark).toBe(true);
+    });
   });
 });

package/src/compiler/normalize.ts

@@ -69,8 +69,8 @@ function normalizeChrome(chrome: Chrome | undefined): NormalizedChrome {
 
 /** Sample values from a data column and infer the field type. */
 function inferFieldType(data: DataRow[], field: string): FieldType {
-  // Sample up to 10 rows
-  const sampleSize = Math.min(10, data.length);
+  // Sample up to 50 rows for more reliable inference on mixed/messy data
+  const sampleSize = Math.min(50, data.length);
   let numericCount = 0;
   let dateCount = 0;
   let totalNonNull = 0;
@@ -215,6 +215,7 @@ function normalizeChartSpec(spec: ChartSpec, warnings: string[]): NormalizedChar
     darkMode: spec.darkMode ?? 'off',
     hiddenSeries: spec.hiddenSeries ?? [],
     seriesStyles: spec.seriesStyles ?? {},
+    watermark: spec.watermark ?? true,
   };
 }
 
@@ -233,6 +234,7 @@ function normalizeTableSpec(spec: TableSpec, _warnings: string[]): NormalizedTab
     compact: spec.compact ?? false,
     responsive: spec.responsive ?? true,
     animation: spec.animation,
+    watermark: spec.watermark ?? true,
   };
 }
 
@@ -254,6 +256,7 @@ function normalizeSankeySpec(spec: SankeySpec, _warnings: string[]): NormalizedS
     animation: spec.animation,
     valueFormat: spec.valueFormat,
     linkOpacity: spec.linkOpacity,
+    watermark: spec.watermark ?? true,
   };
 }
 
@@ -282,6 +285,7 @@ function normalizeGraphSpec(spec: GraphSpec, _warnings: string[]): NormalizedGra
     annotations: normalizeAnnotations(spec.annotations),
     theme: spec.theme ?? {},
     darkMode: spec.darkMode ?? 'off',
+    watermark: spec.watermark ?? true,
   };
 }
 
@@ -338,6 +342,7 @@ export function flattenLayers(
   parentData?: DataRow[],
   parentEncoding?: Encoding,
   parentTransforms?: import('@opendata-ai/openchart-core').Transform[],
+  parentWatermark?: boolean,
 ): ChartSpec[] {
   const resolvedData = spec.data ?? parentData;
   const resolvedEncoding: Encoding | undefined =
@@ -345,13 +350,23 @@ export function flattenLayers(
       ? { ...parentEncoding, ...spec.encoding }
       : (spec.encoding ?? parentEncoding);
   const resolvedTransforms = [...(parentTransforms ?? []), ...(spec.transform ?? [])];
+  // Layer-level watermark propagates to children (child can still override)
+  const resolvedWatermark = spec.watermark ?? parentWatermark;
 
   const leaves: ChartSpec[] = [];
 
   for (const child of spec.layer) {
     if (isLayerSpec(child)) {
       // Nested layer: recurse with merged context
-      leaves.push(...flattenLayers(child, resolvedData, resolvedEncoding, resolvedTransforms));
+      leaves.push(
+        ...flattenLayers(
+          child,
+          resolvedData,
+          resolvedEncoding,
+          resolvedTransforms,
+          resolvedWatermark,
+        ),
+      );
     } else {
       // Leaf ChartSpec: merge inherited properties
       const mergedData = child.data ?? resolvedData ?? [];
@@ -365,6 +380,10 @@ export function flattenLayers(
         data: mergedData,
         encoding: mergedEncoding,
         transform: mergedTransforms.length > 0 ? mergedTransforms : undefined,
+        // Inherit parent watermark if child doesn't explicitly set one
+        ...(child.watermark === undefined && resolvedWatermark !== undefined
+          ? { watermark: resolvedWatermark }
+          : {}),
       });
     }
   }

package/src/compiler/types.ts

@@ -78,6 +78,8 @@ export interface NormalizedChartSpec {
   responsive: boolean;
   theme: ThemeConfig;
   darkMode: DarkMode;
+  /** Whether the tryOpenData.ai watermark is enabled. */
+  watermark: boolean;
   /** Series names to hide from rendering. */
   hiddenSeries: string[];
   /** Per-series visual style overrides. */
@@ -93,6 +95,7 @@ export interface NormalizedTableSpec {
   chrome: NormalizedChrome;
   theme: ThemeConfig;
   darkMode: DarkMode;
+  watermark: boolean;
   search: boolean;
   pagination: boolean | { pageSize: number };
   stickyFirstColumn: boolean;
@@ -113,6 +116,7 @@ export interface NormalizedGraphSpec {
   annotations: Annotation[];
   theme: ThemeConfig;
   darkMode: DarkMode;
+  watermark: boolean;
 }
 
 /** Discriminated union of all normalized spec types. */

package/src/graphs/compile-graph.ts

@@ -194,6 +194,10 @@ export function compileGraph(spec: unknown, options: CompileOptions): GraphCompi
 
   const graphSpec = normalized as NormalizedGraphSpec;
 
+  // Resolve watermark: explicit spec value wins, then options fallback, then default true.
+  const rawWatermark = (spec as Record<string, unknown>).watermark;
+  const watermark = rawWatermark !== undefined ? graphSpec.watermark : (options.watermark ?? true);
+
   // 2. Resolve theme
   const mergedThemeConfig = options.theme
     ? { ...graphSpec.theme, ...options.theme }
@@ -288,6 +292,9 @@ export function compileGraph(spec: unknown, options: CompileOptions): GraphCompi
     theme,
     options.width,
     options.measureText,
+    'full',
+    undefined,
+    watermark,
   );
 
   // 12. Return compilation
@@ -304,6 +311,7 @@ export function compileGraph(spec: unknown, options: CompileOptions): GraphCompi
       height: options.height,
     },
     simulationConfig,
+    watermark,
   };
 }
 

package/src/graphs/types.ts

@@ -101,4 +101,6 @@ export interface GraphCompilation {
   dimensions: { width: number; height: number };
   /** Force simulation configuration. */
   simulationConfig: SimulationConfig;
+  /** Whether to show the brand watermark. */
+  watermark: boolean;
 }

package/src/layout/axes.ts

@@ -399,8 +399,7 @@ export function computeAxes(
 
     // Auto-rotate labels when band scale labels would overlap.
     // Uses max label width (not average) since one long label is enough to overlap.
-    // Prefer labelAngle over deprecated tickAngle
-    let tickAngle = axisConfig?.labelAngle ?? axisConfig?.tickAngle;
+    let tickAngle = axisConfig?.labelAngle;
     if (tickAngle === undefined && scales.x.type === 'band' && ticks.length > 1) {
       const bandwidth = (scales.x.scale as ScaleBand<string>).bandwidth();
       let maxLabelWidth = 0;
@@ -414,8 +413,7 @@ export function computeAxes(
       }
     }
 
-    // Prefer title over deprecated label
-    const axisTitle = axisConfig?.title ?? axisConfig?.label;
+    const axisTitle = axisConfig?.title;
 
     result.x = {
       ticks,
@@ -454,21 +452,20 @@ export function computeAxes(
       allTicks = continuousTicks(scales.y, yDensity);
     }
 
-    // Gridlines use the full tick set (label thinning shouldn't remove gridlines).
-    const gridlines: Gridline[] = allTicks.map((t) => ({
-      position: t.position,
-      major: true,
-    }));
-
     // Thin tick labels to prevent overlap (skip for band scales, explicit tickCount, and values).
     const shouldThin = scales.y.type !== 'band' && !axisConfig?.tickCount && !axisConfig?.values;
     const ticks = shouldThin
       ? thinTicksUntilFit(allTicks, fontSize, fontWeight, measureText)
       : allTicks;
 
-    // Prefer title over deprecated label, labelAngle over deprecated tickAngle
-    const axisTitle = axisConfig?.title ?? axisConfig?.label;
-    const tickAngle = axisConfig?.labelAngle ?? axisConfig?.tickAngle;
+    // Gridlines match the tick set so every gridline has a label.
+    const gridlines: Gridline[] = ticks.map((t) => ({
+      position: t.position,
+      major: true,
+    }));
+
+    const axisTitle = axisConfig?.title;
+    const tickAngle = axisConfig?.labelAngle;
 
     result.y = {
       ticks,

package/src/layout/dimensions.ts

@@ -96,6 +96,7 @@ export function computeDimensions(
   legendLayout: LegendLayout,
   theme: ResolvedTheme,
   strategy?: LayoutStrategy,
+  watermark: boolean = true,
 ): LayoutDimensions {
   const { width, height } = options;
 
@@ -111,6 +112,7 @@ export function computeDimensions(
     options.measureText,
     chromeMode,
     padding,
+    watermark,
   );
 
   // Start with the total rect
@@ -123,9 +125,9 @@ export function computeDimensions(
   // Estimate x-axis height below chart area: tick labels sit 14px below,
   // axis title sits 35px below. These extend past the chart area bottom
   // and source/footer chrome must be positioned below them.
-  const xAxis = encoding.x?.axis as (Record<string, unknown> & { tickAngle?: number }) | undefined;
-  const hasXAxisLabel = !!xAxis?.label;
-  const xTickAngle = xAxis?.tickAngle;
+  const xAxis = encoding.x?.axis as (Record<string, unknown> & { labelAngle?: number }) | undefined;
+  const hasXAxisLabel = !!xAxis?.title;
+  const xTickAngle = xAxis?.labelAngle;
 
   let xAxisHeight: number;
   if (isRadial) {
@@ -334,6 +336,7 @@ export function computeDimensions(
       options.measureText,
       fallbackMode as 'compact' | 'hidden',
       padding,
+      watermark,
     );
 
     // Recalculate top/bottom margins with stripped chrome

package/src/layout/scales.ts

@@ -140,6 +140,25 @@ function uniqueStrings(values: unknown[]): string[] {
   return result;
 }
 
+/**
+ * Apply sort order to categorical domain values (Vega-Lite aligned).
+ * - 'ascending': sort alphabetically/numerically ascending
+ * - 'descending': sort descending
+ * - null: preserve data order (no sorting)
+ * - undefined: ascending (VL default)
+ */
+function applyCategoricalSort(
+  values: string[],
+  sort: 'ascending' | 'descending' | null | undefined,
+): string[] {
+  // null means use data order
+  if (sort === null) return values;
+
+  const sorted = [...values].sort((a, b) => a.localeCompare(b, undefined, { numeric: true }));
+  if (sort === 'descending') sorted.reverse();
+  return sorted;
+}
+
 // ---------------------------------------------------------------------------
 // Helpers: apply common scale config
 // ---------------------------------------------------------------------------
@@ -439,7 +458,7 @@ function buildBandScale(
 ): ResolvedScale {
   const values = channel.scale?.domain
     ? (channel.scale.domain as string[])
-    : uniqueStrings(fieldValues(data, channel.field));
+    : applyCategoricalSort(uniqueStrings(fieldValues(data, channel.field)), channel.sort);
 
   const padding = channel.scale?.padding ?? 0.35;
   const scale = scaleBand().domain(values).range([rangeStart, rangeEnd]).padding(padding);
@@ -466,7 +485,7 @@ function buildPointScale(
 ): ResolvedScale {
   const values = channel.scale?.domain
     ? (channel.scale.domain as string[])
-    : uniqueStrings(fieldValues(data, channel.field));
+    : applyCategoricalSort(uniqueStrings(fieldValues(data, channel.field)), channel.sort);
 
   const padding = channel.scale?.padding ?? 0.5;
   const scale = scalePoint().domain(values).range([rangeStart, rangeEnd]).padding(padding);
@@ -484,7 +503,11 @@ function buildOrdinalColorScale(
   data: DataRow[],
   palette: string[],
 ): ResolvedScale {
-  const values = uniqueStrings(fieldValues(data, channel.field));
+  // Use explicit domain if provided, otherwise derive from data
+  const explicitDomain = channel.scale?.domain as string[] | undefined;
+  const values = explicitDomain
+    ? explicitDomain.map(String)
+    : applyCategoricalSort(uniqueStrings(fieldValues(data, channel.field)), channel.sort);
 
   const scale = scaleOrdinal<string>().domain(values).range(palette);
 
@@ -622,6 +645,7 @@ export function computeScales(
     // For stacked bars, the x-domain needs the max category sum, not max individual value.
     // Without this, stacked bars would clip past the chart area.
     let xData = data;
+    let xChannel = encoding.x;
     const xStackDisabled = encoding.x.stack === null || encoding.x.stack === false;
     if (
       spec.markType === 'bar' &&
@@ -629,25 +653,51 @@ export function computeScales(
       encoding.x.type === 'quantitative' &&
       !xStackDisabled
     ) {
-      const yField = encoding.y?.field;
-      const xField = encoding.x.field;
-      if (yField) {
-        const sums = new Map<string, number>();
-        for (const row of data) {
-          const cat = String(row[yField] ?? '');
-          const val = Number(row[xField] ?? 0);
-          if (Number.isFinite(val) && val > 0) {
-            sums.set(cat, (sums.get(cat) ?? 0) + val);
+      if (encoding.x.stack === 'normalize') {
+        // Normalize: domain is [0, 1]
+        xChannel = { ...encoding.x, scale: { ...encoding.x.scale, domain: [0, 1], nice: false } };
+      } else if (encoding.x.stack === 'center') {
+        // Center: compute max half-sum for symmetric domain
+        const yField = encoding.y?.field;
+        const xField = encoding.x.field;
+        if (yField) {
+          const sums = new Map<string, number>();
+          for (const row of data) {
+            const cat = String(row[yField] ?? '');
+            const val = Number(row[xField] ?? 0);
+            if (Number.isFinite(val) && val > 0) {
+              sums.set(cat, (sums.get(cat) ?? 0) + val);
+            }
+          }
+          const maxSum = Math.max(...sums.values(), 0);
+          const half = maxSum / 2;
+          xChannel = {
+            ...encoding.x,
+            scale: { ...encoding.x.scale, domain: [-half, half], zero: true },
+          };
+        }
+      } else {
+        // Zero (default): domain extends to max category sum
+        const yField = encoding.y?.field;
+        const xField = encoding.x.field;
+        if (yField) {
+          const sums = new Map<string, number>();
+          for (const row of data) {
+            const cat = String(row[yField] ?? '');
+            const val = Number(row[xField] ?? 0);
+            if (Number.isFinite(val) && val > 0) {
+              sums.set(cat, (sums.get(cat) ?? 0) + val);
+            }
           }
+          const maxSum = Math.max(...sums.values(), 0);
+          // Create a synthetic row with the max stack sum so buildLinearScale sees it
+          xData = [...data, { [xField]: maxSum } as DataRow];
         }
-        const maxSum = Math.max(...sums.values(), 0);
-        // Create a synthetic row with the max stack sum so buildLinearScale sees it
-        xData = [...data, { [xField]: maxSum } as DataRow];
       }
     }
 
     result.x = buildPositionalScale(
-      encoding.x,
+      xChannel,
       xData,
       chartArea.x,
       chartArea.x + chartArea.width,
@@ -662,6 +712,7 @@ export function computeScales(
     // would clip above the chart area.
     // Vertical bar = x is categorical and y is quantitative (old 'column' chart type).
     let yData = data;
+    let yChannel = encoding.y;
     const isVerticalBar =
       spec.markType === 'bar' &&
       (encoding.x?.type === 'nominal' || encoding.x?.type === 'ordinal') &&
@@ -673,26 +724,52 @@ export function computeScales(
       encoding.y.type === 'quantitative' &&
       !yStackDisabled
     ) {
-      const xField = encoding.x?.field;
-      const yField = encoding.y.field;
-      if (xField) {
-        const sums = new Map<string, number>();
-        for (const row of data) {
-          const cat = String(row[xField] ?? '');
-          const val = Number(row[yField] ?? 0);
-          if (Number.isFinite(val) && val > 0) {
-            sums.set(cat, (sums.get(cat) ?? 0) + val);
+      if (encoding.y.stack === 'normalize') {
+        // Normalize: domain is [0, 1] (VL convention)
+        yChannel = { ...encoding.y, scale: { ...encoding.y.scale, domain: [0, 1], nice: false } };
+      } else if (encoding.y.stack === 'center') {
+        // Center: compute max half-sum for symmetric domain
+        const xField = encoding.x?.field;
+        const yField = encoding.y.field;
+        if (xField) {
+          const sums = new Map<string, number>();
+          for (const row of data) {
+            const cat = String(row[xField] ?? '');
+            const val = Number(row[yField] ?? 0);
+            if (Number.isFinite(val) && val > 0) {
+              sums.set(cat, (sums.get(cat) ?? 0) + val);
+            }
+          }
+          const maxSum = Math.max(...sums.values(), 0);
+          const half = maxSum / 2;
+          yChannel = {
+            ...encoding.y,
+            scale: { ...encoding.y.scale, domain: [-half, half], zero: true },
+          };
+        }
+      } else {
+        // Zero (default): domain extends to max category sum
+        const xField = encoding.x?.field;
+        const yField = encoding.y.field;
+        if (xField) {
+          const sums = new Map<string, number>();
+          for (const row of data) {
+            const cat = String(row[xField] ?? '');
+            const val = Number(row[yField] ?? 0);
+            if (Number.isFinite(val) && val > 0) {
+              sums.set(cat, (sums.get(cat) ?? 0) + val);
+            }
           }
+          const maxSum = Math.max(...sums.values(), 0);
+          // Create a synthetic row with the max stack sum so buildLinearScale sees it
+          yData = [...data, { [yField]: maxSum } as DataRow];
         }
-        const maxSum = Math.max(...sums.values(), 0);
-        // Create a synthetic row with the max stack sum so buildLinearScale sees it
-        yData = [...data, { [yField]: maxSum } as DataRow];
       }
     }
 
     // Y axis: range is inverted (SVG y goes down, data y goes up)
     result.y = buildPositionalScale(
-      encoding.y,
+      yChannel,
       yData,
       chartArea.y + chartArea.height,
       chartArea.y,

package/src/legend/compute.ts

@@ -150,6 +150,7 @@ export function computeLegend(
   strategy: LayoutStrategy,
   theme: ResolvedTheme,
   chartArea: Rect,
+  watermark: boolean = true,
 ): LegendLayout {
   // Legend explicitly hidden via show: false, or height strategy says no legend
   if (spec.legend?.show === false || strategy.legendMaxHeight === 0) {
@@ -259,7 +260,8 @@ export function computeLegend(
 
   // Top/bottom-positioned legend: horizontal flow with overflow protection.
   // Reserve space on the right so legend entries don't overlap the brand watermark.
-  const availableWidth = chartArea.width - LEGEND_PADDING * 2 - BRAND_RESERVE_WIDTH;
+  const availableWidth =
+    chartArea.width - LEGEND_PADDING * 2 - (watermark ? BRAND_RESERVE_WIDTH : 0);
 
   // Apply symbolLimit first if set (minimum 1), then fit remaining entries to available rows.
   if (spec.legend?.symbolLimit != null) {

package/src/sankey/compile-sankey.ts

@@ -211,6 +211,10 @@ export function compileSankey(spec: unknown, options: CompileOptions): SankeyLay
 
   const sankeySpec = normalized as NormalizedSankeySpec;
 
+  // Resolve watermark: explicit spec value wins, then options fallback, then default true.
+  const rawWatermark = (spec as Record<string, unknown>).watermark;
+  const watermark = rawWatermark !== undefined ? sankeySpec.watermark : (options.watermark ?? true);
+
   // 2. Resolve theme
   const mergedThemeConfig = options.theme
     ? { ...sankeySpec.theme, ...options.theme }
@@ -241,6 +245,9 @@ export function compileSankey(spec: unknown, options: CompileOptions): SankeyLay
     theme,
     options.width,
     options.measureText,
+    'full',
+    undefined,
+    watermark,
   );
 
   // 4. Compute drawing area (total space minus chrome)
@@ -254,7 +261,7 @@ export function compileSankey(spec: unknown, options: CompileOptions): SankeyLay
 
   // Guard against negative dimensions
   if (fullArea.width <= 0 || fullArea.height <= 0) {
-    return emptyLayout(fullArea, chrome, theme, options);
+    return emptyLayout(fullArea, chrome, theme, options, watermark);
   }
 
   // 5. Extract encoding fields
@@ -298,7 +305,7 @@ export function compileSankey(spec: unknown, options: CompileOptions): SankeyLay
   };
 
   if (area.height <= 0) {
-    return emptyLayout(area, chrome, theme, options);
+    return emptyLayout(area, chrome, theme, options, watermark);
   }
 
   // 6. Run d3-sankey layout (may re-run once if labels overflow)
@@ -473,6 +480,7 @@ export function compileSankey(spec: unknown, options: CompileOptions): SankeyLay
       height: options.height,
     },
     animation: resolvedAnimation,
+    watermark,
   };
 }
 
@@ -631,6 +639,7 @@ function emptyLayout(
   chrome: ReturnType<typeof computeChrome>,
   theme: ResolvedTheme,
   options: CompileOptions,
+  watermark: boolean,
 ): SankeyLayout {
   return {
     area,
@@ -664,5 +673,6 @@ function emptyLayout(
       width: options.width,
       height: options.height,
     },
+    watermark,
   };
 }

package/src/sankey/types.ts

@@ -33,6 +33,7 @@ export interface NormalizedSankeySpec {
   legend?: LegendConfig;
   theme: ThemeConfig;
   darkMode: DarkMode;
+  watermark: boolean;
   animation?: AnimationSpec;
   valueFormat?: string;
   linkOpacity?: number;