@splunk/visualization-encoding-parsers 25.7.2 → 25.8.1

package/Base.js

@@ -240,55 +240,46 @@ var find_default = /*#__PURE__*/__webpack_require__.n(find_);
 var format_hasOwnProperty = Object.prototype.hasOwnProperty;
 var rangeFormat = function rangeFormat(value) {
   var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      ranges = _ref.ranges,
-      values = _ref.values;
-
+    ranges = _ref.ranges,
+    values = _ref.values;
   if (Array.isArray(ranges) && Array.isArray(values) && !Number.isNaN(value)) {
     var floatVal = parseFloat(value);
-
     for (var i = 0; i < ranges.length; i += 1) {
       // bad range value
       if (Number.isNaN(Number(ranges[i]))) {
         // Could not format value: Ranges are required to be numbers. Falling back to original value
         return value;
-      } // value is less than the range limit
-
-
+      }
+      // value is less than the range limit
       if (floatVal <= parseFloat(ranges[i])) {
         var valueIndex = Math.min(i, values.length - 1); // correct the index if there are more range items than values
-
         if (values[valueIndex]) {
           return values[valueIndex];
         }
       }
     }
-
     if (floatVal > parseFloat(ranges[ranges.length - 1])) {
       return values[values.length - 1];
     }
-  } // Could not format value: Ranges and Value are required to be numbers
-
-
+  }
+  // Could not format value: Ranges and Value are required to be numbers
   return value;
 };
 var categoryFormat = function categoryFormat(value, _ref2) {
   var categories = _ref2.categories,
-      values = _ref2.values;
-
+    values = _ref2.values;
   if (!(Array.isArray(categories) && Array.isArray(values) && categories.length === values.length)) {
     // Could not format value: categories & values should be arrays of the same length. Falling back to original value
     return value;
   }
-
   var valueIndex = categories.indexOf(value);
-
   if (valueIndex > -1) {
     return values[valueIndex];
-  } // Could not format value: Category does not exist. Falling back to original value
-
-
+  }
+  // Could not format value: Category does not exist. Falling back to original value
   return value;
 };
+
 /**
  * based on a range configuration this formatter maps the value to a value specified in a range.
  * the range fitting follows this criteria: `range.from <= value < range.to` so the `to` value is not included
@@ -301,27 +292,27 @@ var categoryFormat = function categoryFormat(value, _ref2) {
  * @param {object} formatConfig
  * @param {Object[]} formatConfig.ranges
  */
-
 var rangeValueFormat = function rangeValueFormat(value, _ref3) {
   var _ref3$ranges = _ref3.ranges,
-      ranges = _ref3$ranges === void 0 ? [] : _ref3$ranges;
+    ranges = _ref3$ranges === void 0 ? [] : _ref3$ranges;
   var floatValue = parseFloat(value);
-
   if (Number.isNaN(Number(value))) {
     return value;
   }
-
   for (var i = 0; i < ranges.length; i += 1) {
-    if ( // open upper bound: value is bigger than or equal to open upper bound start (from)
-    i === 0 && format_hasOwnProperty.call(ranges[i], 'from') && floatValue >= ranges[i].from || // inbetween: value falls into from - to range
-    floatValue >= ranges[i].from && floatValue < ranges[i].to || // open lower bound: value is smaller than or equal to open lower bound end (to)
+    if (
+    // open upper bound: value is bigger than or equal to open upper bound start (from)
+    i === 0 && format_hasOwnProperty.call(ranges[i], 'from') && floatValue >= ranges[i].from ||
+    // inbetween: value falls into from - to range
+    floatValue >= ranges[i].from && floatValue < ranges[i].to ||
+    // open lower bound: value is smaller than or equal to open lower bound end (to)
     i === ranges.length - 1 && format_hasOwnProperty.call(ranges[i], 'to') && floatValue < ranges[i].to) {
       return ranges[i].value;
     }
   }
-
   return value;
 };
+
 /**
  * this formatter maps the value to a value specified in a list of potential matches .
  * if the value passed is a match for what is provided in `matches[i].match`, we return that mapped value `matches[i].value`.
@@ -334,12 +325,11 @@ var rangeValueFormat = function rangeValueFormat(value, _ref3) {
  * @param {Object[]} formatConfig.matches
  * @param {object} formatConfig.defaultValue
  */
-
 var format_matchValueFormat = function matchValueFormat(value, _ref4) {
   var _ref4$matches = _ref4.matches,
-      matches = _ref4$matches === void 0 ? [] : _ref4$matches,
-      _ref4$defaultValue = _ref4.defaultValue,
-      defaultValue = _ref4$defaultValue === void 0 ? undefined : _ref4$defaultValue;
+    matches = _ref4$matches === void 0 ? [] : _ref4$matches,
+    _ref4$defaultValue = _ref4.defaultValue,
+    defaultValue = _ref4$defaultValue === void 0 ? undefined : _ref4$defaultValue;
   var defaultResult = isUndefined_default()(defaultValue) ? value : defaultValue;
   var matchResult = find_default()(matches, function (match) {
     return match.match && match.match === value;
@@ -349,6 +339,7 @@ var format_matchValueFormat = function matchValueFormat(value, _ref4) {
 var NON_NUMERIC_RANGE_ERROR = 'Could not format value: Ranges are required to be numbers. Falling back to first color';
 var VALUES_AND_RANGES_HAVE_DIFFERENT_LENGTH = 'gradient ranges and values must have the same number of elements';
 var INVALID_VALUE = 'Could not format value for gradient:';
+
 /**
  * based on ranges and values this formatter maps the value to an interpolated color
  *
@@ -359,38 +350,31 @@ var INVALID_VALUE = 'Could not format value for gradient:';
  * @param {string[]} data the data to be formatted
  * @param errorHandler function
  */
-
 var format_colorGradientFormat = function colorGradientFormat(value, _ref5, data, errorHandler) {
   var ranges = _ref5.ranges,
-      values = _ref5.values;
+    values = _ref5.values;
   var colorValues = values;
   var colorRanges = ranges;
-
   function errorColor() {
     return colorValues ? external_chroma_js_default()(colorValues[0]).hex().toUpperCase() : '#000';
   }
-
   if (!Number.isNaN(Number(value))) {
     // set default values for gradient colors if values not explicit
     if (!colorValues) {
       colorValues = ['white', 'red'];
     }
-
     if (colorValues.length === 1) {
       colorValues.unshift('white'); // force color bin to have a lower bound color
-    } // set default values for ranges if ranges not explicit
-
-
+    }
+    // set default values for ranges if ranges not explicit
     if (!ranges) {
       if (data && data.length > 0) {
         var min = data.length > 0 ? Math.min.apply(null, data) : undefined;
         var max = data.length > 0 ? Math.max.apply(null, data) : undefined;
         colorRanges = [min];
-
         for (var i = 1; i < colorValues.length - 1; i += 1) {
           colorRanges.push(min + i * (max - min) / (colorValues.length - 1));
         }
-
         colorRanges.push(max);
       } else {
         colorRanges = [0, 1]; // no data values, so just make the range from zero to 1
@@ -404,23 +388,22 @@ var format_colorGradientFormat = function colorGradientFormat(value, _ref5, data
     colorRanges.sort(function (a, b) {
       return a - b;
     }); // force ascending order of range stops
-
     if (colorRanges.length !== colorValues.length) {
       errorHandler(VALUES_AND_RANGES_HAVE_DIFFERENT_LENGTH);
       return errorColor();
     }
+    var floatVal = parseFloat(value);
 
-    var floatVal = parseFloat(value); // don't let value be outside the allowed range
-
+    // don't let value be outside the allowed range
     if (floatVal > parseFloat(colorRanges[colorRanges.length - 1])) {
       return external_chroma_js_default()(colorValues[colorValues.length - 1]).hex().toUpperCase(); // high end
     }
 
     if (floatVal < parseFloat(colorRanges[0])) {
       return external_chroma_js_default()(colorValues[0]).hex().toUpperCase(); // low end
-    } // find the color gradient range that the value is inside
-
+    }
 
+    // find the color gradient range that the value is inside
     for (var _i = 1; _i < colorRanges.length; _i += 1) {
       // bad range value
       if (Number.isNaN(Number(colorRanges[_i]))) {
@@ -428,14 +411,13 @@ var format_colorGradientFormat = function colorGradientFormat(value, _ref5, data
         errorHandler(NON_NUMERIC_RANGE_ERROR);
         return errorColor();
       }
-
       var upperVal = colorRanges[_i];
-
       if (floatVal <= upperVal) {
         // if value is inside the bin
         var lowerVal = colorRanges[_i - 1];
-        var tau = (value - lowerVal) / (upperVal - lowerVal); // deal with special case when the upper and lower and bounds of the colorRange is equal
+        var tau = (value - lowerVal) / (upperVal - lowerVal);
 
+        // deal with special case when the upper and lower and bounds of the colorRange is equal
         if (upperVal === lowerVal) {
           if (value === 0) {
             // user prolly expects lower end of color range if value is zero
@@ -450,9 +432,8 @@ var format_colorGradientFormat = function colorGradientFormat(value, _ref5, data
         return external_chroma_js_default.a.scale([lowerColor, upperColor])(tau).hex().toUpperCase();
       }
     }
-  } // eslint-disable-next-line
-
-
+  }
+  // eslint-disable-next-line
   errorHandler("".concat(INVALID_VALUE, " ").concat(value));
   return errorColor();
 };
@@ -468,10 +449,10 @@ var newFormatterErrorHandler = function newFormatterErrorHandler(maxErrors, hand
     if (errorCount < maxErrors) {
       handlerFunc(msg);
     }
-
     errorCount += 1;
   };
 };
+
 /**
  * returns a formatter function based on a format config
  * @param {Object} formatCfg formatter config
@@ -480,50 +461,44 @@ var newFormatterErrorHandler = function newFormatterErrorHandler(maxErrors, hand
  * @param {string[]|number[]} formatCfg.categories  an array of categories. categories are used for a 1:1 mapping to values. requires formatCfg.values
  * @param {number[]} data the data to be formatted
  */
-
 var getFormatter = function getFormatter(data) {
   var formatCfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
   if (formatCfg.type) {
     if (formatters[formatCfg.type]) {
       // @TODO(pwied):
       // future: should formatters have prepare stage where params are validated
       // and additional formatting context is generated (e.g. min & max value)
       return function (value) {
-        return formatters[formatCfg.type](value, formatCfg, data, // eslint-disable-next-line no-console
+        return formatters[formatCfg.type](value, formatCfg, data,
+        // eslint-disable-next-line no-console
         newFormatterErrorHandler(MAX_LOGGED_FORMATTER_ERRORS, function (msg) {
           return console.warn(msg);
         }));
       };
     }
-
     return function (value) {
       return value;
     };
-  } // @TODO(pwied):
+  }
+  // @TODO(pwied):
   // - remove post beta deadline
   // - move to formatters with type option
   // - leaving it here for now because Choropleth builds on it
-
-
   var ranges = formatCfg.ranges,
-      values = formatCfg.values;
-
+    values = formatCfg.values;
   if (values) {
     if (ranges) {
       return function (value) {
         return rangeFormat(value, formatCfg);
       };
     }
-
     if (formatCfg.categories) {
       return function (value) {
         return categoryFormat(value, formatCfg);
       };
     }
-  } // eslint-disable-next-line
-
-
+  }
+  // eslint-disable-next-line
   console.warn('Could not find a formatter. Falling back to identity fn');
   return function (value) {
     return value;
@@ -536,6 +511,7 @@ var isFinite_default = /*#__PURE__*/__webpack_require__.n(isFinite_);
 // CONCATENATED MODULE: ./src/util/types.js
 
 
+
 /**
  * getDataTypeForPoint
  * naive implementation of checking for the data type of a single data point
@@ -545,23 +521,20 @@ var isFinite_default = /*#__PURE__*/__webpack_require__.n(isFinite_);
  * @param {any} dataPoint
  * @return {string} type
  */
-
 var types_getDataTypeForPoint = function getDataTypeForPoint(dataPoint) {
   if (isFinite_default()(+dataPoint) && isNumber_default()(+dataPoint)) {
     return 'number';
   }
-
   if (!Number.isNaN(Date.parse(dataPoint))) {
     return 'time';
   }
-
   if (typeof dataPoint === 'string') {
     return 'string';
-  } // nulls, objects, etc
-
-
+  }
+  // nulls, objects, etc
   return 'unknown';
 };
+
 /**
  * inferDataTypeFromSample
  * based on a number of data points this function determines the data type for all of them
@@ -570,7 +543,6 @@ var types_getDataTypeForPoint = function getDataTypeForPoint(dataPoint) {
  * @param {Array} dataSample an array of arbitrary size containing data points of any data type
  * @return {string} type the most common type in the sample
  */
-
 var inferDataTypeFromSample = function inferDataTypeFromSample(dataSample) {
   var typeMatches = {
     time: 0,
@@ -591,6 +563,7 @@ var inferDataTypeFromSample = function inferDataTypeFromSample(dataSample) {
   });
   return returnType;
 };
+
 /**
  * based on a data array (e.g. one data column) this function returns a tiny sample of it
  * @TODO: very naive approach. there's papers with more advanced techniques but for now this should be very fast
@@ -598,55 +571,39 @@ var inferDataTypeFromSample = function inferDataTypeFromSample(dataSample) {
  * @param {Array} data to draw a sample from
  * @return {Array} a sample of the passed data
  */
-
 var drawSample = function drawSample(data) {
   if (data.length > 2) {
     return [data[0], data[Math.floor(data.length / 2)], data[data.length - 1]];
   }
-
   if (data.length === 2) {
     return [data[0], data[1]];
-  } // small enough to check everything
-
-
+  }
+  // small enough to check everything
   return data;
 };
 // CONCATENATED MODULE: ./src/Base.js
 
 
 
-
 function ownKeys(object, enumerableOnly) {
   var keys = Object.keys(object);
-
   if (Object.getOwnPropertySymbols) {
     var symbols = Object.getOwnPropertySymbols(object);
-    if (enumerableOnly) symbols = symbols.filter(function (sym) {
+    enumerableOnly && (symbols = symbols.filter(function (sym) {
       return Object.getOwnPropertyDescriptor(object, sym).enumerable;
-    });
-    keys.push.apply(keys, symbols);
+    })), keys.push.apply(keys, symbols);
   }
-
   return keys;
 }
-
 function _objectSpread(target) {
   for (var i = 1; i < arguments.length; i++) {
-    var source = arguments[i] != null ? arguments[i] : {};
-
-    if (i % 2) {
-      ownKeys(Object(source), true).forEach(function (key) {
-        defineProperty_default()(target, key, source[key]);
-      });
-    } else if (Object.getOwnPropertyDescriptors) {
-      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
-    } else {
-      ownKeys(Object(source)).forEach(function (key) {
-        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
-      });
-    }
+    var source = null != arguments[i] ? arguments[i] : {};
+    i % 2 ? ownKeys(Object(source), !0).forEach(function (key) {
+      defineProperty_default()(target, key, source[key]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) {
+      Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+    });
   }
-
   return target;
 }
 
@@ -655,8 +612,6 @@ function _objectSpread(target) {
 
 
 
-
-
 var getDataForDataSourceType = function getDataForDataSourceType(data, dataSourceType) {
   if (!dataSourceType || !data[dataSourceType] || !data[dataSourceType].data) {
     // @TODO: warn about datasource type not being found
@@ -665,7 +620,6 @@ var getDataForDataSourceType = function getDataForDataSourceType(data, dataSourc
       columns: []
     };
   }
-
   return data[dataSourceType].data;
 };
 /*
@@ -673,20 +627,16 @@ var getDataForDataSourceType = function getDataForDataSourceType(data, dataSourc
  * @param {String} fieldIndexRangeStr   '0:', '0:5', ':5'
  * @returns {Object} info about parsed range if there is any
  */
-
-
 var Base_parseFieldRangeReference = function parseFieldRangeReference(fieldIndexRangeStr) {
   if (!fieldIndexRangeStr || fieldIndexRangeStr.indexOf(':') === -1) {
     return {
       isFieldIndexRange: false
     };
   }
-
   var _fieldIndexRangeStr$s = fieldIndexRangeStr.split(':'),
-      _fieldIndexRangeStr$s2 = slicedToArray_default()(_fieldIndexRangeStr$s, 2),
-      fromFieldIndexStr = _fieldIndexRangeStr$s2[0],
-      toFieldIndexStr = _fieldIndexRangeStr$s2[1];
-
+    _fieldIndexRangeStr$s2 = slicedToArray_default()(_fieldIndexRangeStr$s, 2),
+    fromFieldIndexStr = _fieldIndexRangeStr$s2[0],
+    toFieldIndexStr = _fieldIndexRangeStr$s2[1];
   return {
     isFieldIndexRange: true,
     fromFieldIndex: Number.isNaN(Number(fromFieldIndexStr)) || !fromFieldIndexStr ? 0 : Number(fromFieldIndexStr),
@@ -698,7 +648,6 @@ var Base_parseFieldRangeReference = function parseFieldRangeReference(fieldIndex
  * @param {String} fieldReferenceStr   'primary[1][123]'
  * @returns {Object} { fieldIndex: 1, columnIndex: 123, isFieldIndexRange: true, fromFieldIndexRange: 0, toFieldIndexRange: 3 }
  */
-
 var parseIndexBasedFieldReference = function parseIndexBasedFieldReference(fieldReferenceStr) {
   var indices = fieldReferenceStr.replace(/^[A-Za-z0-9]+/, '').replace(/\[/g, '').replace(/\]/g, ',').split(',');
   var dataSourceName = fieldReferenceStr.match(/^[A-Za-z0-9]+/)[0];
@@ -709,12 +658,12 @@ var parseIndexBasedFieldReference = function parseIndexBasedFieldReference(field
     columnIndex: Number.isNaN(Number(indices[1])) || !indices[1] ? null : Number(indices[1])
   }, fieldRange);
 };
+
 /*
  * parse fieldReferenceStr to get field name and column index for user defined encoding. e.g. 'primary.color[123]'
  * @param {String} fieldReferenceStr   'primary.color[123]'
  * @returns {Object} { fieldName: 'color', columnIndex: 123 }
  */
-
 var parseNameBasedFieldReference = function parseNameBasedFieldReference(fieldReferenceStr) {
   var dataSourceName = fieldReferenceStr.match(/^[A-Za-z0-9]+/)[0];
   var fieldNameStr = fieldReferenceStr.split('.')[1];
@@ -727,54 +676,42 @@ var parseNameBasedFieldReference = function parseNameBasedFieldReference(fieldRe
     columnIndex: columnIndex
   };
 };
-
 var Base_getDataForIndexBasedFieldReference = function getDataForIndexBasedFieldReference(data, fieldReferenceStr) {
   var fields = data.fields,
-      columns = data.columns;
-
+    columns = data.columns;
   var _parseIndexBasedField = parseIndexBasedFieldReference(fieldReferenceStr),
-      dataSourceName = _parseIndexBasedField.dataSourceName,
-      isFieldIndexRange = _parseIndexBasedField.isFieldIndexRange,
-      fromFieldIndex = _parseIndexBasedField.fromFieldIndex,
-      toFieldIndex = _parseIndexBasedField.toFieldIndex,
-      fieldIndex = _parseIndexBasedField.fieldIndex,
-      columnIndex = _parseIndexBasedField.columnIndex;
-
+    dataSourceName = _parseIndexBasedField.dataSourceName,
+    isFieldIndexRange = _parseIndexBasedField.isFieldIndexRange,
+    fromFieldIndex = _parseIndexBasedField.fromFieldIndex,
+    toFieldIndex = _parseIndexBasedField.toFieldIndex,
+    fieldIndex = _parseIndexBasedField.fieldIndex,
+    columnIndex = _parseIndexBasedField.columnIndex;
   if (isFieldIndexRange) {
     var dataForRange = [];
-
     if (fromFieldIndex > -1) {
       var endIndex = toFieldIndex > -1 ? Math.min(fields.length - 1, toFieldIndex) : fields.length + toFieldIndex;
-
       for (var i = fromFieldIndex; i <= endIndex; i += 1) {
         dataForRange.push(getDataForIndexBasedFieldReference(data, "".concat(dataSourceName, "[").concat(i, "][").concat(columnIndex, "]")));
       }
-
       return dataForRange;
     }
   }
-
   if (isNumber_default()(fieldIndex)) {
     var isNegative = fieldIndex < 0;
     var absoluteIndex = Math.abs(fieldIndex);
-
     if (isNegative && absoluteIndex > fields.length || !isNegative && fieldIndex > fields.length - 1) {
       // The field index is out of bounds
       return {};
     }
-
     var correctedFieldIndex = isNegative ? fields.length - absoluteIndex : fieldIndex;
     var fieldName = typeof_default()(fields[correctedFieldIndex]) === 'object' ? fields[correctedFieldIndex].name : fields[correctedFieldIndex];
     var fieldData;
-
     if (isNumber_default()(columnIndex)) {
       var isNegativeColumnIndex = columnIndex < 0;
-
       if (isNegativeColumnIndex && columnIndex < -columns[correctedFieldIndex].length || columnIndex >= columns[correctedFieldIndex].length) {
         // The column index is out of bounds
         return {};
       }
-
       var correctColumnIndex = isNegativeColumnIndex ? columns[correctedFieldIndex].length + columnIndex : columnIndex;
       fieldData = columns[correctedFieldIndex].map(function () {
         return columns[correctedFieldIndex][correctColumnIndex];
@@ -782,41 +719,31 @@ var Base_getDataForIndexBasedFieldReference = function getDataForIndexBasedField
     } else {
       fieldData = columns[correctedFieldIndex];
     }
-
     return {
       fieldName: fieldName,
       data: fieldData
     };
   }
-
   return {};
 };
-
 var Base_getDataForNameBasedFieldReference = function getDataForNameBasedFieldReference(data, fieldReferenceStr) {
   var fields = data.fields,
-      columns = data.columns;
-
+    columns = data.columns;
   var _parseNameBasedFieldR = parseNameBasedFieldReference(fieldReferenceStr),
-      fieldName = _parseNameBasedFieldR.fieldName,
-      columnIndex = _parseNameBasedFieldR.columnIndex; // <datasource>.<fieldname>[0]
-
-
+    fieldName = _parseNameBasedFieldR.fieldName,
+    columnIndex = _parseNameBasedFieldR.columnIndex; // <datasource>.<fieldname>[0]
   if (fieldName) {
     var fieldIndex = findIndex_default()(fields, function (field) {
       return typeof_default()(field) === 'object' ? field.name === fieldName : field === fieldName;
     });
-
     if (fieldIndex > -1) {
       var fieldData;
-
       if (isNumber_default()(columnIndex)) {
         var isNegativeColumnIndex = columnIndex < 0;
-
         if (isNegativeColumnIndex && columnIndex < -columns[fieldIndex].length || columnIndex >= columns[fieldIndex].length) {
           // The column index is out of bounds
           return {};
         }
-
         var correctColumnIndex = isNegativeColumnIndex ? columns[fieldIndex].length + columnIndex : columnIndex;
         fieldData = columns[fieldIndex].map(function () {
           return columns[fieldIndex][correctColumnIndex];
@@ -824,100 +751,80 @@ var Base_getDataForNameBasedFieldReference = function getDataForNameBasedFieldRe
       } else {
         fieldData = columns[fieldIndex];
       }
-
       return {
         fieldName: fieldName,
         data: fieldData
       };
-    } // eslint-disable-next-line
-
-
+    }
+    // eslint-disable-next-line
     console.warn("field '".concat(fieldName, "' not available."));
     return {};
   }
-
   return {};
 };
-
 var Base_getDataForFieldReference = function getDataForFieldReference(dataSources, fieldReference) {
   var fieldReferenceStr = fieldReference;
   var formatValue;
-
   if (Array.isArray(fieldReference) && !fieldReference.isDefault) {
     return fieldReference.map(function (ref) {
       return getDataForFieldReference(dataSources, ref);
     });
-  } // if the reference is a default and there is multiple default fields to fall back
-
-
+  }
+  // if the reference is a default and there is multiple default fields to fall back
   if (fieldReference.isDefault && Array.isArray(fieldReference.field)) {
     // iterate through all defaults and check whether the data type matches the expected type
     for (var i = 0; i < fieldReference.field.length; i += 1) {
       fieldReferenceStr = fieldReference.field[i];
       var dataFromDefault = getDataForFieldReference(dataSources, fieldReferenceStr);
-
       if (Array.isArray(dataFromDefault.data)) {
         var type = inferDataTypeFromSample(drawSample(dataFromDefault.data));
-
         if (fieldReference.type.indexOf(type) > -1) {
           return dataFromDefault;
         }
       }
-    } // if none of the defaults matched the data type use the last default
-
+    }
+    // if none of the defaults matched the data type use the last default
   }
 
   if (typeof_default()(fieldReference) === 'object') {
     var field = fieldReference.field;
-
     if (field && !Array.isArray(field)) {
       fieldReferenceStr = field;
     }
   }
-
   var indexBasedRegx = /^[A-Za-z0-9_]+\[.*\].*$/;
   var nameBasedRegx = /^[A-Za-z0-9_]+\..*$/;
   var isIndexBasedReference = indexBasedRegx.test(fieldReferenceStr);
   var isNameBasedReference = nameBasedRegx.test(fieldReferenceStr);
-
   if (!isIndexBasedReference && !isNameBasedReference) {
     // Unable to parse the encoding. Please verify the encoding format is correct
     return {};
   }
-
   var dataSourceType = fieldReferenceStr.match(/^(.*?)(\.|\[)/)[1];
   var data = getDataForDataSourceType(dataSources, dataSourceType);
   var fieldData;
-
   if (isIndexBasedReference) {
     fieldData = Base_getDataForIndexBasedFieldReference(data, fieldReferenceStr);
   } else {
     fieldData = Base_getDataForNameBasedFieldReference(data, fieldReferenceStr);
   }
-
   if (typeof_default()(fieldReference) === 'object') {
     var format = fieldReference.format;
-
     if (format) {
       formatValue = getFormatter(fieldData.data, format);
     }
   }
-
   if (formatValue && !isEmpty_default()(fieldData)) {
     return {
       fieldName: fieldData.fieldName,
       data: fieldData.data.map(formatValue)
     };
   }
-
   return fieldData;
 };
-
 var Base_mergeEncoding = function mergeEncoding(defaultEncoding) {
   var userDefinedEncoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-
   var mergedEncoding = _objectSpread({}, userDefinedEncoding);
-
   Object.keys(defaultEncoding).forEach(function (key) {
     if (isEmpty_default()(userDefinedEncoding[key]) && defaultEncoding[key].isRequired && defaultEncoding[key].default) {
       mergedEncoding[key] = typeof_default()(defaultEncoding[key].default) === 'object' && !Array.isArray(defaultEncoding[key].default) ? _objectSpread(_objectSpread({}, defaultEncoding[key].default), {}, {
@@ -941,26 +848,25 @@ var Base_parse = function parse(dataSources) {
     }
   };
   Object.keys(encoding).forEach(function (key) {
-    var fieldReference = clone_default()(encoding[key]); // handle the case for encoding field reference, for example fill: 'encoding.trend'
+    var fieldReference = clone_default()(encoding[key]);
 
+    // handle the case for encoding field reference, for example fill: 'encoding.trend'
     if (typeof_default()(fieldReference) === 'object' && fieldReference.field && fieldReference.field.indexOf('encoding') === 0) {
-      var replacedKey = fieldReference.field.split('.')[1]; // return for the below invalid cases
-      // `encoding.z` if `z` is not a valid field in encoding
+      var replacedKey = fieldReference.field.split('.')[1];
 
+      // return for the below invalid cases
+      // `encoding.z` if `z` is not a valid field in encoding
       if (!encoding[replacedKey]) {
         // eslint-disable-next-line
         console.warn("".concat(key, " field cannot refer to 'encoding.").concat(replacedKey, "'."));
-      } // if `z` is an object configuration in encoding simply extract the field when refering `encoding.z`
-
-
+      }
+      // if `z` is an object configuration in encoding simply extract the field when refering `encoding.z`
       var field = typeof_default()(encoding[replacedKey]) === 'object' ? encoding[replacedKey].field : encoding[replacedKey];
       fieldReference = _objectSpread(_objectSpread({}, fieldReference), {}, {
         field: field
       });
     }
-
     var dataForFieldReference = Base_getDataForFieldReference(dataSources, fieldReference);
-
     if (Array.isArray(dataForFieldReference)) {
       parsedOutput[key] = dataForFieldReference.map(function (entry) {
         return entry.data;
@@ -969,19 +875,16 @@ var Base_parse = function parse(dataSources) {
         return entry.fieldName;
       }); // eslint-disable-line no-underscore-dangle
       // eslint-disable-next-line no-underscore-dangle
-
       parsedOutput._meta.types[key] = dataForFieldReference.map(function (entry) {
         return inferDataTypeFromSample(drawSample(entry.data));
       });
     } else {
       var fieldName = dataForFieldReference.fieldName,
-          data = dataForFieldReference.data;
-
+        data = dataForFieldReference.data;
       if (fieldName) {
         parsedOutput[key] = data;
         parsedOutput._meta.fieldNames[key] = fieldName; // eslint-disable-line no-underscore-dangle
         // eslint-disable-next-line no-underscore-dangle
-
         parsedOutput._meta.types[key] = inferDataTypeFromSample(drawSample(data));
       }
     }