@splunk/visualization-encoding-parsers 26.0.0 → 26.1.0

package/Base.js

@@ -240,46 +240,55 @@ 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
@@ -292,27 +301,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`.
@@ -325,11 +334,12 @@ 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;
@@ -339,7 +349,6 @@ 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
  *
@@ -350,31 +359,38 @@ 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
@@ -388,22 +404,23 @@ 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);
 
-    // don't let value be outside the allowed range
+    var floatVal = parseFloat(value); // 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]))) {
@@ -411,13 +428,14 @@ 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);
+        var tau = (value - lowerVal) / (upperVal - lowerVal); // deal with special case when the upper and lower and bounds of the colorRange is equal
 
-        // 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
@@ -432,8 +450,9 @@ 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();
 };
@@ -449,10 +468,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
@@ -461,44 +480,50 @@ 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;
@@ -511,7 +536,6 @@ 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
@@ -521,20 +545,23 @@ 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
@@ -543,6 +570,7 @@ 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,
@@ -563,7 +591,6 @@ 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
@@ -571,39 +598,55 @@ 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);
-    enumerableOnly && (symbols = symbols.filter(function (sym) {
+    if (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 = 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));
-    });
+    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));
+      });
+    }
   }
+
   return target;
 }
 
@@ -612,6 +655,8 @@ function _objectSpread(target) {
 
 
 
+
+
 var getDataForDataSourceType = function getDataForDataSourceType(data, dataSourceType) {
   if (!dataSourceType || !data[dataSourceType] || !data[dataSourceType].data) {
     // @TODO: warn about datasource type not being found
@@ -620,6 +665,7 @@ var getDataForDataSourceType = function getDataForDataSourceType(data, dataSourc
       columns: []
     };
   }
+
   return data[dataSourceType].data;
 };
 /*
@@ -627,16 +673,20 @@ 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),
@@ -648,6 +698,7 @@ 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];
@@ -658,12 +709,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];
@@ -676,42 +727,54 @@ 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];
@@ -719,31 +782,41 @@ 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];
@@ -751,80 +824,100 @@ 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), {}, {
@@ -848,25 +941,26 @@ var Base_parse = function parse(dataSources) {
     }
   };
   Object.keys(encoding).forEach(function (key) {
-    var fieldReference = clone_default()(encoding[key]);
+    var fieldReference = clone_default()(encoding[key]); // handle the case for encoding field reference, for example fill: 'encoding.trend'
 
-    // 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
+      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;
@@ -875,16 +969,19 @@ 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));
       }
     }