remove iterating in parse and instead do for loop in each node, creat…

…e export function for sort index field name

examples/compiled/bar_custom_sort_partial.vg.json

@@ -22,15 +22,15 @@
                     "b": 43
                 },
                 {
-                    "a": "D",
+                    "a": "Z",
                     "b": 91
                 },
                 {
-                    "a": "E",
+                    "a": "Y",
                     "b": 81
                 },
                 {
-                    "a": "F",
+                    "a": "X",
                     "b": 53
                 }
             ]

examples/specs/bar_custom_sort_partial.vl.json

@@ -4,7 +4,7 @@
   "data": {
     "values": [
       {"a": "A","b": 28}, {"a": "B","b": 55}, {"a": "C","b": 43},
-      {"a": "D","b": 91}, {"a": "E","b": 81}, {"a": "F","b": 53}
+      {"a": "Z","b": 91}, {"a": "Y","b": 81}, {"a": "X","b": 53}
     ]
   },
   "mark": "bar",

src/compile/data/calculate.ts

@@ -1,9 +1,9 @@
-import {ChannelDef, isScaleFieldDef} from '../../fielddef';
+import {isScaleFieldDef, ScaleFieldDef, vgField} from '../../fielddef';
 import {isSortArray} from '../../sort';
 import {duplicate} from '../../util';
 import {VgFormulaTransform} from '../../vega.schema';
 import {ModelWithField} from '../model';
-import {Channel} from './../../channel';
+import {SingleDefChannel} from './../../channel';
 import {CalculateTransform} from './../../transform';
 import {DataFlowNode} from './dataflow';
 
@@ -19,19 +19,18 @@ export class CalculateNode extends DataFlowNode {
     super(parent);
   }
 
-  public static makeAllForSortIndex(parent: DataFlowNode, model: ModelWithField): CalculateNode[] {
+  public static parseAllForSortIndex(parent: DataFlowNode, model: ModelWithField) {
     // get all the encoding with sort fields from model
-    const nodes = model.reduceFieldDef((acc: CalculateNode[], fieldDef: ChannelDef<any>, channel: Channel) => {
+    model.forEachFieldDef((fieldDef: ScaleFieldDef<string>, channel: SingleDefChannel) => {
       if (isScaleFieldDef(fieldDef) && isSortArray(fieldDef.sort)) {
         const transform: CalculateTransform = {
           calculate: CalculateNode.calculateExpressionFromSortField(fieldDef.field, fieldDef.sort),
-          as: `${channel}_${fieldDef.field}_sort_index`
+          as: sortArrayIndexField(model, channel)
         };
-         acc.push(new CalculateNode(parent, transform));
+        parent = new CalculateNode(parent, transform);
       }
-      return acc;
-    }, [] as CalculateNode[]);
-    return nodes;
+    });
+    return parent;
   }
 
   public static calculateExpressionFromSortField(field: string, sortFields: string[]): string {
@@ -58,3 +57,8 @@ export class CalculateNode extends DataFlowNode {
     };
   }
 }
+
+export function sortArrayIndexField(model: ModelWithField, channel: SingleDefChannel) {
+  const fieldDef = model.fieldDef(channel);
+  return `${channel}_${vgField(fieldDef)}_sort_index`;
+}

src/compile/data/parse.ts

@@ -204,10 +204,7 @@ export function parseData(model: Model): DataComponent {
     }
 
     head = TimeUnitNode.makeFromEncoding(head, model) || head;
-
-    for (const calculate of CalculateNode.makeAllForSortIndex(head, model)) {
-      head = calculate;
-    }
+    head = CalculateNode.parseAllForSortIndex(head, model);
   }
 
   // add an output node pre aggregation

src/compile/scale/domain.ts

@@ -21,6 +21,7 @@ import {
   VgUnionSortField,
 } from '../../vega.schema';
 import {binRequiresRange} from '../common';
+import {sortArrayIndexField} from '../data/calculate';
 import {FACET_SCALE_PREFIX} from '../data/optimize';
 import {isFacetModel, isUnitModel, Model} from '../model';
 import {SELECTION_DOMAIN} from '../selection/selection';
@@ -271,7 +272,7 @@ export function domainSort(model: UnitModel, channel: ScaleChannel, scaleType: S
   if (isSortArray(sort)) {
     return {
       op: 'min',
-      field: `${channel}_${model.vgField(channel)}_sort_index`,
+      field: sortArrayIndexField(model, channel),
       order: 'ascending'
     };
   }

src/fielddef.ts

@@ -182,7 +182,7 @@ export interface ScaleFieldDef<F> extends FieldDef<F> {
 
   /**
    * Sort order for the encoded field.
-   * Supported `sort` values include `"ascending"`, `"descending"`, `array specifying the preferred order of values` and `null` (no sorting).
+   * Supported `sort` values include `"ascending"`, `"descending"`, `null` (no sorting), or an array specifying the preferred order of values.
    * For fields with discrete domains, `sort` can also be a [sort field definition object](https://vega.github.io/vega-lite/docs/sort.html#sort-field).
    * For `sort` as an [array specifying the preferred order of values](https://vega.github.io/vega-lite/docs/sort.html#sort-array), the sort order will obey the values in the array, followed by any unspecified values in their original order.
    *

test/compile/data/calculate.test.ts

@@ -6,7 +6,8 @@ import {ModelWithField} from '../../../src/compile/model';
 import {parseUnitModel} from '../../util';
 
 function assembleFromSortArray(model: ModelWithField) {
-  return CalculateNode.makeAllForSortIndex(null, model).map(n => n.assemble());
+  const node = CalculateNode.parseAllForSortIndex(null, model) as CalculateNode;
+  return node.assemble();
 }
 
 describe('compile/data/calculate', function () {
@@ -24,11 +25,11 @@ describe('compile/data/calculate', function () {
         }
     });
     const nodes = assembleFromSortArray(model);
-    assert.deepEqual(nodes, [{
+    assert.deepEqual(nodes, {
       type: 'formula',
       expr: "datum.a === 'B' ? 0 : datum.a === 'A' ? 1 : datum.a === 'C' ? 2 : 3",
       as: 'x_a_sort_index'
-    }]);
+    });
   });
 
   describe('calculateExpressionFromSortField', function () {