@opendata-ai/openchart-engine 8.0.0-rc.12 → 8.0.0-rc.3

package/src/compiler/__tests__/validate-highlight.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import { validateSpec } from '../validate';
+
+// ---------------------------------------------------------------------------
+// Test data
+// ---------------------------------------------------------------------------
+
+const data = [
+  { date: '2020', country: 'Germany', value: 100 },
+  { date: '2020', country: 'France', value: 90 },
+  { date: '2020', country: 'Italy', value: 80 },
+  { date: '2021', country: 'Germany', value: 110 },
+  { date: '2021', country: 'France', value: 95 },
+  { date: '2021', country: 'Italy', value: 85 },
+];
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe('validateSpec — highlight channel', () => {
+  it('accepts highlight on a nominal color channel with valid values', () => {
+    const result = validateSpec({
+      mark: 'line',
+      data,
+      encoding: {
+        x: { field: 'date', type: 'temporal' },
+        y: { field: 'value', type: 'quantitative' },
+        color: { field: 'country', type: 'nominal', highlight: ['Germany'] },
+      },
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('accepts highlight as a single string (not array)', () => {
+    const result = validateSpec({
+      mark: 'line',
+      data,
+      encoding: {
+        x: { field: 'date', type: 'temporal' },
+        y: { field: 'value', type: 'quantitative' },
+        color: { field: 'country', type: 'nominal', highlight: 'Germany' },
+      },
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('accepts highlight with multiple valid values', () => {
+    const result = validateSpec({
+      mark: 'line',
+      data,
+      encoding: {
+        x: { field: 'date', type: 'temporal' },
+        y: { field: 'value', type: 'quantitative' },
+        color: { field: 'country', type: 'nominal', highlight: ['Germany', 'France'] },
+      },
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('rejects highlight on a quantitative color channel', () => {
+    const result = validateSpec({
+      mark: 'point',
+      data: [
+        { x: 1, y: 2, temp: 30 },
+        { x: 3, y: 4, temp: 50 },
+      ],
+      encoding: {
+        x: { field: 'x', type: 'quantitative' },
+        y: { field: 'y', type: 'quantitative' },
+        color: { field: 'temp', type: 'quantitative', highlight: ['30'] },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const highlightError = result.errors.find((e) => e.message.toLowerCase().includes('highlight'));
+    expect(highlightError).toBeDefined();
+    // Implementation may use ENCODING_MISMATCH or INVALID_VALUE
+    expect(['ENCODING_MISMATCH', 'INVALID_VALUE']).toContain(highlightError!.code);
+  });
+
+  it('does not reject highlight with unknown values at the validation level', () => {
+    // Unknown highlight values are a warning (surfaced during normalization),
+    // not a validation error. The spec should still pass validation.
+    const result = validateSpec({
+      mark: 'line',
+      data,
+      encoding: {
+        x: { field: 'date', type: 'temporal' },
+        y: { field: 'value', type: 'quantitative' },
+        color: { field: 'country', type: 'nominal', highlight: ['Spain'] },
+      },
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it('does not produce highlight errors when no highlight is specified', () => {
+    const result = validateSpec({
+      mark: 'line',
+      data,
+      encoding: {
+        x: { field: 'date', type: 'temporal' },
+        y: { field: 'value', type: 'quantitative' },
+        color: { field: 'country', type: 'nominal' },
+      },
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+});

package/src/compiler/__tests__/validate-near-miss.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Near-miss validation messages for VL idioms that are unsupported by
+ * decision. Each rejection must point the author at the openchart
+ * equivalent instead of failing with a generic type error.
+ */
+
+import { describe, expect, it } from 'vitest';
+import { validateSpec } from '../validate';
+
+const encoding = {
+  x: { field: 'cat', type: 'nominal' },
+  y: { field: 'value', type: 'quantitative' },
+};
+const data = [
+  { cat: 'A', value: 10 },
+  { cat: 'B', value: 20 },
+];
+
+describe('near-miss validation messages', () => {
+  it('rejects data.url with a pointer to inline data', () => {
+    const result = validateSpec({ mark: 'bar', data: { url: '/data.json' }, encoding });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'data.url');
+    expect(error?.message).toContain('does not fetch remote data');
+    expect(error?.suggestion).toContain('inline');
+  });
+
+  it('rejects the string form of calculate with the structured equivalent', () => {
+    const result = validateSpec({
+      mark: 'bar',
+      data,
+      transform: [{ calculate: 'datum.a / datum.b', as: 'ratio' }],
+      encoding,
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'transform[0].calculate');
+    expect(error?.message).toContain('structured expression object');
+    expect(error?.suggestion).toContain('calculate: { op:');
+  });
+
+  it('rejects hconcat/vconcat with the side-by-side containers suggestion', () => {
+    for (const key of ['hconcat', 'vconcat']) {
+      const result = validateSpec({ [key]: [] });
+      expect(result.valid).toBe(false);
+      const error = result.errors.find((e) => e.path === key);
+      expect(error?.message).toContain(`"${key}" composition is not supported`);
+      expect(error?.suggestion).toContain('facet');
+    }
+  });
+
+  it('rejects the top-level facet operator with the facet channel suggestion', () => {
+    const result = validateSpec({
+      facet: { field: 'cat', type: 'nominal' },
+      spec: { mark: 'bar', encoding },
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'facet');
+    expect(error?.message).toContain('"facet" operator is not supported');
+    expect(error?.suggestion).toContain('encoding.facet');
+  });
+
+  it('rejects unknown scheme names with the supported list', () => {
+    const result = validateSpec({
+      mark: 'bar',
+      data,
+      encoding: {
+        ...encoding,
+        color: { field: 'value', type: 'quantitative', scale: { scheme: 'viridis' } },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'encoding.color.scale.scheme');
+    expect(error?.message).toContain('"viridis" is not a supported scheme name');
+    expect(error?.suggestion).toContain('blues');
+    expect(error?.suggestion).toContain('scale.range');
+  });
+
+  it('accepts known scheme names (resolved by sugar before validation on the compile path)', () => {
+    const result = validateSpec({
+      mark: 'bar',
+      data,
+      encoding: {
+        ...encoding,
+        color: { field: 'value', type: 'quantitative', scale: { scheme: 'blues' } },
+      },
+    });
+    expect(result.errors.filter((e) => e.path === 'encoding.color.scale.scheme')).toHaveLength(0);
+  });
+});