@opendata-ai/openchart-engine 8.0.0-rc.1 → 8.0.0-rc.10

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

@@ -62,11 +62,11 @@ describe('dedupeKeys', () => {
   });
 
   it('suffixes duplicates with occurrence index', () => {
-    expect(dedupeKeys(['a', 'a', 'a'])).toEqual(['a\x010', 'a\x011', 'a\x012']);
+    expect(dedupeKeys(['a', 'a', 'a'])).toEqual(['a⸱0', 'a⸱1', 'a⸱2']);
   });
 
   it('only suffixes keys that appear more than once', () => {
-    expect(dedupeKeys(['a', 'b', 'a'])).toEqual(['a\x010', 'b', 'a\x011']);
+    expect(dedupeKeys(['a', 'b', 'a'])).toEqual(['a⸱0', 'b', 'a⸱1']);
   });
 
   it('handles empty array', () => {
@@ -78,12 +78,6 @@ describe('dedupeKeys', () => {
   });
 
   it('handles multiple duplicate groups', () => {
-    expect(dedupeKeys(['x', 'y', 'x', 'y', 'z'])).toEqual([
-      'x\x010',
-      'y\x010',
-      'x\x011',
-      'y\x011',
-      'z',
-    ]);
+    expect(dedupeKeys(['x', 'y', 'x', 'y', 'z'])).toEqual(['x⸱0', 'y⸱0', 'x⸱1', 'y⸱1', 'z']);
   });
 });

package/src/compiler/__tests__/validate-did-you-mean.test.ts

@@ -66,6 +66,90 @@ describe('did-you-mean field suggestions', () => {
     expect(suggestion).toContain('Did you mean "quarter"?');
   });
 
+  it('suggests the nearest column for a misspelled sankey encoding field', () => {
+    const result = validateSpec({
+      type: 'sankey',
+      data: [{ source: 'A', target: 'B', value: 10 }],
+      encoding: {
+        source: { field: 'sorce', type: 'nominal' }, // typo of "source"
+        target: { field: 'target', type: 'nominal' },
+        value: { field: 'value', type: 'quantitative' },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'encoding.source.field');
+    expect(suggestion).toContain('Did you mean "source"?');
+    expect(suggestion).toContain('target');
+  });
+
+  it('suggests the nearest column for a misspelled tilemap encoding field', () => {
+    const result = validateSpec({
+      type: 'tilemap',
+      data: [{ state: 'CA', value: 12000 }],
+      encoding: {
+        state: { field: 'state', type: 'nominal' },
+        value: { field: 'vlaue', type: 'quantitative' }, // typo of "value"
+      },
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'encoding.value.field');
+    expect(suggestion).toContain('Did you mean "value"?');
+  });
+
+  it('suggests the nearest column for a misspelled barlist encoding field', () => {
+    const result = validateSpec({
+      type: 'barlist',
+      data: [{ label: 'A', value: 42 }],
+      encoding: {
+        label: { field: 'lable', type: 'nominal' }, // typo of "label"
+        value: { field: 'value', type: 'quantitative' },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'encoding.label.field');
+    expect(suggestion).toContain('Did you mean "label"?');
+  });
+
+  it('suggests the nearest column for a misspelled optional barlist channel field', () => {
+    const result = validateSpec({
+      type: 'barlist',
+      data: [{ label: 'A', value: 42, group: 'x' }],
+      encoding: {
+        label: { field: 'label', type: 'nominal' },
+        value: { field: 'value', type: 'quantitative' },
+        color: { field: 'gruop', type: 'nominal' }, // typo of "group"
+      },
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'encoding.color.field');
+    expect(suggestion).toContain('Did you mean "group"?');
+  });
+
+  it('suggests the nearest node field for a misspelled graph encoding field', () => {
+    const result = validateSpec({
+      type: 'graph',
+      nodes: [{ id: 'a', category: 'x' }],
+      edges: [],
+      encoding: {
+        nodeColor: { field: 'catgory', type: 'nominal' }, // typo of "category"
+      },
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'encoding.nodeColor.field');
+    expect(suggestion).toContain('Did you mean "category"?');
+  });
+
+  it('suggests the nearest node id for a misspelled graph edge endpoint', () => {
+    const result = validateSpec({
+      type: 'graph',
+      nodes: [{ id: 'alpha' }, { id: 'beta' }],
+      edges: [{ source: 'alpha', target: 'betta' }], // typo of "beta"
+    });
+    expect(result.valid).toBe(false);
+    const suggestion = suggestionFor(result, 'edges[0].target');
+    expect(suggestion).toContain('Did you mean "beta"?');
+  });
+
   it('does not match on a short unrelated field where the edit distance exceeds the threshold', () => {
     const shortData = [
       { a: 1, b: 2 },

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

@@ -87,3 +87,165 @@ describe('near-miss validation messages', () => {
     expect(result.errors.filter((e) => e.path === 'encoding.color.scale.scheme')).toHaveLength(0);
   });
 });
+
+describe('scale.scheme on non-chart specs', () => {
+  it('rejects any scheme on a sankey color channel as dead config', () => {
+    // Sankey never reads scale.scheme (node colors cycle theme.colors.categorical),
+    // so even a known name like "blues" must not be silently accepted.
+    for (const scheme of ['viridis', 'blues']) {
+      const result = validateSpec({
+        type: 'sankey',
+        data: [{ source: 'A', target: 'B', value: 10 }],
+        encoding: {
+          source: { field: 'source', type: 'nominal' },
+          target: { field: 'target', type: 'nominal' },
+          value: { field: 'value', type: 'quantitative' },
+          color: { field: 'source', type: 'nominal', scale: { scheme } },
+        },
+      });
+      expect(result.valid).toBe(false);
+      const error = result.errors.find((e) => e.path === 'encoding.color.scale.scheme');
+      expect(error?.code).toBe('INVALID_VALUE');
+      expect(error?.message).toContain('has no effect');
+      expect(error?.suggestion).toContain('theme.colors.categorical');
+    }
+  });
+
+  it('rejects any scheme on a tilemap value channel, pointing at the palette prop', () => {
+    const result = validateSpec({
+      type: 'tilemap',
+      data: [{ state: 'CA', value: 12000 }],
+      encoding: {
+        state: { field: 'state', type: 'nominal' },
+        value: { field: 'value', type: 'quantitative', scale: { scheme: 'viridis' } },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'encoding.value.scale.scheme');
+    expect(error?.code).toBe('INVALID_VALUE');
+    expect(error?.message).toContain('has no effect');
+    expect(error?.suggestion).toContain('palette: "green"');
+  });
+
+  it('rejects any scheme on a barlist color channel as dead config', () => {
+    const result = validateSpec({
+      type: 'barlist',
+      data: [{ label: 'A', value: 42, group: 'x' }],
+      encoding: {
+        label: { field: 'label', type: 'nominal' },
+        value: { field: 'value', type: 'quantitative' },
+        color: { field: 'group', type: 'nominal', scale: { scheme: 'viridis' } },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'encoding.color.scale.scheme');
+    expect(error?.code).toBe('INVALID_VALUE');
+    expect(error?.message).toContain('has no effect');
+  });
+
+  it('rejects any scheme on a graph nodeColor channel as dead config', () => {
+    // Graph never reads scale.scheme (encoding.ts consumes only
+    // scale.range/scale.domain), so even a known name must not pass.
+    for (const scheme of ['viridis', 'blues']) {
+      const result = validateSpec({
+        type: 'graph',
+        nodes: [{ id: 'a', category: 'x' }],
+        edges: [],
+        encoding: {
+          nodeColor: { field: 'category', type: 'nominal', scale: { scheme } },
+        },
+      });
+      expect(result.valid).toBe(false);
+      const error = result.errors.find((e) => e.path === 'encoding.nodeColor.scale.scheme');
+      expect(error?.code).toBe('INVALID_VALUE');
+      expect(error?.message).toContain('has no effect');
+      expect(error?.suggestion).toContain('scale.range');
+    }
+  });
+});
+
+describe('scale.scheme on map specs', () => {
+  // Minimal valid TopoJSON topology with one feature
+  const topo = {
+    type: 'Topology',
+    objects: {
+      things: {
+        type: 'GeometryCollection',
+        geometries: [{ type: 'Polygon', arcs: [[0]], id: '01' }],
+      },
+    },
+    arcs: [
+      [
+        [0, 0],
+        [0, 1],
+        [1, 0],
+        [-1, -1],
+      ],
+    ],
+  };
+
+  it('rejects a scheme the map palette set does not support', () => {
+    const result = validateSpec({
+      type: 'map',
+      geo: { features: topo },
+      data: [{ id: '01', value: 5 }],
+      encoding: {
+        key: { field: 'id' },
+        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?.code).toBe('INVALID_VALUE');
+    expect(error?.message).toContain('"viridis" is not a supported map palette');
+    expect(error?.suggestion).toContain('green');
+  });
+
+  it('accepts a supported sequential palette on a map color channel', () => {
+    const result = validateSpec({
+      type: 'map',
+      geo: { features: topo },
+      data: [{ id: '01', value: 5 }],
+      encoding: {
+        key: { field: 'id' },
+        color: { field: 'value', type: 'quantitative', scale: { scheme: 'green' } },
+      },
+    });
+    expect(result.errors.filter((e) => e.path === 'encoding.color.scale.scheme')).toHaveLength(0);
+  });
+
+  it('rejects any scheme on a categorical map color channel as dead config', () => {
+    const result = validateSpec({
+      type: 'map',
+      geo: { features: topo },
+      data: [{ id: '01', region: 'south' }],
+      encoding: {
+        key: { field: 'id' },
+        color: { field: 'region', type: 'nominal', scale: { scheme: 'green' } },
+      },
+    });
+    expect(result.valid).toBe(false);
+    const error = result.errors.find((e) => e.path === 'encoding.color.scale.scheme');
+    expect(error?.code).toBe('INVALID_VALUE');
+    expect(error?.message).toContain('has no effect');
+    expect(error?.suggestion).toContain('scale.range');
+  });
+
+  it('rejects an unsupported scheme on the points layer color channel', () => {
+    const result = validateSpec({
+      type: 'map',
+      geo: { features: topo },
+      data: [],
+      encoding: { key: { field: 'id' } },
+      points: {
+        data: [{ lat: 30, lon: -97, score: 1 }],
+        latitude: { field: 'lat' },
+        longitude: { field: 'lon' },
+        color: { field: 'score', type: 'quantitative', scale: { scheme: 'magma' } },
+      },
+    });
+    const error = result.errors.find((e) => e.path === 'points.color.scale.scheme');
+    expect(error?.code).toBe('INVALID_VALUE');
+    expect(error?.message).toContain('"magma" is not a supported map palette');
+  });
+});

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

@@ -626,4 +626,106 @@ describe('validateSpec', () => {
       expect(result.errors.find((e) => e.code === 'DATA_FIELD_MISSING')).toBeUndefined();
     });
   });
+
+  describe('row/column facet validation', () => {
+    it('validates row channel field and type', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          row: { field: 'nonexistent', type: 'nominal' },
+        },
+      });
+      expect(result.errors.some((e) => e.path === 'encoding.row.field')).toBe(true);
+    });
+
+    it('rejects row with invalid type', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          row: { field: 'country', type: 'quantitative' as 'nominal' },
+        },
+      });
+      expect(result.errors.some((e) => e.path === 'encoding.row.type')).toBe(true);
+    });
+
+    it('rejects row + facet together', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          row: { field: 'country', type: 'nominal' },
+          facet: { field: 'country', type: 'nominal' },
+        },
+      });
+      expect(result.errors.some((e) => e.message.includes('encoding.row and encoding.facet'))).toBe(
+        true,
+      );
+    });
+
+    it('rejects row + column together', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          row: { field: 'country', type: 'nominal' },
+          column: { field: 'date', type: 'ordinal' },
+        },
+      });
+      expect(
+        result.errors.some((e) => e.message.includes('encoding.row and encoding.column')),
+      ).toBe(true);
+    });
+
+    it('accepts valid row channel', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          row: { field: 'country', type: 'nominal' },
+        },
+      });
+      expect(result.errors.filter((e) => e.path?.startsWith('encoding.row'))).toHaveLength(0);
+    });
+
+    it('rejects column + facet together', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'value', type: 'quantitative' },
+          y: { field: 'country', type: 'nominal' },
+          column: { field: 'country', type: 'nominal' },
+          facet: { field: 'country', type: 'nominal' },
+        },
+      });
+      expect(
+        result.errors.some((e) => e.message.includes('encoding.column and encoding.facet')),
+      ).toBe(true);
+    });
+
+    it('accepts valid column channel', () => {
+      const result = validateSpec({
+        mark: 'bar',
+        data: validLineData,
+        encoding: {
+          x: { field: 'country', type: 'nominal' },
+          y: { field: 'value', type: 'quantitative' },
+          column: { field: 'country', type: 'nominal' },
+        },
+      });
+      expect(result.errors.filter((e) => e.path?.startsWith('encoding.column'))).toHaveLength(0);
+    });
+  });
 });

package/src/compiler/keys.ts

@@ -28,22 +28,23 @@ export function serializeKeyValue(v: unknown): string {
  *
  * 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.
+ * Uses U+2E31 (word separator middle dot) as separator - XML-safe and
+ * unlikely to appear in real data values.
  */
+const KEY_DEDUP_SEP = '⸱';
+
 export function dedupeKeys(keys: string[]): string[] {
-  // Count occurrences
   const counts = new Map<string, number>();
   for (const k of keys) {
     counts.set(k, (counts.get(k) ?? 0) + 1);
   }
 
-  // Assign suffixes only to duplicates
   const seen = new Map<string, number>();
   const result: string[] = [];
   for (const k of keys) {
     if (counts.get(k)! > 1) {
       const idx = seen.get(k) ?? 0;
-      result.push(`${k}\x01${idx}`);
+      result.push(`${k}${KEY_DEDUP_SEP}${idx}`);
       seen.set(k, idx + 1);
     } else {
       result.push(k);

package/src/compiler/normalize.ts

@@ -595,6 +595,7 @@ function normalizeMapSpec(spec: MapSpec, _warnings: string[]): NormalizedMapSpec
     watermark: spec.watermark ?? true,
     animation: spec.animation,
     valueFormat: spec.valueFormat,
+    points: spec.points,
   };
 }