kepler.gl/dist/processors/data-processor.js

kepler.gl is a webgl based application to visualize large scale location data in the browser

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.processCsvData = processCsvData;
exports.parseRowsByFields = parseRowsByFields;
exports.getSampleForTypeAnalyze = getSampleForTypeAnalyze;
exports.parseCsvRowsByFieldType = parseCsvRowsByFieldType;
exports.getFieldsFromData = getFieldsFromData;
exports.renameDuplicateFields = renameDuplicateFields;
exports.analyzerTypeToFieldType = analyzerTypeToFieldType;
exports.processRowObject = processRowObject;
exports.processGeojson = processGeojson;
exports.formatCsv = formatCsv;
exports.validateInputData = validateInputData;
exports.processKeplerglJSON = processKeplerglJSON;
exports.processKeplerglDataset = processKeplerglDataset;
exports.Processors = exports.DATASET_HANDLERS = exports.PARSE_FIELD_VALUE_FROM_STRING = exports.CSV_NULLS = exports.ACCEPTED_ANALYZER_TYPES = void 0;

var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));

var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));

var _d3Dsv = require("d3-dsv");

var _d3Array = require("d3-array");

var _window = require("global/window");

var _assert = _interopRequireDefault(require("assert"));

var _typeAnalyzer = require("type-analyzer");

var _geojsonNormalize = _interopRequireDefault(require("@mapbox/geojson-normalize"));

var _defaultSettings = require("../constants/default-settings");

var _dataUtils = require("../utils/data-utils");

var _schemas = _interopRequireDefault(require("../schemas"));

var _userGuides = require("../constants/user-guides");

var _utils = require("../utils/utils");

var _PARSE_FIELD_VALUE_FR, _DATASET_HANDLERS;

function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }

function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }

function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); 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) { (0, _defineProperty2["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; }

var ACCEPTED_ANALYZER_TYPES = [_typeAnalyzer.DATA_TYPES.DATE, _typeAnalyzer.DATA_TYPES.TIME, _typeAnalyzer.DATA_TYPES.DATETIME, _typeAnalyzer.DATA_TYPES.NUMBER, _typeAnalyzer.DATA_TYPES.INT, _typeAnalyzer.DATA_TYPES.FLOAT, _typeAnalyzer.DATA_TYPES.BOOLEAN, _typeAnalyzer.DATA_TYPES.STRING, _typeAnalyzer.DATA_TYPES.GEOMETRY, _typeAnalyzer.DATA_TYPES.GEOMETRY_FROM_STRING, _typeAnalyzer.DATA_TYPES.PAIR_GEOMETRY_FROM_STRING, _typeAnalyzer.DATA_TYPES.ZIPCODE, _typeAnalyzer.DATA_TYPES.ARRAY, _typeAnalyzer.DATA_TYPES.OBJECT]; // if any of these value occurs in csv, parse it to null;
// const CSV_NULLS = ['', 'null', 'NULL', 'Null', 'NaN', '/N'];
// matches empty string

exports.ACCEPTED_ANALYZER_TYPES = ACCEPTED_ANALYZER_TYPES;
var CSV_NULLS = /^(null|NULL|Null|NaN|\/N||)$/;
exports.CSV_NULLS = CSV_NULLS;
var IGNORE_DATA_TYPES = Object.keys(_typeAnalyzer.DATA_TYPES).filter(function (type) {
  return !ACCEPTED_ANALYZER_TYPES.includes(type);
});
var PARSE_FIELD_VALUE_FROM_STRING = (_PARSE_FIELD_VALUE_FR = {}, (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _defaultSettings.ALL_FIELD_TYPES["boolean"], {
  valid: function valid(d) {
    return typeof d === 'boolean';
  },
  parse: function parse(d) {
    return d === 'true' || d === 'True' || d === 'TRUE' || d === '1';
  }
}), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _defaultSettings.ALL_FIELD_TYPES.integer, {
  valid: function valid(d) {
    return parseInt(d, 10) === d;
  },
  parse: function parse(d) {
    return parseInt(d, 10);
  }
}), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _defaultSettings.ALL_FIELD_TYPES.timestamp, {
  valid: function valid(d, field) {
    return ['x', 'X'].includes(field.format) ? typeof d === 'number' : typeof d === 'string';
  },
  parse: function parse(d, field) {
    return ['x', 'X'].includes(field.format) ? Number(d) : d;
  }
}), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _defaultSettings.ALL_FIELD_TYPES.real, {
  valid: function valid(d) {
    return parseFloat(d) === d;
  },
  // Note this will result in NaN for some string
  parse: parseFloat
}), _PARSE_FIELD_VALUE_FR);
/**
 * Process csv data, output a data object with `{fields: [], rows: []}`.
 * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)
 * @param rawData raw csv string
 * @returns  data object `{fields: [], rows: []}` can be passed to addDataToMaps
 * @type {typeof import('./data-processor').processCsvData}
 * @public
 * @example
 * import {processCsvData} from 'kepler.gl/processors';
 *
 * const testData = `gps_data.utc_timestamp,gps_data.lat,gps_data.lng,gps_data.types,epoch,has_result,id,time,begintrip_ts_utc,begintrip_ts_local,date
 * 2016-09-17 00:09:55,29.9900937,31.2590542,driver_analytics,1472688000000,False,1,2016-09-23T00:00:00.000Z,2016-10-01 09:41:39+00:00,2016-10-01 09:41:39+00:00,2016-09-23
 * 2016-09-17 00:10:56,29.9927699,31.2461142,driver_analytics,1472688000000,False,2,2016-09-23T00:00:00.000Z,2016-10-01 09:46:37+00:00,2016-10-01 16:46:37+00:00,2016-09-23
 * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23
 * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`
 *
 * const dataset = {
 *  info: {id: 'test_data', label: 'My Csv'},
 *  data: processCsvData(testData)
 * };
 *
 * dispatch(addDataToMap({
 *  datasets: [dataset],
 *  options: {centerMap: true, readOnly: true}
 * }));
 */

exports.PARSE_FIELD_VALUE_FROM_STRING = PARSE_FIELD_VALUE_FROM_STRING;

function processCsvData(rawData, header) {
  var rows;
  var headerRow;

  if (typeof rawData === 'string') {
    var _parsedRows = (0, _d3Dsv.csvParseRows)(rawData);

    if (!Array.isArray(_parsedRows) || _parsedRows.length < 2) {
      // looks like an empty file, throw error to be catch
      throw new Error('process Csv Data Failed: CSV is empty');
    }

    headerRow = _parsedRows[0];
    rows = _parsedRows.slice(1);
  } else if (Array.isArray(rawData) && rawData.length) {
    rows = rawData;
    headerRow = header;

    if (!Array.isArray(headerRow)) {
      // if data is passed in as array of rows and missing header
      // assume first row is header
      headerRow = rawData[0];
      rows = rawData.slice(1);
    }
  }

  if (!rows || !headerRow) {
    throw new Error('invalid input passed to processCsvData');
  } // here we assume the csv file that people uploaded will have first row
  // as name of the column


  cleanUpFalsyCsvValue(rows); // No need to run type detection on every data point
  // here we get a list of none null values to run analyze on

  var sample = getSampleForTypeAnalyze({
    fields: headerRow,
    rows: rows
  });
  var fields = getFieldsFromData(sample, headerRow);
  var parsedRows = parseRowsByFields(rows, fields);
  return {
    fields: fields,
    rows: parsedRows
  };
}
/**
 * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`
 * @param {Array<Array>} rows
 * @param {Array<Object>} fields
 */


function parseRowsByFields(rows, fields) {
  // Edit rows in place
  var geojsonFieldIdx = fields.findIndex(function (f) {
    return f.name === '_geojson';
  });
  fields.forEach(parseCsvRowsByFieldType.bind(null, rows, geojsonFieldIdx));
  return rows;
}
/**
 * Getting sample data for analyzing field type.
 *
 * @type {typeof import('./data-processor').getSampleForTypeAnalyze}
 */


function getSampleForTypeAnalyze(_ref) {
  var fields = _ref.fields,
      rows = _ref.rows,
      _ref$sampleCount = _ref.sampleCount,
      sampleCount = _ref$sampleCount === void 0 ? 50 : _ref$sampleCount;
  var total = Math.min(sampleCount, rows.length); // const fieldOrder = fields.map(f => f.name);

  var sample = (0, _d3Array.range)(0, total, 1).map(function (d) {
    return {};
  }); // collect sample data for each field

  fields.forEach(function (field, fieldIdx) {
    // data counter
    var i = 0; // sample counter

    var j = 0;

    while (j < total) {
      if (i >= rows.length) {
        // if depleted data pool
        sample[j][field] = null;
        j++;
      } else if ((0, _dataUtils.notNullorUndefined)(rows[i][fieldIdx])) {
        var value = rows[i][fieldIdx];
        sample[j][field] = typeof value === 'string' ? value.trim() : value;
        j++;
        i++;
      } else {
        i++;
      }
    }
  });
  return sample;
}
/**
 * Convert falsy value in csv including `'', 'null', 'NULL', 'Null', 'NaN'` to `null`,
 * so that type-analyzer won't detect it as string
 *
 * @param {Array<Array>} rows
 */


function cleanUpFalsyCsvValue(rows) {
  var re = new RegExp(CSV_NULLS, 'g');

  for (var i = 0; i < rows.length; i++) {
    for (var j = 0; j < rows[i].length; j++) {
      // analyzer will set any fields to 'string' if there are empty values
      // which will be parsed as '' by d3.csv
      // here we parse empty data as null
      // TODO: create warning when deltect `CSV_NULLS` in the data
      if (typeof rows[i][j] === 'string' && rows[i][j].match(re)) {
        rows[i][j] = null;
      }
    }
  }
}
/**
 * Process uploaded csv file to parse value by field type
 *
 * @param rows
 * @param geoFieldIdx field index
 * @param field
 * @param i
 * @type {typeof import('./data-processor').parseCsvRowsByFieldType}
 */


function parseCsvRowsByFieldType(rows, geoFieldIdx, field, i) {
  var parser = PARSE_FIELD_VALUE_FROM_STRING[field.type];

  if (parser) {
    // check first not null value of it's already parsed
    var first = rows.find(function (r) {
      return (0, _dataUtils.notNullorUndefined)(r[i]);
    });

    if (!first || parser.valid(first[i], field)) {
      return;
    }

    rows.forEach(function (row) {
      // parse string value based on field type
      if (row[i] !== null) {
        row[i] = parser.parse(row[i], field);

        if (geoFieldIdx > -1 && row[geoFieldIdx] && row[geoFieldIdx].properties) {
          row[geoFieldIdx].properties[field.name] = row[i];
        }
      }
    });
  }
}
/**
 * Analyze field types from data in `string` format, e.g. uploaded csv.
 * Assign `type`, `fieldIdx` and `format` (timestamp only) to each field
 *
 * @param data array of row object
 * @param fieldOrder array of field names as string
 * @returns formatted fields
 * @type {typeof import('./data-processor').getFieldsFromData}
 * @public
 * @example
 *
 * import {getFieldsFromData} from 'kepler.gl/processors';
 * const data = [{
 *   time: '2016-09-17 00:09:55',
 *   value: '4',
 *   surge: '1.2',
 *   isTrip: 'true',
 *   zeroOnes: '0'
 * }, {
 *   time: '2016-09-17 00:30:08',
 *   value: '3',
 *   surge: null,
 *   isTrip: 'false',
 *   zeroOnes: '1'
 * }, {
 *   time: null,
 *   value: '2',
 *   surge: '1.3',
 *   isTrip: null,
 *   zeroOnes: '1'
 * }];
 *
 * const fieldOrder = ['time', 'value', 'surge', 'isTrip', 'zeroOnes'];
 * const fields = getFieldsFromData(data, fieldOrder);
 * // fields = [
 * // {name: 'time', format: 'YYYY-M-D H:m:s', fieldIdx: 1, type: 'timestamp'},
 * // {name: 'value', format: '', fieldIdx: 4, type: 'integer'},
 * // {name: 'surge', format: '', fieldIdx: 5, type: 'real'},
 * // {name: 'isTrip', format: '', fieldIdx: 6, type: 'boolean'},
 * // {name: 'zeroOnes', format: '', fieldIdx: 7, type: 'integer'}];
 *
 */


function getFieldsFromData(data, fieldOrder) {
  // add a check for epoch timestamp
  var metadata = _typeAnalyzer.Analyzer.computeColMeta(data, [{
    regex: /.*geojson|all_points/g,
    dataType: 'GEOMETRY'
  }, {
    regex: /.*census/g,
    dataType: 'STRING'
  }], {
    ignoredDataTypes: IGNORE_DATA_TYPES
  });

  var _renameDuplicateField = renameDuplicateFields(fieldOrder),
      fieldByIndex = _renameDuplicateField.fieldByIndex;

  var result = fieldOrder.map(function (field, index) {
    var name = fieldByIndex[index];
    var fieldMeta = metadata.find(function (m) {
      return m.key === field;
    });

    var _ref2 = fieldMeta || {},
        type = _ref2.type,
        format = _ref2.format;

    return {
      name: name,
      id: name,
      displayName: name,
      format: format,
      fieldIdx: index,
      type: analyzerTypeToFieldType(type),
      analyzerType: type,
      valueAccessor: function valueAccessor(dc) {
        return function (d) {
          return dc.valueAt(d.index, index);
        };
      }
    };
  }); // @ts-ignore

  return result;
}
/**
 * pass in an array of field names, rename duplicated one
 * and return a map from old field index to new name
 *
 * @param {Array} fieldOrder
 * @returns {Object} new field name by index
 */


function renameDuplicateFields(fieldOrder) {
  return fieldOrder.reduce(function (accu, field, i) {
    var allNames = accu.allNames;
    var fieldName = field; // add a counter to duplicated names

    if (allNames.includes(field)) {
      var counter = 0;

      while (allNames.includes("".concat(field, "-").concat(counter))) {
        counter++;
      }

      fieldName = "".concat(field, "-").concat(counter);
    }

    accu.fieldByIndex[i] = fieldName;
    accu.allNames.push(fieldName);
    return accu;
  }, {
    allNames: [],
    fieldByIndex: {}
  });
}
/**
 * Convert type-analyzer output to kepler.gl field types
 *
 * @param aType
 * @returns corresponding type in `ALL_FIELD_TYPES`
 * @type {typeof import('./data-processor').analyzerTypeToFieldType}}
 */

/* eslint-disable complexity */


function analyzerTypeToFieldType(aType) {
  var DATE = _typeAnalyzer.DATA_TYPES.DATE,
      TIME = _typeAnalyzer.DATA_TYPES.TIME,
      DATETIME = _typeAnalyzer.DATA_TYPES.DATETIME,
      NUMBER = _typeAnalyzer.DATA_TYPES.NUMBER,
      INT = _typeAnalyzer.DATA_TYPES.INT,
      FLOAT = _typeAnalyzer.DATA_TYPES.FLOAT,
      BOOLEAN = _typeAnalyzer.DATA_TYPES.BOOLEAN,
      STRING = _typeAnalyzer.DATA_TYPES.STRING,
      GEOMETRY = _typeAnalyzer.DATA_TYPES.GEOMETRY,
      GEOMETRY_FROM_STRING = _typeAnalyzer.DATA_TYPES.GEOMETRY_FROM_STRING,
      PAIR_GEOMETRY_FROM_STRING = _typeAnalyzer.DATA_TYPES.PAIR_GEOMETRY_FROM_STRING,
      ZIPCODE = _typeAnalyzer.DATA_TYPES.ZIPCODE,
      ARRAY = _typeAnalyzer.DATA_TYPES.ARRAY,
      OBJECT = _typeAnalyzer.DATA_TYPES.OBJECT; // TODO: un recognized types
  // CURRENCY PERCENT NONE

  switch (aType) {
    case DATE:
      return _defaultSettings.ALL_FIELD_TYPES.date;

    case TIME:
    case DATETIME:
      return _defaultSettings.ALL_FIELD_TYPES.timestamp;

    case FLOAT:
      return _defaultSettings.ALL_FIELD_TYPES.real;

    case INT:
      return _defaultSettings.ALL_FIELD_TYPES.integer;

    case BOOLEAN:
      return _defaultSettings.ALL_FIELD_TYPES["boolean"];

    case GEOMETRY:
    case GEOMETRY_FROM_STRING:
    case PAIR_GEOMETRY_FROM_STRING:
    case ARRAY:
    case OBJECT:
      // TODO: create a new data type for objects and arrays
      return _defaultSettings.ALL_FIELD_TYPES.geojson;

    case NUMBER:
    case STRING:
    case ZIPCODE:
      return _defaultSettings.ALL_FIELD_TYPES.string;

    default:
      _window.console.warn("Unsupported analyzer type: ".concat(aType));

      return _defaultSettings.ALL_FIELD_TYPES.string;
  }
}
/* eslint-enable complexity */

/**
 * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
 * NOTE: This function may mutate input.
 * @param rawData an array of row object, each object should have the same number of keys
 * @returns dataset containing `fields` and `rows`
 * @type {typeof import('./data-processor').processRowObject}
 * @public
 * @example
 * import {addDataToMap} from 'kepler.gl/actions';
 * import {processRowObject} from 'kepler.gl/processors';
 *
 * const data = [
 *  {lat: 31.27, lng: 127.56, value: 3},
 *  {lat: 31.22, lng: 126.26, value: 1}
 * ];
 *
 * dispatch(addDataToMap({
 *  datasets: {
 *    info: {label: 'My Data', id: 'my_data'},
 *    data: processRowObject(data)
 *  }
 * }));
 */


function processRowObject(rawData) {
  if (!Array.isArray(rawData) || !rawData.length) {
    return null;
  }

  var keys = Object.keys(rawData[0]);
  var rows = rawData.map(function (d) {
    return keys.map(function (key) {
      return d[key];
    });
  }); // row object an still contain values like `Null` or `N/A`

  cleanUpFalsyCsvValue(rows);
  return processCsvData(rows, keys);
}
/**
 * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),
 * output a data object with `{fields: [], rows: []}`.
 * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
 * NOTE: This function may mutate input.
 *
 * @param  rawData raw geojson feature collection
 * @returns  dataset containing `fields` and `rows`
 * @type {typeof import('./data-processor').processGeojson}
 * @public
 * @example
 * import {addDataToMap} from 'kepler.gl/actions';
 * import {processGeojson} from 'kepler.gl/processors';
 *
 * const geojson = {
 * 	"type" : "FeatureCollection",
 * 	"features" : [{
 * 		"type" : "Feature",
 * 		"properties" : {
 * 			"capacity" : "10",
 * 			"type" : "U-Rack"
 * 		},
 * 		"geometry" : {
 * 			"type" : "Point",
 * 			"coordinates" : [ -71.073283, 42.417500 ]
 * 		}
 * 	}]
 * };
 *
 * dispatch(addDataToMap({
 *  datasets: {
 *    info: {
 *      label: 'Sample Taxi Trips in New York City',
 *      id: 'test_trip_data'
 *    },
 *    data: processGeojson(geojson)
 *  }
 * }));
 */


function processGeojson(rawData) {
  var normalizedGeojson = (0, _geojsonNormalize["default"])(rawData);

  if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {
    var error = new Error("Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](".concat(_userGuides.GUIDES_FILE_FORMAT_DOC, ")"));
    throw error; // fail to normalize geojson
  } // getting all feature fields


  var allDataRows = [];

  for (var i = 0; i < normalizedGeojson.features.length; i++) {
    var f = normalizedGeojson.features[i];

    if (f.geometry) {
      allDataRows.push(_objectSpread({
        // add feature to _geojson field
        _geojson: f
      }, f.properties || {}));
    }
  } // get all the field


  var fields = allDataRows.reduce(function (prev, curr) {
    Object.keys(curr).forEach(function (key) {
      if (!prev.includes(key)) {
        prev.push(key);
      }
    });
    return prev;
  }, []); // make sure each feature has exact same fields

  allDataRows.forEach(function (d) {
    fields.forEach(function (f) {
      if (!(f in d)) {
        d[f] = null;
        d._geojson.properties[f] = null;
      }
    });
  });
  return processRowObject(allDataRows);
}
/**
 * On export data to csv
 * @param {import('utils/table-utils/data-container-interface').DataContainerInterface} dataContainer
 * @param {Array<Object>} fields `dataset.fields`
 * @returns {string} csv string
 */


function formatCsv(dataContainer, fields) {
  var columns = fields.map(function (f) {
    return f.displayName || f.name;
  });
  var formattedData = [columns]; // parse geojson object as string

  var _iterator = _createForOfIteratorHelper(dataContainer.rows(true)),
      _step;

  try {
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
      var row = _step.value;
      formattedData.push(row.map(function (d, i) {
        return (0, _dataUtils.parseFieldValue)(d, fields[i].type);
      }));
    }
  } catch (err) {
    _iterator.e(err);
  } finally {
    _iterator.f();
  }

  return (0, _d3Dsv.csvFormatRows)(formattedData);
}
/**
 * Validate input data, adding missing field types, rename duplicate columns
 * @type {typeof import('./data-processor').validateInputData}
 */


function validateInputData(data) {
  if (!(0, _utils.isPlainObject)(data)) {
    (0, _assert["default"])('addDataToMap Error: dataset.data cannot be null');
    return null;
  } else if (!Array.isArray(data.fields)) {
    (0, _assert["default"])('addDataToMap Error: expect dataset.data.fields to be an array');
    return null;
  } else if (!Array.isArray(data.rows)) {
    (0, _assert["default"])('addDataToMap Error: expect dataset.data.rows to be an array');
    return null;
  }

  var fields = data.fields,
      rows = data.rows; // check if all fields has name, format and type

  var allValid = fields.every(function (f, i) {
    if (!(0, _utils.isPlainObject)(f)) {
      (0, _assert["default"])("fields needs to be an array of object, but find ".concat((0, _typeof2["default"])(f)));
      fields[i] = {};
    }

    if (!f.name) {
      (0, _assert["default"])("field.name is required but missing in ".concat(JSON.stringify(f))); // assign a name

      fields[i].name = "column_".concat(i);
    }

    if (!_defaultSettings.ALL_FIELD_TYPES[f.type]) {
      (0, _assert["default"])("unknown field type ".concat(f.type));
      return false;
    }

    if (!fields.every(function (field) {
      return field.analyzerType;
    })) {
      (0, _assert["default"])('field missing analyzerType');
      return false;
    } // check time format is correct based on first 10 not empty element


    if (f.type === _defaultSettings.ALL_FIELD_TYPES.timestamp) {
      var sample = findNonEmptyRowsAtField(rows, i, 10).map(function (r) {
        return {
          ts: r[i]
        };
      });

      var analyzedType = _typeAnalyzer.Analyzer.computeColMeta(sample)[0];

      return analyzedType && analyzedType.category === 'TIME' && analyzedType.format === f.format;
    }

    return true;
  });

  if (allValid) {
    return {
      rows: rows,
      fields: fields
    };
  } // if any field has missing type, recalculate it for everyone
  // because we simply lost faith in humanity


  var sampleData = getSampleForTypeAnalyze({
    fields: fields.map(function (f) {
      return f.name;
    }),
    rows: rows
  });
  var fieldOrder = fields.map(function (f) {
    return f.name;
  });
  var meta = getFieldsFromData(sampleData, fieldOrder);
  var updatedFields = fields.map(function (f, i) {
    return _objectSpread(_objectSpread({}, f), {}, {
      type: meta[i].type,
      format: meta[i].format,
      analyzerType: meta[i].analyzerType
    });
  });
  return {
    fields: updatedFields,
    rows: rows
  };
}

function findNonEmptyRowsAtField(rows, fieldIdx, total) {
  var sample = [];
  var i = 0;

  while (sample.length < total && i < rows.length) {
    if ((0, _dataUtils.notNullorUndefined)(rows[i][fieldIdx])) {
      sample.push(rows[i]);
    }

    i++;
  }

  return sample;
}
/**
 * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).
 * The json object should contain `datasets` and `config`.
 * @param {Object} rawData
 * @param {Array} rawData.datasets
 * @param {Object} rawData.config
 * @returns {Object} datasets and config `{datasets: {}, config: {}}`
 * @public
 * @example
 * import {addDataToMap} from 'kepler.gl/actions';
 * import {processKeplerglJSON} from 'kepler.gl/processors';
 *
 * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));
 */


function processKeplerglJSON(rawData) {
  return rawData ? _schemas["default"].load(rawData.datasets, rawData.config) : null;
}
/**
 * Parse a single or an array of datasets saved using kepler.gl schema
 * @param {Array | Array<Object>} rawData
 */


function processKeplerglDataset(rawData) {
  if (!rawData) {
    return null;
  }

  var results = _schemas["default"].parseSavedData((0, _utils.toArray)(rawData));

  if (!results) {
    return null;
  }

  return Array.isArray(rawData) ? results : results[0];
}

var DATASET_HANDLERS = (_DATASET_HANDLERS = {}, (0, _defineProperty2["default"])(_DATASET_HANDLERS, _defaultSettings.DATASET_FORMATS.row, processRowObject), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _defaultSettings.DATASET_FORMATS.geojson, processGeojson), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _defaultSettings.DATASET_FORMATS.csv, processCsvData), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _defaultSettings.DATASET_FORMATS.keplergl, processKeplerglDataset), _DATASET_HANDLERS);
exports.DATASET_HANDLERS = DATASET_HANDLERS;
var Processors = {
  processGeojson: processGeojson,
  processCsvData: processCsvData,
  processRowObject: processRowObject,
  processKeplerglJSON: processKeplerglJSON,
  processKeplerglDataset: processKeplerglDataset,
  analyzerTypeToFieldType: analyzerTypeToFieldType,
  getFieldsFromData: getFieldsFromData,
  parseCsvRowsByFieldType: parseCsvRowsByFieldType,
  formatCsv: formatCsv
};
exports.Processors = Processors;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/processors/data-processor.js"],"names":["ACCEPTED_ANALYZER_TYPES","AnalyzerDATA_TYPES","DATE","TIME","DATETIME","NUMBER","INT","FLOAT","BOOLEAN","STRING","GEOMETRY","GEOMETRY_FROM_STRING","PAIR_GEOMETRY_FROM_STRING","ZIPCODE","ARRAY","OBJECT","CSV_NULLS","IGNORE_DATA_TYPES","Object","keys","filter","type","includes","PARSE_FIELD_VALUE_FROM_STRING","ALL_FIELD_TYPES","valid","d","parse","integer","parseInt","timestamp","field","format","Number","real","parseFloat","processCsvData","rawData","header","rows","headerRow","parsedRows","Array","isArray","length","Error","slice","cleanUpFalsyCsvValue","sample","getSampleForTypeAnalyze","fields","getFieldsFromData","parseRowsByFields","geojsonFieldIdx","findIndex","f","name","forEach","parseCsvRowsByFieldType","bind","sampleCount","total","Math","min","map","fieldIdx","i","j","value","trim","re","RegExp","match","geoFieldIdx","parser","first","find","r","row","properties","data","fieldOrder","metadata","Analyzer","computeColMeta","regex","dataType","ignoredDataTypes","renameDuplicateFields","fieldByIndex","result","index","fieldMeta","m","key","id","displayName","analyzerTypeToFieldType","analyzerType","valueAccessor","dc","valueAt","reduce","accu","allNames","fieldName","counter","push","aType","date","geojson","string","globalConsole","warn","processRowObject","processGeojson","normalizedGeojson","features","error","GUIDES_FILE_FORMAT_DOC","allDataRows","geometry","_geojson","prev","curr","formatCsv","dataContainer","columns","formattedData","validateInputData","allValid","every","JSON","stringify","findNonEmptyRowsAtField","ts","analyzedType","category","sampleData","meta","updatedFields","processKeplerglJSON","KeplerGlSchema","load","datasets","config","processKeplerglDataset","results","parseSavedData","DATASET_HANDLERS","DATASET_FORMATS","csv","keplergl","Processors"],"mappings":"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