@kepler.gl/processors 3.1.0-alpha.0 → 3.1.0-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,457 @@
1
+ "use strict";
2
+
3
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
4
+ var _typeof = require("@babel/runtime/helpers/typeof");
5
+ Object.defineProperty(exports, "__esModule", {
6
+ value: true
7
+ });
8
+ exports.Processors = exports.PARSE_FIELD_VALUE_FROM_STRING = exports.DATASET_HANDLERS = exports.CSV_NULLS = void 0;
9
+ exports.arrowSchemaToFields = arrowSchemaToFields;
10
+ exports.parseCsvRowsByFieldType = parseCsvRowsByFieldType;
11
+ exports.parseRowsByFields = parseRowsByFields;
12
+ exports.processArrowBatches = processArrowBatches;
13
+ exports.processArrowTable = processArrowTable;
14
+ exports.processCsvData = processCsvData;
15
+ exports.processGeojson = processGeojson;
16
+ exports.processKeplerglDataset = processKeplerglDataset;
17
+ exports.processKeplerglJSON = processKeplerglJSON;
18
+ exports.processRowObject = processRowObject;
19
+ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
20
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
21
+ var arrow = _interopRequireWildcard(require("apache-arrow"));
22
+ var _d3Dsv = require("d3-dsv");
23
+ var _typeAnalyzer = require("type-analyzer");
24
+ var _geojsonNormalize = _interopRequireDefault(require("@mapbox/geojson-normalize"));
25
+ var _constants = require("@kepler.gl/constants");
26
+ var _utils = require("@kepler.gl/utils");
27
+ var _commonUtils = require("@kepler.gl/common-utils");
28
+ var _schemas = require("@kepler.gl/schemas");
29
+ function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
30
+ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
31
+ function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
32
+ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
33
+ // Copyright contributors to the kepler.gl project
34
+ // if any of these value occurs in csv, parse it to null;
35
+ // const CSV_NULLS = ['', 'null', 'NULL', 'Null', 'NaN', '/N'];
36
+ // matches empty string
37
+ var CSV_NULLS = exports.CSV_NULLS = /^(null|NULL|Null|NaN|\/N||)$/;
38
+ function tryParseJsonString(str) {
39
+ try {
40
+ return JSON.parse(str);
41
+ } catch (e) {
42
+ return null;
43
+ }
44
+ }
45
+ var PARSE_FIELD_VALUE_FROM_STRING = exports.PARSE_FIELD_VALUE_FROM_STRING = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.ALL_FIELD_TYPES["boolean"], {
46
+ valid: function valid(d) {
47
+ return typeof d === 'boolean';
48
+ },
49
+ parse: function parse(d) {
50
+ return d === 'true' || d === 'True' || d === 'TRUE' || d === '1';
51
+ }
52
+ }), _constants.ALL_FIELD_TYPES.integer, {
53
+ // @ts-ignore
54
+ valid: function valid(d) {
55
+ return parseInt(d, 10) === d;
56
+ },
57
+ // @ts-ignore
58
+ parse: function parse(d) {
59
+ return parseInt(d, 10);
60
+ }
61
+ }), _constants.ALL_FIELD_TYPES.timestamp, {
62
+ valid: function valid(d, field) {
63
+ return ['x', 'X'].includes(field.format) ? typeof d === 'number' : typeof d === 'string';
64
+ },
65
+ parse: function parse(d, field) {
66
+ return ['x', 'X'].includes(field.format) ? Number(d) : d;
67
+ }
68
+ }), _constants.ALL_FIELD_TYPES.real, {
69
+ // @ts-ignore
70
+ valid: function valid(d) {
71
+ return parseFloat(d) === d;
72
+ },
73
+ // Note this will result in NaN for some string
74
+ parse: parseFloat
75
+ }), _constants.ALL_FIELD_TYPES.object, {
76
+ valid: _utils.isPlainObject,
77
+ parse: tryParseJsonString
78
+ }), _constants.ALL_FIELD_TYPES.array, {
79
+ valid: Array.isArray,
80
+ parse: tryParseJsonString
81
+ }), _constants.ALL_FIELD_TYPES.h3, {
82
+ valid: function valid(d) {
83
+ return (0, _commonUtils.h3IsValid)(d);
84
+ },
85
+ parse: function parse(d) {
86
+ return d;
87
+ }
88
+ });
89
+
90
+ /**
91
+ * Process csv data, output a data object with `{fields: [], rows: []}`.
92
+ * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)
93
+ * @param rawData raw csv string
94
+ * @returns data object `{fields: [], rows: []}` can be passed to addDataToMaps
95
+ * @public
96
+ * @example
97
+ * import {processCsvData} from 'kepler.gl/processors';
98
+ *
99
+ * 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
100
+ * 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
101
+ * 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
102
+ * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23
103
+ * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`
104
+ *
105
+ * const dataset = {
106
+ * info: {id: 'test_data', label: 'My Csv'},
107
+ * data: processCsvData(testData)
108
+ * };
109
+ *
110
+ * dispatch(addDataToMap({
111
+ * datasets: [dataset],
112
+ * options: {centerMap: true, readOnly: true}
113
+ * }));
114
+ */
115
+ function processCsvData(rawData, header) {
116
+ var rows;
117
+ var headerRow;
118
+ if (typeof rawData === 'string') {
119
+ var _parsedRows = (0, _d3Dsv.csvParseRows)(rawData);
120
+ if (!Array.isArray(_parsedRows) || _parsedRows.length < 2) {
121
+ // looks like an empty file, throw error to be catch
122
+ throw new Error('process Csv Data Failed: CSV is empty');
123
+ }
124
+ headerRow = _parsedRows[0];
125
+ rows = _parsedRows.slice(1);
126
+ } else if (Array.isArray(rawData) && rawData.length) {
127
+ rows = rawData;
128
+ headerRow = header;
129
+ if (!Array.isArray(headerRow)) {
130
+ // if data is passed in as array of rows and missing header
131
+ // assume first row is header
132
+ // @ts-ignore
133
+ headerRow = rawData[0];
134
+ rows = rawData.slice(1);
135
+ }
136
+ }
137
+ if (!rows || !headerRow) {
138
+ throw new Error('invalid input passed to processCsvData');
139
+ }
140
+
141
+ // here we assume the csv file that people uploaded will have first row
142
+ // as name of the column
143
+
144
+ cleanUpFalsyCsvValue(rows);
145
+ // No need to run type detection on every data point
146
+ // here we get a list of none null values to run analyze on
147
+ var sample = (0, _commonUtils.getSampleForTypeAnalyze)({
148
+ fields: headerRow,
149
+ rows: rows
150
+ });
151
+ var fields = (0, _commonUtils.getFieldsFromData)(sample, headerRow);
152
+ var parsedRows = parseRowsByFields(rows, fields);
153
+ return {
154
+ fields: fields,
155
+ rows: parsedRows
156
+ };
157
+ }
158
+
159
+ /**
160
+ * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`
161
+ * @param rows
162
+ * @param fields
163
+ */
164
+ function parseRowsByFields(rows, fields) {
165
+ // Edit rows in place
166
+ var geojsonFieldIdx = fields.findIndex(function (f) {
167
+ return f.name === '_geojson';
168
+ });
169
+ fields.forEach(parseCsvRowsByFieldType.bind(null, rows, geojsonFieldIdx));
170
+ return rows;
171
+ }
172
+
173
+ /**
174
+ * Convert falsy value in csv including `'', 'null', 'NULL', 'Null', 'NaN'` to `null`,
175
+ * so that type-analyzer won't detect it as string
176
+ *
177
+ * @param rows
178
+ */
179
+ function cleanUpFalsyCsvValue(rows) {
180
+ var re = new RegExp(CSV_NULLS, 'g');
181
+ for (var i = 0; i < rows.length; i++) {
182
+ for (var j = 0; j < rows[i].length; j++) {
183
+ // analyzer will set any fields to 'string' if there are empty values
184
+ // which will be parsed as '' by d3.csv
185
+ // here we parse empty data as null
186
+ // TODO: create warning when deltect `CSV_NULLS` in the data
187
+ if (typeof rows[i][j] === 'string' && rows[i][j].match(re)) {
188
+ rows[i][j] = null;
189
+ }
190
+ }
191
+ }
192
+ }
193
+
194
+ /**
195
+ * Process uploaded csv file to parse value by field type
196
+ *
197
+ * @param rows
198
+ * @param geoFieldIdx field index
199
+ * @param field
200
+ * @param i
201
+ */
202
+ function parseCsvRowsByFieldType(rows, geoFieldIdx, field, i) {
203
+ var parser = PARSE_FIELD_VALUE_FROM_STRING[field.type];
204
+ if (parser) {
205
+ // check first not null value of it's already parsed
206
+ var first = rows.find(function (r) {
207
+ return (0, _commonUtils.notNullorUndefined)(r[i]);
208
+ });
209
+ if (!first || parser.valid(first[i], field)) {
210
+ return;
211
+ }
212
+ rows.forEach(function (row) {
213
+ // parse string value based on field type
214
+ if (row[i] !== null) {
215
+ row[i] = parser.parse(row[i], field);
216
+ if (geoFieldIdx > -1 && (0, _utils.isPlainObject)(row[geoFieldIdx]) &&
217
+ // @ts-ignore
218
+ (0, _utils.hasOwnProperty)(row[geoFieldIdx], 'properties')) {
219
+ // @ts-ignore
220
+ row[geoFieldIdx].properties[field.name] = row[i];
221
+ }
222
+ }
223
+ });
224
+ }
225
+ }
226
+
227
+ /* eslint-enable complexity */
228
+
229
+ /**
230
+ * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
231
+ * NOTE: This function may mutate input.
232
+ * @param rawData an array of row object, each object should have the same number of keys
233
+ * @returns dataset containing `fields` and `rows`
234
+ * @public
235
+ * @example
236
+ * import {addDataToMap} from 'kepler.gl/actions';
237
+ * import {processRowObject} from 'kepler.gl/processors';
238
+ *
239
+ * const data = [
240
+ * {lat: 31.27, lng: 127.56, value: 3},
241
+ * {lat: 31.22, lng: 126.26, value: 1}
242
+ * ];
243
+ *
244
+ * dispatch(addDataToMap({
245
+ * datasets: {
246
+ * info: {label: 'My Data', id: 'my_data'},
247
+ * data: processRowObject(data)
248
+ * }
249
+ * }));
250
+ */
251
+ function processRowObject(rawData) {
252
+ if (!Array.isArray(rawData)) {
253
+ return null;
254
+ } else if (!rawData.length) {
255
+ // data is empty
256
+ return {
257
+ fields: [],
258
+ rows: []
259
+ };
260
+ }
261
+ var keys = Object.keys(rawData[0]); // [lat, lng, value]
262
+ var rows = rawData.map(function (d) {
263
+ return keys.map(function (key) {
264
+ return d[key];
265
+ });
266
+ }); // [[31.27, 127.56, 3]]
267
+
268
+ // row object can still contain values like `Null` or `N/A`
269
+ cleanUpFalsyCsvValue(rows);
270
+ return processCsvData(rows, keys);
271
+ }
272
+
273
+ /**
274
+ * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),
275
+ * output a data object with `{fields: [], rows: []}`.
276
+ * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
277
+ * NOTE: This function may mutate input.
278
+ *
279
+ * @param rawData raw geojson feature collection
280
+ * @returns dataset containing `fields` and `rows`
281
+ * @public
282
+ * @example
283
+ * import {addDataToMap} from 'kepler.gl/actions';
284
+ * import {processGeojson} from 'kepler.gl/processors';
285
+ *
286
+ * const geojson = {
287
+ * "type" : "FeatureCollection",
288
+ * "features" : [{
289
+ * "type" : "Feature",
290
+ * "properties" : {
291
+ * "capacity" : "10",
292
+ * "type" : "U-Rack"
293
+ * },
294
+ * "geometry" : {
295
+ * "type" : "Point",
296
+ * "coordinates" : [ -71.073283, 42.417500 ]
297
+ * }
298
+ * }]
299
+ * };
300
+ *
301
+ * dispatch(addDataToMap({
302
+ * datasets: {
303
+ * info: {
304
+ * label: 'Sample Taxi Trips in New York City',
305
+ * id: 'test_trip_data'
306
+ * },
307
+ * data: processGeojson(geojson)
308
+ * }
309
+ * }));
310
+ */
311
+ function processGeojson(rawData) {
312
+ var normalizedGeojson = (0, _geojsonNormalize["default"])(rawData);
313
+ if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {
314
+ var error = new Error("Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](".concat(_constants.GUIDES_FILE_FORMAT_DOC, ")"));
315
+ throw error;
316
+ // fail to normalize geojson
317
+ }
318
+
319
+ // getting all feature fields
320
+ var allDataRows = [];
321
+ for (var i = 0; i < normalizedGeojson.features.length; i++) {
322
+ var f = normalizedGeojson.features[i];
323
+ if (f.geometry) {
324
+ allDataRows.push(_objectSpread({
325
+ // add feature to _geojson field
326
+ _geojson: f
327
+ }, f.properties || {}));
328
+ }
329
+ }
330
+ // get all the field
331
+ var fields = allDataRows.reduce(function (accu, curr) {
332
+ Object.keys(curr).forEach(function (key) {
333
+ if (!accu.includes(key)) {
334
+ accu.push(key);
335
+ }
336
+ });
337
+ return accu;
338
+ }, []);
339
+
340
+ // make sure each feature has exact same fields
341
+ allDataRows.forEach(function (d) {
342
+ fields.forEach(function (f) {
343
+ if (!(f in d)) {
344
+ d[f] = null;
345
+ if (d._geojson.properties) {
346
+ d._geojson.properties[f] = null;
347
+ }
348
+ }
349
+ });
350
+ });
351
+ return processRowObject(allDataRows);
352
+ }
353
+
354
+ /**
355
+ * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).
356
+ * The json object should contain `datasets` and `config`.
357
+ * @param rawData
358
+ * @param schema
359
+ * @returns datasets and config `{datasets: {}, config: {}}`
360
+ * @public
361
+ * @example
362
+ * import {addDataToMap} from 'kepler.gl/actions';
363
+ * import {processKeplerglJSON} from 'kepler.gl/processors';
364
+ *
365
+ * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));
366
+ */
367
+ function processKeplerglJSON(rawData) {
368
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
369
+ return rawData ? schema.load(rawData.datasets, rawData.config) : null;
370
+ }
371
+
372
+ /**
373
+ * Parse a single or an array of datasets saved using kepler.gl schema
374
+ * @param rawData
375
+ * @param schema
376
+ */
377
+ function processKeplerglDataset(rawData) {
378
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
379
+ if (!rawData) {
380
+ return null;
381
+ }
382
+ var results = schema.parseSavedData((0, _commonUtils.toArray)(rawData));
383
+ if (!results) {
384
+ return null;
385
+ }
386
+ return Array.isArray(rawData) ? results : results[0];
387
+ }
388
+
389
+ /**
390
+ * Parse arrow table and return a dataset
391
+ *
392
+ * @param arrowTable ArrowTable to parse, see loaders.gl/schema
393
+ * @returns dataset containing `fields` and `rows` or null
394
+ */
395
+ function processArrowTable(arrowTable) {
396
+ // @ts-ignore - Unknown data type causing build failures
397
+ return processArrowBatches(arrowTable.data.batches);
398
+ }
399
+ function arrowSchemaToFields(schema) {
400
+ return schema.fields.map(function (field, index) {
401
+ var _field$metadata$get;
402
+ var isGeoArrowColumn = (_field$metadata$get = field.metadata.get('ARROW:extension:name')) === null || _field$metadata$get === void 0 ? void 0 : _field$metadata$get.startsWith('geoarrow');
403
+ return _objectSpread(_objectSpread({}, field), {}, {
404
+ name: field.name,
405
+ id: field.name,
406
+ displayName: field.name,
407
+ format: '',
408
+ fieldIdx: index,
409
+ type: isGeoArrowColumn ? _constants.ALL_FIELD_TYPES.geoarrow : (0, _utils.arrowDataTypeToFieldType)(field.type),
410
+ analyzerType: isGeoArrowColumn ? _typeAnalyzer.DATA_TYPES.GEOMETRY : (0, _utils.arrowDataTypeToAnalyzerDataType)(field.type),
411
+ valueAccessor: function valueAccessor(dc) {
412
+ return function (d) {
413
+ return dc.valueAt(d.index, index);
414
+ };
415
+ },
416
+ metadata: field.metadata
417
+ });
418
+ });
419
+ }
420
+ /**
421
+ * Parse arrow batches returned from parseInBatches()
422
+ *
423
+ * @param arrowTable the arrow table to parse
424
+ * @returns dataset containing `fields` and `rows` or null
425
+ */
426
+ function processArrowBatches(arrowBatches) {
427
+ if (arrowBatches.length === 0) {
428
+ return null;
429
+ }
430
+ var arrowTable = new arrow.Table(arrowBatches);
431
+ var fields = arrowSchemaToFields(arrowTable.schema);
432
+ var cols = (0, _toConsumableArray2["default"])(Array(arrowTable.numCols).keys()).map(function (i) {
433
+ return arrowTable.getChildAt(i);
434
+ });
435
+
436
+ // return empty rows and use raw arrow table to construct column-wise data container
437
+ return {
438
+ fields: fields,
439
+ rows: [],
440
+ cols: cols,
441
+ metadata: arrowTable.schema.metadata
442
+ };
443
+ }
444
+ var DATASET_HANDLERS = exports.DATASET_HANDLERS = (0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])((0, _defineProperty2["default"])({}, _constants.DATASET_FORMATS.row, processRowObject), _constants.DATASET_FORMATS.geojson, processGeojson), _constants.DATASET_FORMATS.csv, processCsvData), _constants.DATASET_FORMATS.arrow, processArrowTable), _constants.DATASET_FORMATS.keplergl, processKeplerglDataset);
445
+ var Processors = exports.Processors = {
446
+ processGeojson: processGeojson,
447
+ processCsvData: processCsvData,
448
+ processArrowTable: processArrowTable,
449
+ processArrowBatches: processArrowBatches,
450
+ processRowObject: processRowObject,
451
+ processKeplerglJSON: processKeplerglJSON,
452
+ processKeplerglDataset: processKeplerglDataset,
453
+ analyzerTypeToFieldType: _commonUtils.analyzerTypeToFieldType,
454
+ getFieldsFromData: _commonUtils.getFieldsFromData,
455
+ parseCsvRowsByFieldType: parseCsvRowsByFieldType
456
+ };
457
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["arrow","_interopRequireWildcard","require","_d3Dsv","_typeAnalyzer","_geojsonNormalize","_interopRequireDefault","_constants","_utils","_commonUtils","_schemas","_getRequireWildcardCache","e","WeakMap","r","t","__esModule","_typeof","has","get","n","__proto__","a","Object","defineProperty","getOwnPropertyDescriptor","u","hasOwnProperty","call","i","set","ownKeys","keys","getOwnPropertySymbols","o","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","CSV_NULLS","exports","tryParseJsonString","str","JSON","parse","PARSE_FIELD_VALUE_FROM_STRING","ALL_FIELD_TYPES","valid","d","integer","parseInt","timestamp","field","includes","format","Number","real","parseFloat","object","isPlainObject","array","Array","isArray","h3","h3IsValid","processCsvData","rawData","header","rows","headerRow","parsedRows","csvParseRows","Error","slice","cleanUpFalsyCsvValue","sample","getSampleForTypeAnalyze","fields","getFieldsFromData","parseRowsByFields","geojsonFieldIdx","findIndex","f","name","parseCsvRowsByFieldType","bind","re","RegExp","j","match","geoFieldIdx","parser","type","first","find","notNullorUndefined","row","properties","processRowObject","map","key","processGeojson","normalizedGeojson","normalize","features","error","concat","GUIDES_FILE_FORMAT_DOC","allDataRows","geometry","_geojson","reduce","accu","curr","processKeplerglJSON","schema","undefined","KeplerGlSchema","load","datasets","config","processKeplerglDataset","results","parseSavedData","toArray","processArrowTable","arrowTable","processArrowBatches","data","batches","arrowSchemaToFields","index","_field$metadata$get","isGeoArrowColumn","metadata","startsWith","id","displayName","fieldIdx","geoarrow","arrowDataTypeToFieldType","analyzerType","AnalyzerDATA_TYPES","GEOMETRY","arrowDataTypeToAnalyzerDataType","valueAccessor","dc","valueAt","arrowBatches","Table","cols","_toConsumableArray2","numCols","getChildAt","DATASET_HANDLERS","DATASET_FORMATS","geojson","csv","keplergl","Processors","analyzerTypeToFieldType"],"sources":["../src/data-processor.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport * as arrow from 'apache-arrow';\nimport {csvParseRows} from 'd3-dsv';\nimport {DATA_TYPES as AnalyzerDATA_TYPES} from 'type-analyzer';\nimport normalize from '@mapbox/geojson-normalize';\nimport {ArrowTable} from '@loaders.gl/schema';\nimport {ALL_FIELD_TYPES, DATASET_FORMATS, GUIDES_FILE_FORMAT_DOC} from '@kepler.gl/constants';\nimport {ProcessorResult, Field} from '@kepler.gl/types';\nimport {\n  arrowDataTypeToAnalyzerDataType,\n  arrowDataTypeToFieldType,\n  hasOwnProperty,\n  isPlainObject\n} from '@kepler.gl/utils';\nimport {\n  analyzerTypeToFieldType,\n  getSampleForTypeAnalyze,\n  getFieldsFromData,\n  h3IsValid,\n  notNullorUndefined,\n  toArray\n} from '@kepler.gl/common-utils';\nimport {KeplerGlSchema, ParsedDataset, SavedMap, LoadedMap} from '@kepler.gl/schemas';\nimport {Feature} from '@nebula.gl/edit-modes';\n\n// if any of these value occurs in csv, parse it to null;\n// const CSV_NULLS = ['', 'null', 'NULL', 'Null', 'NaN', '/N'];\n// matches empty string\nexport const CSV_NULLS = /^(null|NULL|Null|NaN|\\/N||)$/;\n\nfunction tryParseJsonString(str) {\n  try {\n    return JSON.parse(str);\n  } catch (e) {\n    return null;\n  }\n}\n\nexport const PARSE_FIELD_VALUE_FROM_STRING = {\n  [ALL_FIELD_TYPES.boolean]: {\n    valid: (d: unknown): boolean => typeof d === 'boolean',\n    parse: (d: unknown): boolean => d === 'true' || d === 'True' || d === 'TRUE' || d === '1'\n  },\n  [ALL_FIELD_TYPES.integer]: {\n    // @ts-ignore\n    valid: (d: unknown): boolean => parseInt(d, 10) === d,\n    // @ts-ignore\n    parse: (d: unknown): number => parseInt(d, 10)\n  },\n  [ALL_FIELD_TYPES.timestamp]: {\n    valid: (d: unknown, field: Field): boolean =>\n      ['x', 'X'].includes(field.format) ? typeof d === 'number' : typeof d === 'string',\n    parse: (d: any, field: Field) => (['x', 'X'].includes(field.format) ? Number(d) : d)\n  },\n  [ALL_FIELD_TYPES.real]: {\n    // @ts-ignore\n    valid: (d: unknown): boolean => parseFloat(d) === d,\n    // Note this will result in NaN for some string\n    parse: parseFloat\n  },\n  [ALL_FIELD_TYPES.object]: {\n    valid: isPlainObject,\n    parse: tryParseJsonString\n  },\n\n  [ALL_FIELD_TYPES.array]: {\n    valid: Array.isArray,\n    parse: tryParseJsonString\n  },\n\n  [ALL_FIELD_TYPES.h3]: {\n    valid: d => h3IsValid(d),\n    parse: d => d\n  }\n};\n\n/**\n * Process csv data, output a data object with `{fields: [], rows: []}`.\n * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)\n * @param rawData raw csv string\n * @returns data object `{fields: [], rows: []}` can be passed to addDataToMaps\n * @public\n * @example\n * import {processCsvData} from 'kepler.gl/processors';\n *\n * 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\n * 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\n * 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\n * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23\n * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`\n *\n * const dataset = {\n *  info: {id: 'test_data', label: 'My Csv'},\n *  data: processCsvData(testData)\n * };\n *\n * dispatch(addDataToMap({\n *  datasets: [dataset],\n *  options: {centerMap: true, readOnly: true}\n * }));\n */\nexport function processCsvData(rawData: unknown[][] | string, header?: string[]): ProcessorResult {\n  let rows: unknown[][] | undefined;\n  let headerRow: string[] | undefined;\n\n  if (typeof rawData === 'string') {\n    const parsedRows: string[][] = csvParseRows(rawData);\n\n    if (!Array.isArray(parsedRows) || parsedRows.length < 2) {\n      // looks like an empty file, throw error to be catch\n      throw new Error('process Csv Data Failed: CSV is empty');\n    }\n    headerRow = parsedRows[0];\n    rows = parsedRows.slice(1);\n  } else if (Array.isArray(rawData) && rawData.length) {\n    rows = rawData;\n    headerRow = header;\n\n    if (!Array.isArray(headerRow)) {\n      // if data is passed in as array of rows and missing header\n      // assume first row is header\n      // @ts-ignore\n      headerRow = rawData[0];\n      rows = rawData.slice(1);\n    }\n  }\n\n  if (!rows || !headerRow) {\n    throw new Error('invalid input passed to processCsvData');\n  }\n\n  // here we assume the csv file that people uploaded will have first row\n  // as name of the column\n\n  cleanUpFalsyCsvValue(rows);\n  // No need to run type detection on every data point\n  // here we get a list of none null values to run analyze on\n  const sample = getSampleForTypeAnalyze({fields: headerRow, rows});\n  const fields = getFieldsFromData(sample, headerRow);\n  const parsedRows = parseRowsByFields(rows, fields);\n\n  return {fields, rows: parsedRows};\n}\n\n/**\n * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`\n * @param rows\n * @param fields\n */\nexport function parseRowsByFields(rows: any[][], fields: Field[]) {\n  // Edit rows in place\n  const geojsonFieldIdx = fields.findIndex(f => f.name === '_geojson');\n  fields.forEach(parseCsvRowsByFieldType.bind(null, rows, geojsonFieldIdx));\n\n  return rows;\n}\n\n/**\n * Convert falsy value in csv including `'', 'null', 'NULL', 'Null', 'NaN'` to `null`,\n * so that type-analyzer won't detect it as string\n *\n * @param rows\n */\nfunction cleanUpFalsyCsvValue(rows: unknown[][]): void {\n  const re = new RegExp(CSV_NULLS, 'g');\n  for (let i = 0; i < rows.length; i++) {\n    for (let j = 0; j < rows[i].length; j++) {\n      // analyzer will set any fields to 'string' if there are empty values\n      // which will be parsed as '' by d3.csv\n      // here we parse empty data as null\n      // TODO: create warning when deltect `CSV_NULLS` in the data\n      if (typeof rows[i][j] === 'string' && (rows[i][j] as string).match(re)) {\n        rows[i][j] = null;\n      }\n    }\n  }\n}\n\n/**\n * Process uploaded csv file to parse value by field type\n *\n * @param rows\n * @param geoFieldIdx field index\n * @param field\n * @param i\n */\nexport function parseCsvRowsByFieldType(\n  rows: unknown[][],\n  geoFieldIdx: number,\n  field: Field,\n  i: number\n): void {\n  const parser = PARSE_FIELD_VALUE_FROM_STRING[field.type];\n  if (parser) {\n    // check first not null value of it's already parsed\n    const first = rows.find(r => notNullorUndefined(r[i]));\n    if (!first || parser.valid(first[i], field)) {\n      return;\n    }\n    rows.forEach(row => {\n      // parse string value based on field type\n      if (row[i] !== null) {\n        row[i] = parser.parse(row[i], field);\n        if (\n          geoFieldIdx > -1 &&\n          isPlainObject(row[geoFieldIdx]) &&\n          // @ts-ignore\n          hasOwnProperty(row[geoFieldIdx], 'properties')\n        ) {\n          // @ts-ignore\n          row[geoFieldIdx].properties[field.name] = row[i];\n        }\n      }\n    });\n  }\n}\n\n/* eslint-enable complexity */\n\n/**\n * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)\n * NOTE: This function may mutate input.\n * @param rawData an array of row object, each object should have the same number of keys\n * @returns dataset containing `fields` and `rows`\n * @public\n * @example\n * import {addDataToMap} from 'kepler.gl/actions';\n * import {processRowObject} from 'kepler.gl/processors';\n *\n * const data = [\n *  {lat: 31.27, lng: 127.56, value: 3},\n *  {lat: 31.22, lng: 126.26, value: 1}\n * ];\n *\n * dispatch(addDataToMap({\n *  datasets: {\n *    info: {label: 'My Data', id: 'my_data'},\n *    data: processRowObject(data)\n *  }\n * }));\n */\nexport function processRowObject(rawData: unknown[]): ProcessorResult {\n  if (!Array.isArray(rawData)) {\n    return null;\n  } else if (!rawData.length) {\n    // data is empty\n    return {\n      fields: [],\n      rows: []\n    };\n  }\n\n  const keys = Object.keys(rawData[0]); // [lat, lng, value]\n  const rows = rawData.map(d => keys.map(key => d[key])); // [[31.27, 127.56, 3]]\n\n  // row object can still contain values like `Null` or `N/A`\n  cleanUpFalsyCsvValue(rows);\n\n  return processCsvData(rows, keys);\n}\n\n/**\n * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),\n * output a data object with `{fields: [], rows: []}`.\n * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)\n * NOTE: This function may mutate input.\n *\n * @param rawData raw geojson feature collection\n * @returns dataset containing `fields` and `rows`\n * @public\n * @example\n * import {addDataToMap} from 'kepler.gl/actions';\n * import {processGeojson} from 'kepler.gl/processors';\n *\n * const geojson = {\n * \t\"type\" : \"FeatureCollection\",\n * \t\"features\" : [{\n * \t\t\"type\" : \"Feature\",\n * \t\t\"properties\" : {\n * \t\t\t\"capacity\" : \"10\",\n * \t\t\t\"type\" : \"U-Rack\"\n * \t\t},\n * \t\t\"geometry\" : {\n * \t\t\t\"type\" : \"Point\",\n * \t\t\t\"coordinates\" : [ -71.073283, 42.417500 ]\n * \t\t}\n * \t}]\n * };\n *\n * dispatch(addDataToMap({\n *  datasets: {\n *    info: {\n *      label: 'Sample Taxi Trips in New York City',\n *      id: 'test_trip_data'\n *    },\n *    data: processGeojson(geojson)\n *  }\n * }));\n */\nexport function processGeojson(rawData: unknown): ProcessorResult {\n  const normalizedGeojson = normalize(rawData);\n\n  if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {\n    const error = new Error(\n      `Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](${GUIDES_FILE_FORMAT_DOC})`\n    );\n    throw error;\n    // fail to normalize geojson\n  }\n\n  // getting all feature fields\n  const allDataRows: Array<{_geojson: Feature} & keyof Feature> = [];\n  for (let i = 0; i < normalizedGeojson.features.length; i++) {\n    const f = normalizedGeojson.features[i];\n    if (f.geometry) {\n      allDataRows.push({\n        // add feature to _geojson field\n        _geojson: f,\n        ...(f.properties || {})\n      });\n    }\n  }\n  // get all the field\n  const fields = allDataRows.reduce<string[]>((accu, curr) => {\n    Object.keys(curr).forEach(key => {\n      if (!accu.includes(key)) {\n        accu.push(key);\n      }\n    });\n    return accu;\n  }, []);\n\n  // make sure each feature has exact same fields\n  allDataRows.forEach(d => {\n    fields.forEach(f => {\n      if (!(f in d)) {\n        d[f] = null;\n        if (d._geojson.properties) {\n          d._geojson.properties[f] = null;\n        }\n      }\n    });\n  });\n\n  return processRowObject(allDataRows);\n}\n\n/**\n * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).\n * The json object should contain `datasets` and `config`.\n * @param rawData\n * @param schema\n * @returns datasets and config `{datasets: {}, config: {}}`\n * @public\n * @example\n * import {addDataToMap} from 'kepler.gl/actions';\n * import {processKeplerglJSON} from 'kepler.gl/processors';\n *\n * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));\n */\nexport function processKeplerglJSON(rawData: SavedMap, schema = KeplerGlSchema): LoadedMap | null {\n  return rawData ? schema.load(rawData.datasets, rawData.config) : null;\n}\n\n/**\n * Parse a single or an array of datasets saved using kepler.gl schema\n * @param rawData\n * @param schema\n */\nexport function processKeplerglDataset(\n  rawData: object | object[],\n  schema = KeplerGlSchema\n): ParsedDataset | ParsedDataset[] | null {\n  if (!rawData) {\n    return null;\n  }\n\n  const results = schema.parseSavedData(toArray(rawData));\n  if (!results) {\n    return null;\n  }\n  return Array.isArray(rawData) ? results : results[0];\n}\n\n/**\n * Parse arrow table and return a dataset\n *\n * @param arrowTable ArrowTable to parse, see loaders.gl/schema\n * @returns dataset containing `fields` and `rows` or null\n */\nexport function processArrowTable(arrowTable: ArrowTable): ProcessorResult | null {\n  // @ts-ignore - Unknown data type causing build failures\n  return processArrowBatches(arrowTable.data.batches);\n}\n\nexport function arrowSchemaToFields(schema: arrow.Schema): Field[] {\n  return schema.fields.map((field: arrow.Field, index: number) => {\n    const isGeoArrowColumn = field.metadata.get('ARROW:extension:name')?.startsWith('geoarrow');\n    return {\n      ...field,\n      name: field.name,\n      id: field.name,\n      displayName: field.name,\n      format: '',\n      fieldIdx: index,\n      type: isGeoArrowColumn ? ALL_FIELD_TYPES.geoarrow : arrowDataTypeToFieldType(field.type),\n      analyzerType: isGeoArrowColumn\n        ? AnalyzerDATA_TYPES.GEOMETRY\n        : arrowDataTypeToAnalyzerDataType(field.type),\n      valueAccessor: (dc: any) => d => {\n        return dc.valueAt(d.index, index);\n      },\n      metadata: field.metadata\n    };\n  });\n}\n/**\n * Parse arrow batches returned from parseInBatches()\n *\n * @param arrowTable the arrow table to parse\n * @returns dataset containing `fields` and `rows` or null\n */\nexport function processArrowBatches(arrowBatches: arrow.RecordBatch[]): ProcessorResult | null {\n  if (arrowBatches.length === 0) {\n    return null;\n  }\n  const arrowTable = new arrow.Table(arrowBatches);\n  const fields = arrowSchemaToFields(arrowTable.schema);\n\n  const cols = [...Array(arrowTable.numCols).keys()].map(i => arrowTable.getChildAt(i));\n\n  // return empty rows and use raw arrow table to construct column-wise data container\n  return {fields, rows: [], cols, metadata: arrowTable.schema.metadata};\n}\n\nexport const DATASET_HANDLERS = {\n  [DATASET_FORMATS.row]: processRowObject,\n  [DATASET_FORMATS.geojson]: processGeojson,\n  [DATASET_FORMATS.csv]: processCsvData,\n  [DATASET_FORMATS.arrow]: processArrowTable,\n  [DATASET_FORMATS.keplergl]: processKeplerglDataset\n};\n\nexport const Processors: {\n  processGeojson: typeof processGeojson;\n  processCsvData: typeof processCsvData;\n  processArrowTable: typeof processArrowTable;\n  processArrowBatches: typeof processArrowBatches;\n  processRowObject: typeof processRowObject;\n  processKeplerglJSON: typeof processKeplerglJSON;\n  processKeplerglDataset: typeof processKeplerglDataset;\n  analyzerTypeToFieldType: typeof analyzerTypeToFieldType;\n  getFieldsFromData: typeof getFieldsFromData;\n  parseCsvRowsByFieldType: typeof parseCsvRowsByFieldType;\n} = {\n  processGeojson,\n  processCsvData,\n  processArrowTable,\n  processArrowBatches,\n  processRowObject,\n  processKeplerglJSON,\n  processKeplerglDataset,\n  analyzerTypeToFieldType,\n  getFieldsFromData,\n  parseCsvRowsByFieldType\n};\n"],"mappings":"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","ignoreList":[]}
@@ -0,0 +1,49 @@
1
+ import * as arrow from 'apache-arrow';
2
+ import { Loader } from '@loaders.gl/loader-utils';
3
+ import { AddDataToMapPayload, Feature } from '@kepler.gl/types';
4
+ import { FeatureCollection } from '@turf/helpers';
5
+ import { FileCacheItem, ValidKeplerGlMap } from './types';
6
+ export declare type ProcessFileDataContent = {
7
+ data: unknown;
8
+ fileName: string;
9
+ length?: number;
10
+ progress?: {
11
+ rowCount?: number;
12
+ rowCountInBatch?: number;
13
+ percent?: number;
14
+ };
15
+ /** metadata e.g. for arrow data, metadata could be the schema.fields */
16
+ metadata?: Map<string, string>;
17
+ };
18
+ /**
19
+ * check if table is an ArrowTable object
20
+ * @param table - object to check
21
+ * @returns {boolean} - true if table is an ArrowTable object type guarded
22
+ */
23
+ export declare function isArrowTable(table: any): table is arrow.Table;
24
+ /**
25
+ * check if data is an ArrowData object, which is an array of RecordBatch
26
+ * @param data - object to check
27
+ * @returns {boolean} - true if data is an ArrowData object type guarded
28
+ */
29
+ export declare function isArrowData(data: any): boolean;
30
+ export declare function isGeoJson(json: unknown): json is Feature | FeatureCollection;
31
+ export declare function isFeature(json: unknown): json is Feature;
32
+ export declare function isFeatureCollection(json: unknown): json is FeatureCollection;
33
+ export declare function isRowObject(json: any): boolean;
34
+ export declare function isKeplerGlMap(json: unknown): json is ValidKeplerGlMap;
35
+ export declare function makeProgressIterator(asyncIterator: AsyncIterable<any>, info: {
36
+ size: number;
37
+ }): AsyncGenerator;
38
+ export declare function readBatch(asyncIterator: AsyncIterable<any>, fileName: string): AsyncGenerator;
39
+ export declare function readFileInBatches({ file, loaders, loadOptions }: {
40
+ file: File;
41
+ fileCache: FileCacheItem[];
42
+ loaders: Loader[];
43
+ loadOptions: any;
44
+ }): Promise<AsyncGenerator>;
45
+ export declare function processFileData({ content, fileCache }: {
46
+ content: ProcessFileDataContent;
47
+ fileCache: FileCacheItem[];
48
+ }): Promise<FileCacheItem[]>;
49
+ export declare function filesToDataPayload(fileCache: FileCacheItem[]): AddDataToMapPayload[];