@opendata-ai/openchart-engine 7.4.0 → 7.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opendata-ai/openchart-engine",
-  "version": "7.4.0",
+  "version": "7.4.1",
   "description": "Headless compiler for openchart: spec validation, data compilation, scales, and layout",
   "license": "Apache-2.0",
   "author": "Riley Hilliard",
@@ -48,7 +48,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
-    "@opendata-ai/openchart-core": "7.4.0",
+    "@opendata-ai/openchart-core": "7.4.1",
     "d3-array": "^3.2.0",
     "d3-format": "^3.1.2",
     "d3-interpolate": "^3.0.0",

package/src/__tests__/legend.test.ts

@@ -548,4 +548,58 @@ describe('computeLegend', () => {
       expect(legend.rowHeight).toBeGreaterThan(0);
     });
   });
+
+  describe('rows missing the color field', () => {
+    // A layered spec flattens every layer's rows into `spec.data`, but the
+    // color encoding belongs to one layer. Rows from sibling layers (e.g. a
+    // diagonal reference-line) have no value for the color field and must not
+    // manufacture a phantom "undefined" legend entry.
+    it('ignores rows whose color field is undefined', () => {
+      const spec: NormalizedChartSpec = {
+        ...specWithColor,
+        data: [
+          { date: '2020', value: 10, country: 'US' },
+          { date: '2021', value: 20, country: 'UK' },
+          // rule-layer rows: no `country` field
+          { date: '2020', value: 0 },
+          { date: '2022', value: 40 },
+        ],
+      };
+      const legend = computeLegend(spec, fullStrategy, theme, chartArea);
+      expect(legend.entries.map((e) => e.label)).toEqual(['US', 'UK']);
+    });
+
+    it('keeps an explicit color domain authoritative despite phantom rows', () => {
+      const spec: NormalizedChartSpec = {
+        ...specWithColor,
+        data: [
+          { date: '2020', value: 10, tier: 'One F from takeover' },
+          { date: '2021', value: 20, tier: 'One year behind' },
+          { date: '2022', value: 30, tier: 'Other D/F campus' },
+          // diagonal reference-line layer, no `tier`
+          { date: '2020', value: 0 },
+          { date: '2022', value: 40 },
+        ],
+        encoding: {
+          x: { field: 'date', type: 'temporal' },
+          y: { field: 'value', type: 'quantitative' },
+          color: {
+            field: 'tier',
+            type: 'nominal',
+            scale: {
+              domain: ['One F from takeover', 'One year behind', 'Other D/F campus'],
+              range: ['#fb7185', '#f59e0b', '#64748b'],
+            },
+          },
+        },
+      };
+      const legend = computeLegend(spec, fullStrategy, theme, chartArea);
+      expect(legend.entries.map((e) => e.label)).toEqual([
+        'One F from takeover',
+        'One year behind',
+        'Other D/F campus',
+      ]);
+      expect(legend.entries).toHaveLength(3);
+    });
+  });
 });

package/src/legend/compute.ts

@@ -144,7 +144,15 @@ function extractColorEntries(spec: NormalizedChartSpec, theme: ResolvedTheme): L
   // Sequential (quantitative) color doesn't produce discrete legend entries
   if (colorEnc.type === 'quantitative') return [];
 
-  const dataValues = [...new Set(spec.data.map((d) => String(d[colorEnc.field])))];
+  // Rows missing the color field (e.g. a sibling layer in a layered spec whose
+  // marks don't participate in the color encoding) must not manufacture a legend
+  // category. Without this guard, `String(undefined)` seeds a phantom "undefined"
+  // entry and — with an explicit domain — appends it past the authored entries.
+  const dataValues = [
+    ...new Set(
+      spec.data.filter((d) => d[colorEnc.field] != null).map((d) => String(d[colorEnc.field])),
+    ),
+  ];
   const explicitDomain = colorEnc.scale?.domain as string[] | undefined;
   const explicitRange = colorEnc.scale?.range as string[] | undefined;
   const palette = explicitRange ?? theme.colors.categorical;