Fix logic for window’s default as

src/compile/data/aggregate.ts

@@ -73,18 +73,19 @@ export class AggregateNode extends DataFlowNode {
     }
 
     model.forEachFieldDef((fieldDef, channel) => {
-      if (fieldDef.aggregate) {
-        if (fieldDef.aggregate === 'count') {
+      const {aggregate, field} = fieldDef;
+      if (aggregate) {
+        if (aggregate === 'count') {
           meas['*'] = meas['*'] || {};
-          meas['*']['count'] = vgField(fieldDef, {aggregate: 'count'});
+          meas['*']['count'] = vgField(fieldDef);
         } else {
-          meas[fieldDef.field] = meas[fieldDef.field] || {};
-          meas[fieldDef.field][fieldDef.aggregate] = vgField(fieldDef);
+          meas[field] = meas[field] || {};
+          meas[field][aggregate] = vgField(fieldDef);
 
           // For scale channel with domain === 'unaggregated', add min/max so we can use their union as unaggregated domain
           if (isScaleChannel(channel) && model.scaleDomain(channel) === 'unaggregated') {
-            meas[fieldDef.field]['min'] = vgField(fieldDef, {aggregate: 'min'});
-            meas[fieldDef.field]['max'] = vgField(fieldDef, {aggregate: 'max'});
+            meas[field]['min'] = vgField({field, aggregate: 'min'});
+            meas[field]['max'] = vgField({field, aggregate: 'max'});
           }
         }
       } else {
@@ -104,13 +105,14 @@ export class AggregateNode extends DataFlowNode {
     const meas = {};
 
     for (const s of t.aggregate) {
-      if (s.op) {
-        if (s.op === 'count') {
+      const {op, field, as} = s;
+      if (op) {
+        if (op === 'count') {
           meas['*'] = meas['*'] || {};
-          meas['*']['count'] = s.as || vgField(s);
+          meas['*']['count'] = as || vgField(s);
         } else {
-          meas[s.field] = meas[s.field] || {};
-          meas[s.field][s.op] = s.as || vgField(s);
+          meas[field] = meas[field] || {};
+          meas[field][op] = as || vgField(s);
         }
       }
     }

src/compile/data/window.ts

@@ -1,4 +1,5 @@
 import {AggregateOp} from 'vega';
+import {vgField} from '../../fielddef';
 import {WindowFieldDef, WindowOnlyOp, WindowTransform} from '../../transform';
 import {duplicate} from '../../util';
 import {VgComparator, VgComparatorOrder, VgWindowTransform} from '../../vega.schema';
@@ -26,7 +27,7 @@ export class WindowTransformNode extends DataFlowNode {
   }
 
   private getDefaultName(windowFieldDef: WindowFieldDef): string {
-    return windowFieldDef.as === undefined ? String(windowFieldDef.op) + '_field' : windowFieldDef.as;
+    return windowFieldDef.as || vgField(windowFieldDef);
   }
 
   public assemble(): VgWindowTransform {

src/compile/scale/domain.ts

@@ -4,7 +4,7 @@ import {binToString, isBinParams} from '../../bin';
 import {isScaleChannel, ScaleChannel} from '../../channel';
 import {MAIN, RAW} from '../../data';
 import {DateTime, dateTimeExpr, isDateTime} from '../../datetime';
-import {FieldDef, ScaleFieldDef} from '../../fielddef';
+import {FieldDef, ScaleFieldDef, vgField} from '../../fielddef';
 import * as log from '../../log';
 import {Domain, hasDiscreteDomain, isBinScale, isSelectionDomain, ScaleConfig, ScaleType} from '../../scale';
 import {EncodingSortField, isSortArray, isSortField} from '../../sort';
@@ -192,12 +192,13 @@ function parseSingleChannelDomain(scaleType: ScaleType, domain: Domain, model: U
 
   if (domain === 'unaggregated') {
     const data = model.requestDataName(MAIN);
+    const {field} = fieldDef;
     return [{
       data,
-      field: model.vgField(channel, {aggregate: 'min'})
+      field: vgField({field, aggregate: 'min'})
     }, {
       data,
-      field: model.vgField(channel, {aggregate: 'max'})
+      field: vgField({field, aggregate: 'max'})
     }];
   } else if (fieldDef.bin) { // bin
     if (isBinScale(scaleType)) {

src/fielddef.ts

@@ -16,6 +16,7 @@ import {Scale} from './scale';
 import {EncodingSortField, SortOrder} from './sort';
 import {StackOffset} from './stack';
 import {getTimeUnitParts, normalizeTimeUnit, TimeUnit} from './timeunit';
+import {AggregatedFieldDef, WindowFieldDef} from './transform';
 import {getFullName, QUANTITATIVE, Type} from './type';
 import {flatAccessWithDatum, replacePathInField, titlecase} from './util';
 
@@ -298,11 +299,13 @@ export interface FieldRefOption {
   binSuffix?: 'end' | 'range' | 'mid';
   /** append suffix to the field ref (general) */
   suffix?: string;
-  /** Override which aggregate to use. Needed for unaggregated domain. */
-  aggregate?: AggregateOp;
 }
 
-export function vgField(fieldDef: FieldDefBase<string>, opt: FieldRefOption = {}): string {
+function isOpFieldDef(fieldDef: FieldDefBase<string> | WindowFieldDef | AggregatedFieldDef): fieldDef is WindowFieldDef | AggregatedFieldDef {
+  return !!fieldDef['op'];
+}
+
+export function vgField(fieldDef: FieldDefBase<string> | WindowFieldDef | AggregatedFieldDef, opt: FieldRefOption = {}): string {
   let field = fieldDef.field;
   const prefix = opt.prefix;
   let suffix = opt.suffix;
@@ -313,18 +316,20 @@ export function vgField(fieldDef: FieldDefBase<string>, opt: FieldRefOption = {}
     let fn: string = undefined;
 
     if (!opt.nofn) {
-      if (fieldDef.bin) {
+      if (isOpFieldDef(fieldDef)) {
+        fn = fieldDef.op;
+      } else if (fieldDef.bin) {
         fn = binToString(fieldDef.bin);
         suffix = opt.binSuffix || '';
       } else if (fieldDef.aggregate) {
-        fn = String(opt.aggregate || fieldDef.aggregate);
+        fn = String(fieldDef.aggregate);
       } else if (fieldDef.timeUnit) {
         fn = String(fieldDef.timeUnit);
       }
     }
 
     if (fn) {
-      field = `${fn}_${field}`;
+      field = field ? `${fn}_${field}` : fn;
     }
   }
 

test/compile/data/window.test.ts

@@ -5,93 +5,129 @@ import {WindowTransformNode} from '../../../src/compile/data/window';
 import {Transform} from '../../../src/transform';
 
 describe('compile/data/window', () => {
-  describe('TestWindowTransform()', () => {
-    it ('should return a proper vg transform', () => {
-      const transform: Transform = {
-        window: [
+  it('should return a proper vg transform', () => {
+    const transform: Transform = {
+      window: [
+        {
+          op: 'row_number',
+          as: 'ordered_row_number',
+        },
+      ],
+      ignorePeers: false,
+      sort:
+        [
           {
-            op: 'row_number',
-            as: 'ordered_row_number',
-          },
+            field: 'f',
+            order: 'ascending'
+          }
         ],
-        ignorePeers: false,
-        sort:
-          [
-            {
-              field:'f',
-              order:'ascending'
-            }
-          ],
-        groupby: ['f'],
-        frame: [null, 0]
-      };
-      const window = new WindowTransformNode(null, transform);
-      assert.deepEqual(window.assemble(), {
-        type: 'window',
-        ops: ['row_number'],
-        fields: [null],
-        params: [null],
-        sort : {
-          field: ["f"],
-          order: ["ascending"],
-        },
-        ignorePeers: false,
-        as: ['ordered_row_number'],
-        frame: [null, 0],
-        groupby: ['f']
-      });
+      groupby: ['f'],
+      frame: [null, 0]
+    };
+    const window = new WindowTransformNode(null, transform);
+    assert.deepEqual(window.assemble(), {
+      type: 'window',
+      ops: ['row_number'],
+      fields: [null],
+      params: [null],
+      sort: {
+        field: ["f"],
+        order: ["ascending"],
+      },
+      ignorePeers: false,
+      as: ['ordered_row_number'],
+      frame: [null, 0],
+      groupby: ['f']
     });
-    it ('should return a producer proper fields', () => {
-      const transform: Transform = {
-        window: [
-          {
-            op: 'row_number',
-            as: 'ordered_row_number',
-          },
-          {
-            op: 'count',
-            as: 'count_field'
-          },
+  });
+
+  it('should augment as with default as', () => {
+    const transform: Transform = {
+      window: [
+        {
+          op: 'row_number',
+          as: undefined // intentionally omit for testing
+        },
+      ],
+      ignorePeers: false,
+      sort:
+        [
           {
-            op: 'sum',
-            as: 'sum_field'
+            field: 'f',
+            order: 'ascending'
           }
         ],
-        ignorePeers: false,
-        sort:
-          [
-            {
-              field:'f',
-              order:'ascending'
-            }
-          ],
-        groupby: ['f'],
-        frame: [null, 0]
-      };
-      const window = new WindowTransformNode(null, transform);
-      assert.deepEqual({"count_field": true, "ordered_row_number": true, "sum_field": true}, window.producedFields());
+      groupby: ['f'],
+      frame: [null, 0]
+    };
+    const window = new WindowTransformNode(null, transform);
+    assert.deepEqual(window.assemble(), {
+      type: 'window',
+      ops: ['row_number'],
+      fields: [null],
+      params: [null],
+      sort: {
+        field: ["f"],
+        order: ["ascending"],
+      },
+      ignorePeers: false,
+      as: ['row_number'],
+      frame: [null, 0],
+      groupby: ['f']
     });
-    it ('should clone to an equivalent version', () => {
-      const transform: Transform = {
-        window: [
+  });
+
+  it('should return a proper produced fields', () => {
+    const transform: Transform = {
+      window: [
+        {
+          op: 'row_number',
+          as: 'ordered_row_number',
+        },
+        {
+          op: 'count',
+          as: 'count_field'
+        },
+        {
+          op: 'sum',
+          as: 'sum_field'
+        }
+      ],
+      ignorePeers: false,
+      sort:
+        [
           {
-            op: 'row_number',
-            as: 'ordered_row_number',
-          },
+            field:'f',
+            order:'ascending'
+          }
         ],
-        ignorePeers: false,
-        sort:
-          [
-            {
-              field:'f',
-              order:'ascending'
-            }
-          ],
-        groupby: ['f'],
-        frame: [null, 0]
-      };
-      const window = new WindowTransformNode(null, transform);
-      assert.deepEqual(window, window.clone());
-    });
+      groupby: ['f'],
+      frame: [null, 0]
+    };
+    const window = new WindowTransformNode(null, transform);
+    assert.deepEqual({"count_field": true, "ordered_row_number": true, "sum_field": true}, window.producedFields());
+  });
+
+  it('should clone to an equivalent version', () => {
+    const transform: Transform = {
+      window: [
+        {
+          op: 'row_number',
+          as: 'ordered_row_number',
+        },
+      ],
+      ignorePeers: false,
+      sort:
+        [
+          {
+            field:'f',
+            order:'ascending'
+          }
+        ],
+      groupby: ['f'],
+      frame: [null, 0]
+    };
+    const window = new WindowTransformNode(null, transform);
+    assert.deepEqual(window, window.clone());
   });
 });