@opendata-ai/openchart-engine 7.7.0 → 7.9.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as _opendata_ai_openchart_core from '@opendata-ai/openchart-core';
-import { LegendLayout, ResolvedChrome, TooltipContent, A11yMetadata, ResolvedTheme, CompileOptions, ChartLayout, LayerSpec, CompileTableOptions, TableLayout, AnimationSpec, ResolvedAnimation, DataRow, BarListEncoding, ThemeConfig, DarkMode, TileMapEncoding, TileMapPalette, LegendConfig, MarkType, MarkDef, Encoding, ChromeText, Annotation, LabelConfig, Display, ColumnConfig, GraphSpec, GraphEncoding, GraphLayoutConfig, NodeOverride, SankeyEncoding, SankeyNodeAlign, SankeyLinkColor, ScaleType, EncodingChannel, Rect, LayoutStrategy, VizSpec, Mark, BinTransform, CalculateTransform, ConditionalValueDef, FilterPredicate, TimeUnitTransform, Transform } from '@opendata-ai/openchart-core';
+import { LegendLayout, ResolvedChrome, TooltipContent, A11yMetadata, ResolvedTheme, CompileOptions, ChartLayout, LayerSpec, CompileTableOptions, TableLayout, ResolvedAnimationPhase, AnimationSpec, ResolvedAnimation, Point, DataRow, BarListEncoding, ThemeConfig, DarkMode, TileMapEncoding, TileMapPalette, LegendConfig, MarkType, MarkDef, Encoding, ChromeText, Annotation, LabelConfig, Display, ColumnConfig, GraphSpec, GraphEncoding, GraphLayoutConfig, NodeOverride, SankeyEncoding, SankeyNodeAlign, SankeyLinkColor, ScaleType, EncodingChannel, Rect, LayoutStrategy, VizSpec, Mark, BinTransform, CalculateTransform, ConditionalValueDef, FilterPredicate, TimeUnitTransform, Transform } from '@opendata-ai/openchart-core';
 export { BarListLayout, BarListSpec, ChartLayout, ChartSpec, CompileOptions, CompileTableOptions, GraphLayout, GraphSpec, LayerSpec, SankeyLayout, SankeySpec, TableLayout, TableSpec, TileMapLayout, TileMapSpec, VizSpec } from '@opendata-ai/openchart-core';
 import { ScaleLinear, ScaleTime, ScaleLogarithmic, ScalePower, ScaleSymLog, ScaleBand, ScalePoint, ScaleOrdinal, ScaleQuantile, ScaleQuantize, ScaleThreshold } from 'd3-scale';
 
@@ -189,11 +189,24 @@ declare function compileBarList(spec: unknown, options: CompileOptions): _openda
  * Animation resolver: normalizes AnimationSpec into fully resolved config.
  *
  * Handles the shorthand forms:
- * - true -> { enter: true } -> full defaults
- * - { enter: { duration: 800 } } -> merge with defaults
+ * - true -> all three phases with defaults
+ * - { enter: { duration: 800 } } -> merge with defaults per phase
  * - false/undefined -> undefined (no animation)
+ *
+ * Each phase resolves independently:
+ * - true/config-object -> resolved phase merged onto that phase's defaults
+ * - false -> phase absent
+ * - undefined -> phase present with defaults (animation: {} behaves like true)
+ *
+ * Returns undefined only when ALL phases resolve absent.
  */
 
+/** Default values for entrance animation. */
+declare const ENTER_DEFAULTS: ResolvedAnimationPhase;
+/** Default values for update (data transition) animation. */
+declare const UPDATE_DEFAULTS: ResolvedAnimationPhase;
+/** Default values for exit animation. */
+declare const EXIT_DEFAULTS: ResolvedAnimationPhase;
 /**
  * Resolve an AnimationSpec into a fully resolved config with all defaults filled.
  * Returns undefined if animation is disabled (false or omitted).
@@ -204,6 +217,52 @@ declare function resolveAnimation(spec: AnimationSpec | undefined): ResolvedAnim
  */
 declare function clampStaggerDelay(delay: number, elementCount: number): number;
 
+/**
+ * Mark key utilities for data-update transitions.
+ *
+ * Keys uniquely identify marks across data updates so the renderer can
+ * match old marks to new marks and animate the difference. Each chart
+ * type stamps keys during its compute phase; these helpers provide the
+ * shared serialization and deduplication logic.
+ */
+/**
+ * Serialize a datum value into a stable key fragment.
+ * - Date -> epoch ms string (avoids locale-dependent Date.toString)
+ * - number/string/boolean -> String(v)
+ * - null/undefined -> null sentinel
+ */
+declare function serializeKeyValue(v: unknown): string;
+/**
+ * Append occurrence suffixes to duplicate keys, in order.
+ *
+ * Only keys that appear more than once get suffixed. Unique keys pass
+ * through unchanged so keys remain human-readable when possible.
+ * Uses SOH (\x01) as separator to avoid collisions with real data values.
+ */
+declare function dedupeKeys(keys: string[]): string[];
+
+/**
+ * Curve interpolation mapping and path builders.
+ *
+ * Maps Vega-Lite-style interpolation strings to d3-shape curve factories.
+ * Used by both line and area chart computations.
+ *
+ * Also exports pure path-builder helpers (`buildLinePath`, `buildAreaPath`)
+ * so downstream consumers (e.g. transition interpolators) can reconstruct
+ * SVG paths from point arrays without pulling in chart-specific code.
+ */
+
+/**
+ * Build an SVG path string from an array of points using d3 line generator.
+ * Accepts an optional interpolation string (defaults to 'monotone').
+ */
+declare function buildLinePath(points: Point[], interpolate?: string): string;
+/**
+ * Build an SVG path string for a filled area from top and bottom point arrays.
+ * Accepts an optional interpolation string (defaults to 'monotone').
+ */
+declare function buildAreaPath(topPoints: Point[], bottomPoints: Point[], interpolate?: string): string;
+
 /**
  * Internal normalized barlist spec type used by the compilation pipeline.
  */
@@ -733,4 +792,4 @@ declare function runTimeUnit(data: DataRow[], transform: TimeUnitTransform): Dat
  */
 declare function runTransforms(data: DataRow[], transforms: Transform[]): DataRow[];
 
-export { type AnnotationContext, type AnnotationMeasureTextFn, type ChartRenderer, type CompileResult, type CompiledGraphEdge, type CompiledGraphNode, type GraphCompilation, type NormalizedBarListSpec, type NormalizedChartSpec, type NormalizedChrome, type NormalizedGraphSpec, type NormalizedSankeySpec, type NormalizedSpec, type NormalizedTableSpec, type NormalizedTileMapSpec, type ObstacleKind, type PlacementObstacle, type SimulationConfig, type ValidationError, type ValidationErrorCode, type ValidationResult, clampStaggerDelay, clearRenderers, compile, compileBarList, compileChart, compileGraph, compileLayer, compileSankey, compileTable, compileTileMap, evaluatePredicate, getChartRenderer, heuristicMeasure, isConditionalValueDef, normalizeSpec, registerChartRenderer, resolveAnimation, resolveConditionalValue, runBin, runCalculate, runFilter, runTimeUnit, runTransforms, validateSpec };
+export { type AnnotationContext, type AnnotationMeasureTextFn, type ChartRenderer, type CompileResult, type CompiledGraphEdge, type CompiledGraphNode, ENTER_DEFAULTS, EXIT_DEFAULTS, type GraphCompilation, type NormalizedBarListSpec, type NormalizedChartSpec, type NormalizedChrome, type NormalizedGraphSpec, type NormalizedSankeySpec, type NormalizedSpec, type NormalizedTableSpec, type NormalizedTileMapSpec, type ObstacleKind, type PlacementObstacle, type SimulationConfig, UPDATE_DEFAULTS, type ValidationError, type ValidationErrorCode, type ValidationResult, buildAreaPath, buildLinePath, clampStaggerDelay, clearRenderers, compile, compileBarList, compileChart, compileGraph, compileLayer, compileSankey, compileTable, compileTileMap, dedupeKeys, evaluatePredicate, getChartRenderer, heuristicMeasure, isConditionalValueDef, normalizeSpec, registerChartRenderer, resolveAnimation, resolveConditionalValue, runBin, runCalculate, runFilter, runTimeUnit, runTransforms, serializeKeyValue, validateSpec };

package/dist/index.js

@@ -2125,6 +2125,32 @@ function computeEndpointLabels(spec, marks, theme, chartArea, strategy, endpoint
 // src/charts/bar/compute.ts
 import { isGradientDef, NARROW_VIEWPORT_MAX } from "@opendata-ai/openchart-core";
 
+// src/compiler/keys.ts
+var NULL_KEY = "\u2205";
+function serializeKeyValue(v) {
+  if (v === null || v === void 0) return NULL_KEY;
+  if (v instanceof Date) return String(v.getTime());
+  return String(v);
+}
+function dedupeKeys(keys) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const k of keys) {
+    counts.set(k, (counts.get(k) ?? 0) + 1);
+  }
+  const seen = /* @__PURE__ */ new Map();
+  const result = [];
+  for (const k of keys) {
+    if (counts.get(k) > 1) {
+      const idx = seen.get(k) ?? 0;
+      result.push(`${k}
${idx}`);
+      seen.set(k, idx + 1);
+    } else {
+      result.push(k);
+    }
+  }
+  return result;
+}
+
 // src/transforms/predicates.ts
 function isFieldPredicate(pred) {
   return "field" in pred;
@@ -2374,8 +2400,21 @@ function computeBarMarks(spec, scales, _chartArea, _strategy, containerWidth) {
       );
     }
   }
+  const categoryField = yChannel.field;
+  stampBarKeys(marks, categoryField, colorField);
   return applyMarkDefOverrides(marks, spec, bandwidth);
 }
+function stampBarKeys(marks, categoryField, colorField) {
+  const rawKeys = marks.map((m) => {
+    const series = colorField ? String(m.data[colorField] ?? "") : "";
+    const cat = serializeKeyValue(m.data[categoryField]);
+    return `${series}|${cat}`;
+  });
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
+}
 function computeStackedBars(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, _baseline, scales, stackMode = "zero") {
   const marks = [];
   const categoryGroups = groupByField(data, categoryField);
@@ -2873,8 +2912,21 @@ function computeColumnMarks(spec, scales, _chartArea, _strategy) {
       conditionalColor
     );
   }
+  const categoryField = xChannel.field;
+  stampColumnKeys(marks, categoryField, colorField);
   return applyMarkDefOverrides2(marks, spec, bandwidth);
 }
+function stampColumnKeys(marks, categoryField, colorField) {
+  const rawKeys = marks.map((m) => {
+    const series = colorField ? String(m.data[colorField] ?? "") : "";
+    const cat = serializeKeyValue(m.data[categoryField]);
+    return `${series}|${cat}`;
+  });
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
+}
 function computeSimpleColumns(data, categoryField, valueField, xScale, yScale, bandwidth, baseline, scales, sequentialColor = false, conditionalColor) {
   const marks = [];
   for (const row of data) {
@@ -3198,8 +3250,9 @@ function computeDotMarks(spec, scales, _chartArea, _strategy) {
   const colorEnc = encoding.color && "field" in encoding.color ? encoding.color : void 0;
   const isSequentialColor = colorEnc?.type === "quantitative";
   const colorField = isSequentialColor ? void 0 : colorEnc?.field;
+  let marks;
   if (colorField) {
-    return computeDumbbellMarks(
+    marks = computeDumbbellMarks(
       spec.data,
       xChannel.field,
       yChannel.field,
@@ -3209,18 +3262,30 @@ function computeDotMarks(spec, scales, _chartArea, _strategy) {
       bandwidth,
       scales
     );
+  } else {
+    marks = computeLollipopMarks(
+      spec.data,
+      xChannel.field,
+      yChannel.field,
+      xScale,
+      yScale,
+      bandwidth,
+      baseline,
+      scales,
+      isSequentialColor
+    );
   }
-  return computeLollipopMarks(
-    spec.data,
-    xChannel.field,
-    yChannel.field,
-    xScale,
-    yScale,
-    bandwidth,
-    baseline,
-    scales,
-    isSequentialColor
-  );
+  const pointMarks = marks.filter((m) => m.type === "point");
+  const rawKeys = pointMarks.map((m) => {
+    const cat = serializeKeyValue(m.data[yChannel.field]);
+    const series = colorField ? String(m.data[colorField] ?? "") : "";
+    return series ? `${series}|${cat}` : cat;
+  });
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < pointMarks.length; i++) {
+    pointMarks[i].key = keys[i];
+  }
+  return marks;
 }
 function computeDumbbellMarks(data, valueField, categoryField, colorField, xScale, yScale, bandwidth, scales) {
   const marks = [];
@@ -4335,6 +4400,23 @@ function resolveCurve(interpolate) {
   if (!interpolate) return monotoneX;
   return CURVE_MAP[interpolate] ?? monotoneX;
 }
+function buildLinePath(points, interpolate) {
+  if (points.length === 0) return "";
+  const curve = resolveCurve(interpolate);
+  const generator = line_default().x((d) => d.x).y((d) => d.y).curve(curve);
+  return generator(points) ?? "";
+}
+function buildAreaPath(topPoints, bottomPoints, interpolate) {
+  if (topPoints.length === 0) return "";
+  const curve = resolveCurve(interpolate);
+  const paired = topPoints.map((tp, i) => ({
+    x: tp.x,
+    yTop: tp.y,
+    yBottom: bottomPoints[i]?.y ?? 0
+  }));
+  const generator = area_default().x((d) => d.x).y0((d) => d.yBottom).y1((d) => d.yTop).curve(curve);
+  return generator(paired) ?? "";
+}
 
 // src/charts/line/area.ts
 var DEFAULT_FILL_OPACITY = 0.15;
@@ -4436,8 +4518,15 @@ function computeSingleArea(spec, scales, _chartArea) {
       fillValue = buildGradientFill(colorStr, defaultGradientStops);
       fillOpacity = 1;
     }
+    const keyField = encoding.key && "field" in encoding.key ? encoding.key.field : void 0;
+    const rawPointKeys = validPoints.map(
+      (p) => keyField ? serializeKeyValue(p.row[keyField]) : serializeKeyValue(p.row[xChannel.field])
+    );
     marks.push({
       type: "area",
+      key: seriesKey === "__default__" ? "area" : seriesKey,
+      pointKeys: dedupeKeys(rawPointKeys),
+      interpolate: spec.markDef.interpolate ?? "monotone",
       topPoints,
       bottomPoints,
       path: pathStr,
@@ -4536,8 +4625,12 @@ function computeStackedArea(spec, scales, chartArea, darkMode) {
       fillValue = buildGradientFill(colorStr, stackedStops);
       fillOpacity = 1;
     }
+    const rawPointKeys = validPoints.map((_p, idx) => serializeKeyValue(layer[idx]?.data.__x__));
     marks.push({
       type: "area",
+      key: seriesKey,
+      pointKeys: dedupeKeys(rawPointKeys),
+      interpolate: spec.markDef.interpolate ?? "monotone",
       topPoints,
       bottomPoints,
       path: pathStr,
@@ -4570,6 +4663,10 @@ function computeAreaMarks(spec, scales, chartArea, darkMode) {
   } else {
     marks = computeSingleArea(spec, scales, chartArea);
   }
+  const areaKeys = dedupeKeys(marks.map((m) => m.key));
+  marks.forEach((m, i) => {
+    m.key = areaKeys[i];
+  });
   const highlight = spec.highlight ?? [];
   if (highlight.length > 0) {
     const highlightSet = new Set(highlight);
@@ -4655,8 +4752,15 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
     let strokeDasharray;
     if (styleOverride?.lineStyle === "dashed") strokeDasharray = "6 4";
     else if (styleOverride?.lineStyle === "dotted") strokeDasharray = "2 3";
+    const keyField = encoding.key && "field" in encoding.key ? encoding.key.field : void 0;
+    const rawPointKeys = pointsWithData.map(
+      (p) => keyField ? serializeKeyValue(p.row[keyField]) : serializeKeyValue(p.row[xChannel.field])
+    );
     const lineMark = {
       type: "line",
+      key: seriesStyleKey ?? "series",
+      pointKeys: dedupeKeys(rawPointKeys),
+      interpolate: spec.markDef.interpolate ?? "monotone",
       points: allPoints,
       path: combinedPath,
       stroke: strokeColor,
@@ -4695,9 +4799,11 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
         }
         const hollow = isEndpoints && visible;
         const pointColorStr = getRepresentativeColor5(pointColor);
+        const pointKey = keyField ? serializeKeyValue(p.row[keyField]) : seriesStyleKey ? `${seriesStyleKey}|${serializeKeyValue(p.row[xChannel.field])}` : serializeKeyValue(p.row[xChannel.field]);
         if (isSingleEndpoint) {
           bucket.push({
             type: "point",
+            key: pointKey,
             cx: p.x,
             cy: p.y,
             r: 3.5,
@@ -4712,6 +4818,7 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
         }
         const pointMark = {
           type: "point",
+          key: pointKey,
           cx: p.x,
           cy: p.y,
           r: visible ? DEFAULT_POINT_RADIUS : 0,
@@ -4728,7 +4835,20 @@ function computeLineMarks(spec, scales, _chartArea, _strategy) {
       }
     }
   }
-  return [...mutedMarks, ...highlightedMarks];
+  const allMarks = [...mutedMarks, ...highlightedMarks];
+  const lineMarks = allMarks.filter((m) => m.type === "line");
+  const lineKeys = dedupeKeys(lineMarks.map((m) => m.key));
+  lineMarks.forEach((m, i) => {
+    m.key = lineKeys[i];
+  });
+  const pointMarks = allMarks.filter((m) => m.type === "point");
+  if (pointMarks.length > 0) {
+    const pointKeys = dedupeKeys(pointMarks.map((m) => m.key ?? ""));
+    pointMarks.forEach((m, i) => {
+      m.key = pointKeys[i];
+    });
+  }
+  return allMarks;
 }
 function _getMidValue(rows, field) {
   const values = rows.map((r) => Number(r[field])).filter(Number.isFinite);
@@ -5028,6 +5148,14 @@ function computePieMarks(spec, scales, chartArea, _strategy, isDonut = false) {
       aria
     });
   }
+  const rawKeys = marks.map((m) => {
+    const label = categoryField ? String(m.data[categoryField] ?? "") : String(m.data.label ?? m.data.name ?? m.data.category ?? "");
+    return serializeKeyValue(label);
+  });
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
   return marks;
 }
 
@@ -5202,6 +5330,12 @@ function computeRuleMarks(spec, scales, chartArea) {
       aria
     });
   }
+  const posField = xChannel?.field ?? yChannel?.field;
+  const rawKeys = marks.map((m, i) => posField ? serializeKeyValue(m.data[posField]) : String(i));
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
   return marks;
 }
 var ruleRenderer = (spec, scales, chartArea, _strategy, _theme) => {
@@ -7639,6 +7773,8 @@ function computeScatterMarks(spec, scales, _chartArea, _strategy) {
     const [radiusMin, radiusMax] = explicitRange ?? [MIN_BUBBLE_RADIUS, MAX_BUBBLE_RADIUS];
     sizeScale = sqrt2().domain([sizeMin, sizeMax]).range([radiusMin, radiusMax]).clamp(true);
   }
+  const keyEnc = encoding.key && "field" in encoding.key ? encoding.key : void 0;
+  const keyField = keyEnc?.field;
   const marks = [];
   for (const row of spec.data) {
     const rawX = row[xChannel.field];
@@ -7682,6 +7818,16 @@ function computeScatterMarks(spec, scales, _chartArea, _strategy) {
       aria
     });
   }
+  const rawKeys = marks.map((m) => {
+    if (keyField) return serializeKeyValue(m.data[keyField]);
+    const cat = colorField ? String(m.data[colorField] ?? "") : "";
+    const xVal = serializeKeyValue(m.data[xChannel.field]);
+    return cat ? `${cat}|${xVal}` : xVal;
+  });
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
   return marks;
 }
 
@@ -7799,6 +7945,12 @@ function computeTextMarks(spec, scales) {
       aria
     });
   }
+  const posField = xChannel?.field ?? yChannel?.field;
+  const rawKeys = marks.map((m, i) => posField ? serializeKeyValue(m.data[posField]) : String(i));
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
   return marks;
 }
 var textRenderer = (spec, scales, _chartArea, _strategy, _theme) => {
@@ -7841,6 +7993,12 @@ function computeTickMarks(spec, scales, _chartArea) {
       aria
     });
   }
+  const posField = isHorizontal ? xChannel.field : yChannel.field;
+  const rawKeys = marks.map((m) => serializeKeyValue(m.data[posField]));
+  const keys = dedupeKeys(rawKeys);
+  for (let i = 0; i < marks.length; i++) {
+    marks[i].key = keys[i];
+  }
   return marks;
 }
 var tickRenderer = (spec, scales, chartArea, _strategy, _theme) => {
@@ -7893,69 +8051,70 @@ var ENTER_DEFAULTS = {
   duration: 500,
   ease: "smooth",
   staggerDelay: 80,
-  staggerOrder: "index",
-  annotationDelay: 200
+  staggerOrder: "index"
 };
+var UPDATE_DEFAULTS = {
+  duration: 500,
+  ease: "smooth",
+  staggerDelay: 0,
+  staggerOrder: "index"
+};
+var EXIT_DEFAULTS = {
+  duration: 300,
+  ease: "smooth",
+  staggerDelay: 0,
+  staggerOrder: "index"
+};
+var DEFAULT_ANNOTATION_DELAY = 200;
 var MAX_TOTAL_STAGGER_MS = 2e3;
 function resolveAnimation(spec) {
   if (spec === void 0 || spec === false) return void 0;
   if (spec === true) {
     return {
-      enabled: true,
-      duration: ENTER_DEFAULTS.duration,
-      ease: ENTER_DEFAULTS.ease,
-      staggerDelay: ENTER_DEFAULTS.staggerDelay,
-      staggerOrder: ENTER_DEFAULTS.staggerOrder,
-      annotationDelay: ENTER_DEFAULTS.annotationDelay
+      enter: { ...ENTER_DEFAULTS },
+      update: { ...UPDATE_DEFAULTS },
+      exit: { ...EXIT_DEFAULTS },
+      annotationDelay: DEFAULT_ANNOTATION_DELAY
     };
   }
   const config = spec;
-  if (config.enter === false || config.enter === void 0 && !hasAnyPhase(config)) {
-    return void 0;
-  }
-  const enterConfig = resolvePhaseConfig(config.enter);
+  const enter = resolvePhase(config.enter, ENTER_DEFAULTS);
+  const update = resolvePhase(config.update, UPDATE_DEFAULTS);
+  const exit = resolvePhase(config.exit, EXIT_DEFAULTS);
+  if (!enter && !update && !exit) return void 0;
   return {
-    enabled: true,
-    duration: enterConfig.duration,
-    ease: enterConfig.ease,
-    staggerDelay: enterConfig.staggerDelay,
-    staggerOrder: enterConfig.staggerOrder,
-    annotationDelay: config.annotationDelay ?? ENTER_DEFAULTS.annotationDelay
+    enter: enter ?? void 0,
+    update: update ?? void 0,
+    exit: exit ?? void 0,
+    annotationDelay: config.annotationDelay ?? DEFAULT_ANNOTATION_DELAY
   };
 }
 function clampStaggerDelay(delay, elementCount) {
   if (elementCount <= 1) return 0;
   return Math.min(delay, MAX_TOTAL_STAGGER_MS / elementCount);
 }
-function hasAnyPhase(config) {
-  return config.enter !== void 0 || config.update !== void 0 || config.exit !== void 0;
-}
-function resolvePhaseConfig(phase) {
+function resolvePhase(phase, defaults) {
+  if (phase === false) return null;
   if (phase === void 0 || phase === true) {
-    return {
-      duration: ENTER_DEFAULTS.duration,
-      ease: ENTER_DEFAULTS.ease,
-      staggerDelay: ENTER_DEFAULTS.staggerDelay,
-      staggerOrder: ENTER_DEFAULTS.staggerOrder
-    };
+    return { ...defaults };
   }
   const cfg = phase;
-  const stagger = resolveStagger(cfg.stagger);
+  const stagger = resolveStagger(cfg.stagger, defaults);
   return {
-    duration: cfg.duration ?? ENTER_DEFAULTS.duration,
-    ease: cfg.ease ?? ENTER_DEFAULTS.ease,
+    duration: cfg.duration ?? defaults.duration,
+    ease: cfg.ease ?? defaults.ease,
     staggerDelay: stagger.delay,
     staggerOrder: stagger.order
   };
 }
-function resolveStagger(stagger) {
+function resolveStagger(stagger, defaults) {
   if (stagger === false) return { delay: 0, order: "index" };
   if (stagger === void 0 || stagger === true) {
-    return { delay: ENTER_DEFAULTS.staggerDelay, order: ENTER_DEFAULTS.staggerOrder };
+    return { delay: defaults.staggerDelay, order: defaults.staggerOrder };
   }
   return {
-    delay: stagger.delay ?? ENTER_DEFAULTS.staggerDelay,
-    order: stagger.order ?? ENTER_DEFAULTS.staggerOrder
+    delay: stagger.delay ?? defaults.staggerDelay,
+    order: stagger.order ?? defaults.staggerOrder
   };
 }
 
@@ -8160,7 +8319,7 @@ function inferFieldType(data, field) {
 }
 function inferEncodingTypes(encoding, data, warnings) {
   const result = { ...encoding };
-  for (const channel of ["x", "y", "color", "size", "detail"]) {
+  for (const channel of ["x", "y", "color", "size", "detail", "key"]) {
     const spec = result[channel];
     if (!spec) continue;
     if ("condition" in spec) continue;
@@ -9799,8 +9958,8 @@ function getMarkPrimaryValue(mark) {
   }
 }
 function assignAnimationIndices(marks, animation) {
-  if (!animation?.enabled) return;
-  if (animation.staggerOrder === "value") {
+  if (!animation?.enter) return;
+  if (animation.enter.staggerOrder === "value") {
     const indexed = marks.map((m, i) => ({ mark: m, idx: i }));
     indexed.sort((a, b) => {
       const av = getMarkPrimaryValue(a.mark);
@@ -14782,6 +14941,7 @@ import {
   computeChrome as computeChrome7,
   estimateTextWidth as estimateTextWidth20,
   formatNumber as formatNumber8,
+  pickLabelColor as pickLabelColor2,
   resolveTheme as resolveTheme5,
   SEQUENTIAL_PALETTES
 } from "@opendata-ai/openchart-core";
@@ -14897,7 +15057,8 @@ function compileQuantitative(tilemapSpec, options, theme, chrome, fullArea, isDa
         value: value2,
         formattedValue,
         hasData,
-        theme
+        theme,
+        isDarkMode: !!isDarkMode
       })
     );
   }
@@ -15024,6 +15185,7 @@ function compileCategorical(tilemapSpec, options, theme, chrome, fullArea, isDar
         formattedValue,
         hasData,
         theme,
+        isDarkMode: !!isDarkMode,
         category: hasData ? category : void 0
       })
     );
@@ -15096,22 +15258,25 @@ function buildTileMark(opts) {
     formattedValue,
     hasData,
     theme,
+    isDarkMode,
     category
   } = opts;
   const tileCenterX = gridOffsetX + pos.x + tileSize / 2;
   const tileTopY = gridOffsetY + pos.y;
+  const textColor = hasData ? pickLabelColor2(fill, isDarkMode) : "#ffffff";
+  const isLightText = textColor === "#ffffff";
   const labelStyle = {
     fontFamily: theme.fonts.family,
     fontSize: tileSize > 24 ? 10 : 7,
     fontWeight: 700,
-    fill: "#ffffff",
+    fill: textColor,
     lineHeight: 1.2
   };
   const valueLabelStyle = {
     fontFamily: theme.fonts.family,
     fontSize: tileSize > 24 ? 10 : 7,
     fontWeight: 300,
-    fill: "rgba(255,255,255,0.6)",
+    fill: isLightText ? "rgba(255,255,255,0.6)" : "rgba(0,0,0,0.45)",
     lineHeight: 1.2
   };
   const valueLabel = tileSize < 24 ? { text: "", x: 0, y: 0, style: valueLabelStyle, visible: false } : {
@@ -16433,7 +16598,7 @@ function compileFaceted(chartSpec, renderSpec, facetChannel, options, theme, str
       encoding: panelEnc
     };
     const panelScales = computeScales(panelSpecWithDomains, gridPanel.area, panelData);
-    applyColorScaleRange(panelScales, panelSpecWithDomains.encoding, theme);
+    applyColorScaleRange(panelScales, panelSpecWithDomains.encoding, theme, renderSpec.highlight);
     panelScales.defaultColor = chartSpec.markDef.fill ?? chartSpec.markDef.stroke ?? theme.colors.categorical[0];
     const isLeftCol = gridPanel.col === 0;
     const isBottomRow = gridPanel.row === grid.rows - 1;
@@ -16566,6 +16731,11 @@ function compileBarList2(spec, options) {
   return compileBarList(spec, options);
 }
 export {
+  ENTER_DEFAULTS,
+  EXIT_DEFAULTS,
+  UPDATE_DEFAULTS,
+  buildAreaPath,
+  buildLinePath,
   clampStaggerDelay,
   clearRenderers,
   compile,
@@ -16576,6 +16746,7 @@ export {
   compileSankey2 as compileSankey,
   compileTable,
   compileTileMap2 as compileTileMap,
+  dedupeKeys,
   evaluatePredicate,
   getChartRenderer,
   heuristicMeasure,
@@ -16589,6 +16760,7 @@ export {
   runFilter,
   runTimeUnit,
   runTransforms,
+  serializeKeyValue,
   validateSpec
 };
 //# sourceMappingURL=index.js.map