@kepler.gl/processors 3.0.0-alpha.0

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,161 @@
1
+ import { ProcessorResult, Field } from '@kepler.gl/types';
2
+ import { analyzerTypeToFieldType, getFieldsFromData } from '@kepler.gl/utils';
3
+ import { ParsedDataset, SavedMap, LoadedMap } from '@kepler.gl/schemas';
4
+ export declare const CSV_NULLS: RegExp;
5
+ export declare const PARSE_FIELD_VALUE_FROM_STRING: {
6
+ boolean: {
7
+ valid: (d: unknown) => boolean;
8
+ parse: (d: unknown) => boolean;
9
+ };
10
+ integer: {
11
+ valid: (d: unknown) => boolean;
12
+ parse: (d: unknown) => number;
13
+ };
14
+ timestamp: {
15
+ valid: (d: unknown, field: Field) => boolean;
16
+ parse: (d: any, field: Field) => any;
17
+ };
18
+ real: {
19
+ valid: (d: unknown) => boolean;
20
+ parse: typeof parseFloat;
21
+ };
22
+ };
23
+ /**
24
+ * Process csv data, output a data object with `{fields: [], rows: []}`.
25
+ * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)
26
+ * @param rawData raw csv string
27
+ * @returns data object `{fields: [], rows: []}` can be passed to addDataToMaps
28
+ * @public
29
+ * @example
30
+ * import {processCsvData} from 'kepler.gl/processors';
31
+ *
32
+ * 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
33
+ * 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
34
+ * 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
35
+ * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23
36
+ * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`
37
+ *
38
+ * const dataset = {
39
+ * info: {id: 'test_data', label: 'My Csv'},
40
+ * data: processCsvData(testData)
41
+ * };
42
+ *
43
+ * dispatch(addDataToMap({
44
+ * datasets: [dataset],
45
+ * options: {centerMap: true, readOnly: true}
46
+ * }));
47
+ */
48
+ export declare function processCsvData(rawData: unknown[][], header?: string[]): ProcessorResult;
49
+ /**
50
+ * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`
51
+ * @param rows
52
+ * @param fields
53
+ */
54
+ export declare function parseRowsByFields(rows: any[][], fields: Field[]): any[][];
55
+ /**
56
+ * Process uploaded csv file to parse value by field type
57
+ *
58
+ * @param rows
59
+ * @param geoFieldIdx field index
60
+ * @param field
61
+ * @param i
62
+ */
63
+ export declare function parseCsvRowsByFieldType(rows: unknown[][], geoFieldIdx: number, field: Field, i: number): void;
64
+ /**
65
+ * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
66
+ * NOTE: This function may mutate input.
67
+ * @param rawData an array of row object, each object should have the same number of keys
68
+ * @returns dataset containing `fields` and `rows`
69
+ * @public
70
+ * @example
71
+ * import {addDataToMap} from 'kepler.gl/actions';
72
+ * import {processRowObject} from 'kepler.gl/processors';
73
+ *
74
+ * const data = [
75
+ * {lat: 31.27, lng: 127.56, value: 3},
76
+ * {lat: 31.22, lng: 126.26, value: 1}
77
+ * ];
78
+ *
79
+ * dispatch(addDataToMap({
80
+ * datasets: {
81
+ * info: {label: 'My Data', id: 'my_data'},
82
+ * data: processRowObject(data)
83
+ * }
84
+ * }));
85
+ */
86
+ export declare function processRowObject(rawData: unknown[]): ProcessorResult;
87
+ /**
88
+ * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),
89
+ * output a data object with `{fields: [], rows: []}`.
90
+ * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
91
+ * NOTE: This function may mutate input.
92
+ *
93
+ * @param rawData raw geojson feature collection
94
+ * @returns dataset containing `fields` and `rows`
95
+ * @public
96
+ * @example
97
+ * import {addDataToMap} from 'kepler.gl/actions';
98
+ * import {processGeojson} from 'kepler.gl/processors';
99
+ *
100
+ * const geojson = {
101
+ * "type" : "FeatureCollection",
102
+ * "features" : [{
103
+ * "type" : "Feature",
104
+ * "properties" : {
105
+ * "capacity" : "10",
106
+ * "type" : "U-Rack"
107
+ * },
108
+ * "geometry" : {
109
+ * "type" : "Point",
110
+ * "coordinates" : [ -71.073283, 42.417500 ]
111
+ * }
112
+ * }]
113
+ * };
114
+ *
115
+ * dispatch(addDataToMap({
116
+ * datasets: {
117
+ * info: {
118
+ * label: 'Sample Taxi Trips in New York City',
119
+ * id: 'test_trip_data'
120
+ * },
121
+ * data: processGeojson(geojson)
122
+ * }
123
+ * }));
124
+ */
125
+ export declare function processGeojson(rawData: unknown): ProcessorResult;
126
+ /**
127
+ * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).
128
+ * The json object should contain `datasets` and `config`.
129
+ * @param rawData
130
+ * @param schema
131
+ * @returns datasets and config `{datasets: {}, config: {}}`
132
+ * @public
133
+ * @example
134
+ * import {addDataToMap} from 'kepler.gl/actions';
135
+ * import {processKeplerglJSON} from 'kepler.gl/processors';
136
+ *
137
+ * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));
138
+ */
139
+ export declare function processKeplerglJSON(rawData: SavedMap, schema?: import("@kepler.gl/schemas").KeplerGLSchemaClass): LoadedMap | null;
140
+ /**
141
+ * Parse a single or an array of datasets saved using kepler.gl schema
142
+ * @param rawData
143
+ * @param schema
144
+ */
145
+ export declare function processKeplerglDataset(rawData: object | object[], schema?: import("@kepler.gl/schemas").KeplerGLSchemaClass): ParsedDataset | ParsedDataset[] | null;
146
+ export declare const DATASET_HANDLERS: {
147
+ row: typeof processRowObject;
148
+ geojson: typeof processGeojson;
149
+ csv: typeof processCsvData;
150
+ keplergl: typeof processKeplerglDataset;
151
+ };
152
+ export declare const Processors: {
153
+ processGeojson: typeof processGeojson;
154
+ processCsvData: typeof processCsvData;
155
+ processRowObject: typeof processRowObject;
156
+ processKeplerglJSON: typeof processKeplerglJSON;
157
+ processKeplerglDataset: typeof processKeplerglDataset;
158
+ analyzerTypeToFieldType: typeof analyzerTypeToFieldType;
159
+ getFieldsFromData: typeof getFieldsFromData;
160
+ parseCsvRowsByFieldType: typeof parseCsvRowsByFieldType;
161
+ };
@@ -0,0 +1,427 @@
1
+ // Copyright (c) 2022 Uber Technologies, Inc.
2
+ //
3
+ // Permission is hereby granted, free of charge, to any person obtaining a copy
4
+ // of this software and associated documentation files (the "Software"), to deal
5
+ // in the Software without restriction, including without limitation the rights
6
+ // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7
+ // copies of the Software, and to permit persons to whom the Software is
8
+ // furnished to do so, subject to the following conditions:
9
+ //
10
+ // The above copyright notice and this permission notice shall be included in
11
+ // all copies or substantial portions of the Software.
12
+ //
13
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14
+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15
+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16
+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17
+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19
+ // THE SOFTWARE.
20
+
21
+ "use strict";
22
+
23
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
24
+
25
+ Object.defineProperty(exports, "__esModule", {
26
+ value: true
27
+ });
28
+ exports.processCsvData = processCsvData;
29
+ exports.parseRowsByFields = parseRowsByFields;
30
+ exports.parseCsvRowsByFieldType = parseCsvRowsByFieldType;
31
+ exports.processRowObject = processRowObject;
32
+ exports.processGeojson = processGeojson;
33
+ exports.processKeplerglJSON = processKeplerglJSON;
34
+ exports.processKeplerglDataset = processKeplerglDataset;
35
+ exports.Processors = exports.DATASET_HANDLERS = exports.PARSE_FIELD_VALUE_FROM_STRING = exports.CSV_NULLS = void 0;
36
+
37
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
38
+
39
+ var _d3Dsv = require("d3-dsv");
40
+
41
+ var _geojsonNormalize = _interopRequireDefault(require("@mapbox/geojson-normalize"));
42
+
43
+ var _constants = require("@kepler.gl/constants");
44
+
45
+ var _utils = require("@kepler.gl/utils");
46
+
47
+ var _schemas = require("@kepler.gl/schemas");
48
+
49
+ var _PARSE_FIELD_VALUE_FR, _DATASET_HANDLERS;
50
+
51
+ 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; }
52
+
53
+ 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; }
54
+
55
+ // if any of these value occurs in csv, parse it to null;
56
+ // const CSV_NULLS = ['', 'null', 'NULL', 'Null', 'NaN', '/N'];
57
+ // matches empty string
58
+ var CSV_NULLS = /^(null|NULL|Null|NaN|\/N||)$/;
59
+ exports.CSV_NULLS = CSV_NULLS;
60
+ var PARSE_FIELD_VALUE_FROM_STRING = (_PARSE_FIELD_VALUE_FR = {}, (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _constants.ALL_FIELD_TYPES["boolean"], {
61
+ valid: function valid(d) {
62
+ return typeof d === 'boolean';
63
+ },
64
+ parse: function parse(d) {
65
+ return d === 'true' || d === 'True' || d === 'TRUE' || d === '1';
66
+ }
67
+ }), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _constants.ALL_FIELD_TYPES.integer, {
68
+ // @ts-ignore
69
+ valid: function valid(d) {
70
+ return parseInt(d, 10) === d;
71
+ },
72
+ // @ts-ignore
73
+ parse: function parse(d) {
74
+ return parseInt(d, 10);
75
+ }
76
+ }), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _constants.ALL_FIELD_TYPES.timestamp, {
77
+ valid: function valid(d, field) {
78
+ return ['x', 'X'].includes(field.format) ? typeof d === 'number' : typeof d === 'string';
79
+ },
80
+ parse: function parse(d, field) {
81
+ return ['x', 'X'].includes(field.format) ? Number(d) : d;
82
+ }
83
+ }), (0, _defineProperty2["default"])(_PARSE_FIELD_VALUE_FR, _constants.ALL_FIELD_TYPES.real, {
84
+ // @ts-ignore
85
+ valid: function valid(d) {
86
+ return parseFloat(d) === d;
87
+ },
88
+ // Note this will result in NaN for some string
89
+ parse: parseFloat
90
+ }), _PARSE_FIELD_VALUE_FR);
91
+ /**
92
+ * Process csv data, output a data object with `{fields: [], rows: []}`.
93
+ * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)
94
+ * @param rawData raw csv string
95
+ * @returns data object `{fields: [], rows: []}` can be passed to addDataToMaps
96
+ * @public
97
+ * @example
98
+ * import {processCsvData} from 'kepler.gl/processors';
99
+ *
100
+ * 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
101
+ * 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
102
+ * 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
103
+ * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23
104
+ * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`
105
+ *
106
+ * const dataset = {
107
+ * info: {id: 'test_data', label: 'My Csv'},
108
+ * data: processCsvData(testData)
109
+ * };
110
+ *
111
+ * dispatch(addDataToMap({
112
+ * datasets: [dataset],
113
+ * options: {centerMap: true, readOnly: true}
114
+ * }));
115
+ */
116
+
117
+ exports.PARSE_FIELD_VALUE_FROM_STRING = PARSE_FIELD_VALUE_FROM_STRING;
118
+
119
+ function processCsvData(rawData, header) {
120
+ var rows;
121
+ var headerRow;
122
+
123
+ if (typeof rawData === 'string') {
124
+ var _parsedRows = (0, _d3Dsv.csvParseRows)(rawData);
125
+
126
+ if (!Array.isArray(_parsedRows) || _parsedRows.length < 2) {
127
+ // looks like an empty file, throw error to be catch
128
+ throw new Error('process Csv Data Failed: CSV is empty');
129
+ }
130
+
131
+ headerRow = _parsedRows[0];
132
+ rows = _parsedRows.slice(1);
133
+ } else if (Array.isArray(rawData) && rawData.length) {
134
+ rows = rawData;
135
+ headerRow = header;
136
+
137
+ if (!Array.isArray(headerRow)) {
138
+ // if data is passed in as array of rows and missing header
139
+ // assume first row is header
140
+ // @ts-ignore
141
+ headerRow = rawData[0];
142
+ rows = rawData.slice(1);
143
+ }
144
+ }
145
+
146
+ if (!rows || !headerRow) {
147
+ throw new Error('invalid input passed to processCsvData');
148
+ } // here we assume the csv file that people uploaded will have first row
149
+ // as name of the column
150
+
151
+
152
+ cleanUpFalsyCsvValue(rows); // No need to run type detection on every data point
153
+ // here we get a list of none null values to run analyze on
154
+
155
+ var sample = (0, _utils.getSampleForTypeAnalyze)({
156
+ fields: headerRow,
157
+ rows: rows
158
+ });
159
+ var fields = (0, _utils.getFieldsFromData)(sample, headerRow);
160
+ var parsedRows = parseRowsByFields(rows, fields);
161
+ return {
162
+ fields: fields,
163
+ rows: parsedRows
164
+ };
165
+ }
166
+ /**
167
+ * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`
168
+ * @param rows
169
+ * @param fields
170
+ */
171
+
172
+
173
+ function parseRowsByFields(rows, fields) {
174
+ // Edit rows in place
175
+ var geojsonFieldIdx = fields.findIndex(function (f) {
176
+ return f.name === '_geojson';
177
+ });
178
+ fields.forEach(parseCsvRowsByFieldType.bind(null, rows, geojsonFieldIdx));
179
+ return rows;
180
+ }
181
+ /**
182
+ * Convert falsy value in csv including `'', 'null', 'NULL', 'Null', 'NaN'` to `null`,
183
+ * so that type-analyzer won't detect it as string
184
+ *
185
+ * @param rows
186
+ */
187
+
188
+
189
+ function cleanUpFalsyCsvValue(rows) {
190
+ var re = new RegExp(CSV_NULLS, 'g');
191
+
192
+ for (var i = 0; i < rows.length; i++) {
193
+ for (var j = 0; j < rows[i].length; j++) {
194
+ // analyzer will set any fields to 'string' if there are empty values
195
+ // which will be parsed as '' by d3.csv
196
+ // here we parse empty data as null
197
+ // TODO: create warning when deltect `CSV_NULLS` in the data
198
+ if (typeof rows[i][j] === 'string' && rows[i][j].match(re)) {
199
+ rows[i][j] = null;
200
+ }
201
+ }
202
+ }
203
+ }
204
+ /**
205
+ * Process uploaded csv file to parse value by field type
206
+ *
207
+ * @param rows
208
+ * @param geoFieldIdx field index
209
+ * @param field
210
+ * @param i
211
+ */
212
+
213
+
214
+ function parseCsvRowsByFieldType(rows, geoFieldIdx, field, i) {
215
+ var parser = PARSE_FIELD_VALUE_FROM_STRING[field.type];
216
+
217
+ if (parser) {
218
+ // check first not null value of it's already parsed
219
+ var first = rows.find(function (r) {
220
+ return (0, _utils.notNullorUndefined)(r[i]);
221
+ });
222
+
223
+ if (!first || parser.valid(first[i], field)) {
224
+ return;
225
+ }
226
+
227
+ rows.forEach(function (row) {
228
+ // parse string value based on field type
229
+ if (row[i] !== null) {
230
+ row[i] = parser.parse(row[i], field);
231
+
232
+ if (geoFieldIdx > -1 && (0, _utils.isPlainObject)(row[geoFieldIdx]) && // @ts-ignore
233
+ (0, _utils.hasOwnProperty)(row[geoFieldIdx], 'properties')) {
234
+ // @ts-ignore
235
+ row[geoFieldIdx].properties[field.name] = row[i];
236
+ }
237
+ }
238
+ });
239
+ }
240
+ }
241
+ /* eslint-enable complexity */
242
+
243
+ /**
244
+ * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
245
+ * NOTE: This function may mutate input.
246
+ * @param rawData an array of row object, each object should have the same number of keys
247
+ * @returns dataset containing `fields` and `rows`
248
+ * @public
249
+ * @example
250
+ * import {addDataToMap} from 'kepler.gl/actions';
251
+ * import {processRowObject} from 'kepler.gl/processors';
252
+ *
253
+ * const data = [
254
+ * {lat: 31.27, lng: 127.56, value: 3},
255
+ * {lat: 31.22, lng: 126.26, value: 1}
256
+ * ];
257
+ *
258
+ * dispatch(addDataToMap({
259
+ * datasets: {
260
+ * info: {label: 'My Data', id: 'my_data'},
261
+ * data: processRowObject(data)
262
+ * }
263
+ * }));
264
+ */
265
+
266
+
267
+ function processRowObject(rawData) {
268
+ if (!Array.isArray(rawData)) {
269
+ return null;
270
+ } else if (!rawData.length) {
271
+ // data is empty
272
+ return {
273
+ fields: [],
274
+ rows: []
275
+ };
276
+ }
277
+
278
+ var keys = Object.keys(rawData[0]); // [lat, lng, value]
279
+
280
+ var rows = rawData.map(function (d) {
281
+ return keys.map(function (key) {
282
+ return d[key];
283
+ });
284
+ }); // [[31.27, 127.56, 3]]
285
+ // row object an still contain values like `Null` or `N/A`
286
+
287
+ cleanUpFalsyCsvValue(rows);
288
+ return processCsvData(rows, keys);
289
+ }
290
+ /**
291
+ * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),
292
+ * output a data object with `{fields: [], rows: []}`.
293
+ * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
294
+ * NOTE: This function may mutate input.
295
+ *
296
+ * @param rawData raw geojson feature collection
297
+ * @returns dataset containing `fields` and `rows`
298
+ * @public
299
+ * @example
300
+ * import {addDataToMap} from 'kepler.gl/actions';
301
+ * import {processGeojson} from 'kepler.gl/processors';
302
+ *
303
+ * const geojson = {
304
+ * "type" : "FeatureCollection",
305
+ * "features" : [{
306
+ * "type" : "Feature",
307
+ * "properties" : {
308
+ * "capacity" : "10",
309
+ * "type" : "U-Rack"
310
+ * },
311
+ * "geometry" : {
312
+ * "type" : "Point",
313
+ * "coordinates" : [ -71.073283, 42.417500 ]
314
+ * }
315
+ * }]
316
+ * };
317
+ *
318
+ * dispatch(addDataToMap({
319
+ * datasets: {
320
+ * info: {
321
+ * label: 'Sample Taxi Trips in New York City',
322
+ * id: 'test_trip_data'
323
+ * },
324
+ * data: processGeojson(geojson)
325
+ * }
326
+ * }));
327
+ */
328
+
329
+
330
+ function processGeojson(rawData) {
331
+ var normalizedGeojson = (0, _geojsonNormalize["default"])(rawData);
332
+
333
+ if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {
334
+ 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, ")"));
335
+ throw error; // fail to normalize geojson
336
+ } // getting all feature fields
337
+
338
+
339
+ var allDataRows = [];
340
+
341
+ for (var i = 0; i < normalizedGeojson.features.length; i++) {
342
+ var f = normalizedGeojson.features[i];
343
+
344
+ if (f.geometry) {
345
+ allDataRows.push(_objectSpread({
346
+ // add feature to _geojson field
347
+ _geojson: f
348
+ }, f.properties || {}));
349
+ }
350
+ } // get all the field
351
+
352
+
353
+ var fields = allDataRows.reduce(function (accu, curr) {
354
+ Object.keys(curr).forEach(function (key) {
355
+ if (!accu.includes(key)) {
356
+ accu.push(key);
357
+ }
358
+ });
359
+ return accu;
360
+ }, []); // make sure each feature has exact same fields
361
+
362
+ allDataRows.forEach(function (d) {
363
+ fields.forEach(function (f) {
364
+ if (!(f in d)) {
365
+ d[f] = null;
366
+ d._geojson.properties[f] = null;
367
+ }
368
+ });
369
+ });
370
+ return processRowObject(allDataRows);
371
+ }
372
+ /**
373
+ * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).
374
+ * The json object should contain `datasets` and `config`.
375
+ * @param rawData
376
+ * @param schema
377
+ * @returns datasets and config `{datasets: {}, config: {}}`
378
+ * @public
379
+ * @example
380
+ * import {addDataToMap} from 'kepler.gl/actions';
381
+ * import {processKeplerglJSON} from 'kepler.gl/processors';
382
+ *
383
+ * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));
384
+ */
385
+
386
+
387
+ function processKeplerglJSON(rawData) {
388
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
389
+ return rawData ? schema.load(rawData.datasets, rawData.config) : null;
390
+ }
391
+ /**
392
+ * Parse a single or an array of datasets saved using kepler.gl schema
393
+ * @param rawData
394
+ * @param schema
395
+ */
396
+
397
+
398
+ function processKeplerglDataset(rawData) {
399
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
400
+
401
+ if (!rawData) {
402
+ return null;
403
+ }
404
+
405
+ var results = schema.parseSavedData((0, _utils.toArray)(rawData));
406
+
407
+ if (!results) {
408
+ return null;
409
+ }
410
+
411
+ return Array.isArray(rawData) ? results : results[0];
412
+ }
413
+
414
+ var DATASET_HANDLERS = (_DATASET_HANDLERS = {}, (0, _defineProperty2["default"])(_DATASET_HANDLERS, _constants.DATASET_FORMATS.row, processRowObject), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _constants.DATASET_FORMATS.geojson, processGeojson), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _constants.DATASET_FORMATS.csv, processCsvData), (0, _defineProperty2["default"])(_DATASET_HANDLERS, _constants.DATASET_FORMATS.keplergl, processKeplerglDataset), _DATASET_HANDLERS);
415
+ exports.DATASET_HANDLERS = DATASET_HANDLERS;
416
+ var Processors = {
417
+ processGeojson: processGeojson,
418
+ processCsvData: processCsvData,
419
+ processRowObject: processRowObject,
420
+ processKeplerglJSON: processKeplerglJSON,
421
+ processKeplerglDataset: processKeplerglDataset,
422
+ analyzerTypeToFieldType: _utils.analyzerTypeToFieldType,
423
+ getFieldsFromData: _utils.getFieldsFromData,
424
+ parseCsvRowsByFieldType: parseCsvRowsByFieldType
425
+ };
426
+ exports.Processors = Processors;
427
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/data-processor.ts"],"names":["CSV_NULLS","PARSE_FIELD_VALUE_FROM_STRING","ALL_FIELD_TYPES","valid","d","parse","integer","parseInt","timestamp","field","includes","format","Number","real","parseFloat","processCsvData","rawData","header","rows","headerRow","parsedRows","Array","isArray","length","Error","slice","cleanUpFalsyCsvValue","sample","fields","parseRowsByFields","geojsonFieldIdx","findIndex","f","name","forEach","parseCsvRowsByFieldType","bind","re","RegExp","i","j","match","geoFieldIdx","parser","type","first","find","r","row","properties","processRowObject","keys","Object","map","key","processGeojson","normalizedGeojson","features","error","GUIDES_FILE_FORMAT_DOC","allDataRows","geometry","push","_geojson","reduce","accu","curr","processKeplerglJSON","schema","KeplerGlSchema","load","datasets","config","processKeplerglDataset","results","parseSavedData","DATASET_HANDLERS","DATASET_FORMATS","geojson","csv","keplergl","Processors","analyzerTypeToFieldType","getFieldsFromData"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {csvParseRows} from 'd3-dsv';\nimport normalize from '@mapbox/geojson-normalize';\nimport {ALL_FIELD_TYPES, DATASET_FORMATS, GUIDES_FILE_FORMAT_DOC} from '@kepler.gl/constants';\nimport {ProcessorResult, Field} from '@kepler.gl/types';\nimport {\n  notNullorUndefined,\n  hasOwnProperty,\n  isPlainObject,\n  analyzerTypeToFieldType,\n  getSampleForTypeAnalyze,\n  getFieldsFromData,\n  toArray\n} from '@kepler.gl/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\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};\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[][], 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 an 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        d._geojson.properties[f] = null;\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\nexport const DATASET_HANDLERS: {\n  row: typeof processRowObject;\n  geojson: typeof processGeojson;\n  csv: typeof processCsvData;\n  keplergl: typeof processKeplerglDataset;\n} = {\n  [DATASET_FORMATS.row]: processRowObject,\n  [DATASET_FORMATS.geojson]: processGeojson,\n  [DATASET_FORMATS.csv]: processCsvData,\n  [DATASET_FORMATS.keplergl]: processKeplerglDataset\n};\n\nexport const Processors: {\n  processGeojson: typeof processGeojson;\n  processCsvData: typeof processCsvData;\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  processRowObject,\n  processKeplerglJSON,\n  processKeplerglDataset,\n  analyzerTypeToFieldType,\n  getFieldsFromData,\n  parseCsvRowsByFieldType\n};\n"]}
@@ -0,0 +1,27 @@
1
+ import { Loader } from '@loaders.gl/loader-utils';
2
+ import { FileCacheItem, ValidKeplerGlMap } from './types';
3
+ import { Feature, AddDataToMapPayload } from '@kepler.gl/types';
4
+ import { FeatureCollection } from '@turf/helpers';
5
+ export declare function isGeoJson(json: unknown): json is Feature | FeatureCollection;
6
+ export declare function isFeature(json: unknown): json is Feature;
7
+ export declare function isFeatureCollection(json: unknown): json is FeatureCollection;
8
+ export declare function isRowObject(json: any): boolean;
9
+ export declare function isKeplerGlMap(json: unknown): json is ValidKeplerGlMap;
10
+ export declare function makeProgressIterator(asyncIterator: AsyncIterable<any>, info: {
11
+ size: number;
12
+ }): AsyncGenerator;
13
+ export declare function readBatch(asyncIterator: AsyncIterable<any>, fileName: string): AsyncGenerator;
14
+ export declare function readFileInBatches({ file, loaders, loadOptions }: {
15
+ file: File;
16
+ fileCache: FileCacheItem[];
17
+ loaders: Loader[];
18
+ loadOptions: any;
19
+ }): Promise<AsyncGenerator>;
20
+ export declare function processFileData({ content, fileCache }: {
21
+ content: {
22
+ data: unknown;
23
+ fileName: string;
24
+ };
25
+ fileCache: FileCacheItem[];
26
+ }): Promise<FileCacheItem[]>;
27
+ export declare function filesToDataPayload(fileCache: FileCacheItem[]): AddDataToMapPayload[];
@@ -0,0 +1,449 @@
1
+ // Copyright (c) 2022 Uber Technologies, Inc.
2
+ //
3
+ // Permission is hereby granted, free of charge, to any person obtaining a copy
4
+ // of this software and associated documentation files (the "Software"), to deal
5
+ // in the Software without restriction, including without limitation the rights
6
+ // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7
+ // copies of the Software, and to permit persons to whom the Software is
8
+ // furnished to do so, subject to the following conditions:
9
+ //
10
+ // The above copyright notice and this permission notice shall be included in
11
+ // all copies or substantial portions of the Software.
12
+ //
13
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14
+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15
+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16
+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17
+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19
+ // THE SOFTWARE.
20
+
21
+ "use strict";
22
+
23
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
24
+
25
+ Object.defineProperty(exports, "__esModule", {
26
+ value: true
27
+ });
28
+ exports.isGeoJson = isGeoJson;
29
+ exports.isFeature = isFeature;
30
+ exports.isFeatureCollection = isFeatureCollection;
31
+ exports.isRowObject = isRowObject;
32
+ exports.isKeplerGlMap = isKeplerGlMap;
33
+ exports.makeProgressIterator = makeProgressIterator;
34
+ exports.readBatch = readBatch;
35
+ exports.readFileInBatches = readFileInBatches;
36
+ exports.processFileData = processFileData;
37
+ exports.filesToDataPayload = filesToDataPayload;
38
+
39
+ var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
40
+
41
+ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
42
+
43
+ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
44
+
45
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
46
+
47
+ var _awaitAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/awaitAsyncGenerator"));
48
+
49
+ var _wrapAsyncGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/wrapAsyncGenerator"));
50
+
51
+ var _asyncIterator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncIterator"));
52
+
53
+ var _core = require("@loaders.gl/core");
54
+
55
+ var _json = require("@loaders.gl/json");
56
+
57
+ var _csv = require("@loaders.gl/csv");
58
+
59
+ var _dataProcessor = require("./data-processor");
60
+
61
+ var _utils = require("@kepler.gl/utils");
62
+
63
+ var _constants = require("@kepler.gl/constants");
64
+
65
+ 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; }
66
+
67
+ 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; }
68
+
69
+ var BATCH_TYPE = {
70
+ METADATA: 'metadata',
71
+ PARTIAL_RESULT: 'partial-result',
72
+ FINAL_RESULT: 'final-result'
73
+ };
74
+ var CSV_LOADER_OPTIONS = {
75
+ shape: 'object-row-table',
76
+ dynamicTyping: false // not working for now
77
+
78
+ };
79
+ var JSON_LOADER_OPTIONS = {
80
+ shape: 'object-row-table',
81
+ // instruct loaders.gl on what json paths to stream
82
+ jsonpaths: ['$', // JSON Row array
83
+ '$.features', // GeoJSON
84
+ '$.datasets' // KeplerGL JSON
85
+ ]
86
+ };
87
+
88
+ function isGeoJson(json) {
89
+ // json can be feature collection
90
+ // or single feature
91
+ return (0, _utils.isPlainObject)(json) && (isFeature(json) || isFeatureCollection(json));
92
+ }
93
+
94
+ function isFeature(json) {
95
+ return (0, _utils.isPlainObject)(json) && json.type === 'Feature' && Boolean(json.geometry);
96
+ }
97
+
98
+ function isFeatureCollection(json) {
99
+ return (0, _utils.isPlainObject)(json) && json.type === 'FeatureCollection' && Boolean(json.features);
100
+ }
101
+
102
+ function isRowObject(json) {
103
+ return Array.isArray(json) && (0, _utils.isPlainObject)(json[0]);
104
+ }
105
+
106
+ function isKeplerGlMap(json) {
107
+ return Boolean((0, _utils.isPlainObject)(json) && json.datasets && json.config && json.info && (0, _utils.isPlainObject)(json.info) && json.info.app === 'kepler.gl');
108
+ }
109
+
110
+ function makeProgressIterator(_x, _x2) {
111
+ return _makeProgressIterator.apply(this, arguments);
112
+ } // eslint-disable-next-line complexity
113
+
114
+
115
+ function _makeProgressIterator() {
116
+ _makeProgressIterator = (0, _wrapAsyncGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee(asyncIterator, info) {
117
+ var rowCount, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, batch, rowCountInBatch, percent, progress;
118
+
119
+ return _regenerator["default"].wrap(function _callee$(_context) {
120
+ while (1) {
121
+ switch (_context.prev = _context.next) {
122
+ case 0:
123
+ rowCount = 0;
124
+ _iteratorNormalCompletion = true;
125
+ _didIteratorError = false;
126
+ _context.prev = 3;
127
+ _iterator = (0, _asyncIterator2["default"])(asyncIterator);
128
+
129
+ case 5:
130
+ _context.next = 7;
131
+ return (0, _awaitAsyncGenerator2["default"])(_iterator.next());
132
+
133
+ case 7:
134
+ _step = _context.sent;
135
+ _iteratorNormalCompletion = _step.done;
136
+ _context.next = 11;
137
+ return (0, _awaitAsyncGenerator2["default"])(_step.value);
138
+
139
+ case 11:
140
+ _value = _context.sent;
141
+
142
+ if (_iteratorNormalCompletion) {
143
+ _context.next = 23;
144
+ break;
145
+ }
146
+
147
+ batch = _value;
148
+ rowCountInBatch = batch.data && batch.data.length || 0;
149
+ rowCount += rowCountInBatch;
150
+ percent = Number.isFinite(batch.bytesUsed) ? batch.bytesUsed / info.size : null; // Update progress object
151
+
152
+ progress = _objectSpread({
153
+ rowCount: rowCount,
154
+ rowCountInBatch: rowCountInBatch
155
+ }, Number.isFinite(percent) ? {
156
+ percent: percent
157
+ } : {});
158
+ _context.next = 20;
159
+ return _objectSpread(_objectSpread({}, batch), {}, {
160
+ progress: progress
161
+ });
162
+
163
+ case 20:
164
+ _iteratorNormalCompletion = true;
165
+ _context.next = 5;
166
+ break;
167
+
168
+ case 23:
169
+ _context.next = 29;
170
+ break;
171
+
172
+ case 25:
173
+ _context.prev = 25;
174
+ _context.t0 = _context["catch"](3);
175
+ _didIteratorError = true;
176
+ _iteratorError = _context.t0;
177
+
178
+ case 29:
179
+ _context.prev = 29;
180
+ _context.prev = 30;
181
+
182
+ if (!(!_iteratorNormalCompletion && _iterator["return"] != null)) {
183
+ _context.next = 34;
184
+ break;
185
+ }
186
+
187
+ _context.next = 34;
188
+ return (0, _awaitAsyncGenerator2["default"])(_iterator["return"]());
189
+
190
+ case 34:
191
+ _context.prev = 34;
192
+
193
+ if (!_didIteratorError) {
194
+ _context.next = 37;
195
+ break;
196
+ }
197
+
198
+ throw _iteratorError;
199
+
200
+ case 37:
201
+ return _context.finish(34);
202
+
203
+ case 38:
204
+ return _context.finish(29);
205
+
206
+ case 39:
207
+ case "end":
208
+ return _context.stop();
209
+ }
210
+ }
211
+ }, _callee, null, [[3, 25, 29, 39], [30,, 34, 38]]);
212
+ }));
213
+ return _makeProgressIterator.apply(this, arguments);
214
+ }
215
+
216
+ function readBatch(_x3, _x4) {
217
+ return _readBatch.apply(this, arguments);
218
+ }
219
+
220
+ function _readBatch() {
221
+ _readBatch = (0, _wrapAsyncGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee2(asyncIterator, fileName) {
222
+ var result, batches, _iteratorNormalCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, _value2, batch, streamingPath, i;
223
+
224
+ return _regenerator["default"].wrap(function _callee2$(_context2) {
225
+ while (1) {
226
+ switch (_context2.prev = _context2.next) {
227
+ case 0:
228
+ result = null;
229
+ batches = [];
230
+ _iteratorNormalCompletion2 = true;
231
+ _didIteratorError2 = false;
232
+ _context2.prev = 4;
233
+ _iterator2 = (0, _asyncIterator2["default"])(asyncIterator);
234
+
235
+ case 6:
236
+ _context2.next = 8;
237
+ return (0, _awaitAsyncGenerator2["default"])(_iterator2.next());
238
+
239
+ case 8:
240
+ _step2 = _context2.sent;
241
+ _iteratorNormalCompletion2 = _step2.done;
242
+ _context2.next = 12;
243
+ return (0, _awaitAsyncGenerator2["default"])(_step2.value);
244
+
245
+ case 12:
246
+ _value2 = _context2.sent;
247
+
248
+ if (_iteratorNormalCompletion2) {
249
+ _context2.next = 21;
250
+ break;
251
+ }
252
+
253
+ batch = _value2;
254
+
255
+ // Last batch will have this special type and will provide all the root
256
+ // properties of the parsed document.
257
+ // Only json parse will have `FINAL_RESULT`
258
+ if (batch.batchType === BATCH_TYPE.FINAL_RESULT) {
259
+ if (batch.container) {
260
+ result = _objectSpread({}, batch.container);
261
+ } // Set the streamed data correctly is Batch json path is set
262
+ // and the path streamed is not the top level object (jsonpath = '$')
263
+
264
+
265
+ if (batch.jsonpath && batch.jsonpath.length > 1) {
266
+ streamingPath = new _json._JSONPath(batch.jsonpath);
267
+ streamingPath.setFieldAtPath(result, batches);
268
+ } else if (batch.jsonpath && batch.jsonpath.length === 1) {
269
+ // The streamed object is a ROW JSON-batch (jsonpath = '$')
270
+ // row objects
271
+ result = batches;
272
+ }
273
+ } else {
274
+ for (i = 0; i < batch.data.length; i++) {
275
+ batches.push(batch.data[i]);
276
+ }
277
+ }
278
+
279
+ _context2.next = 18;
280
+ return _objectSpread(_objectSpread(_objectSpread({}, batch), batch.schema ? {
281
+ headers: Object.keys(batch.schema)
282
+ } : {}), {}, {
283
+ fileName: fileName,
284
+ // if dataset is CSV, data is set to the raw batches
285
+ data: result ? result : batches
286
+ });
287
+
288
+ case 18:
289
+ _iteratorNormalCompletion2 = true;
290
+ _context2.next = 6;
291
+ break;
292
+
293
+ case 21:
294
+ _context2.next = 27;
295
+ break;
296
+
297
+ case 23:
298
+ _context2.prev = 23;
299
+ _context2.t0 = _context2["catch"](4);
300
+ _didIteratorError2 = true;
301
+ _iteratorError2 = _context2.t0;
302
+
303
+ case 27:
304
+ _context2.prev = 27;
305
+ _context2.prev = 28;
306
+
307
+ if (!(!_iteratorNormalCompletion2 && _iterator2["return"] != null)) {
308
+ _context2.next = 32;
309
+ break;
310
+ }
311
+
312
+ _context2.next = 32;
313
+ return (0, _awaitAsyncGenerator2["default"])(_iterator2["return"]());
314
+
315
+ case 32:
316
+ _context2.prev = 32;
317
+
318
+ if (!_didIteratorError2) {
319
+ _context2.next = 35;
320
+ break;
321
+ }
322
+
323
+ throw _iteratorError2;
324
+
325
+ case 35:
326
+ return _context2.finish(32);
327
+
328
+ case 36:
329
+ return _context2.finish(27);
330
+
331
+ case 37:
332
+ case "end":
333
+ return _context2.stop();
334
+ }
335
+ }
336
+ }, _callee2, null, [[4, 23, 27, 37], [28,, 32, 36]]);
337
+ }));
338
+ return _readBatch.apply(this, arguments);
339
+ }
340
+
341
+ function readFileInBatches(_x5) {
342
+ return _readFileInBatches.apply(this, arguments);
343
+ }
344
+
345
+ function _readFileInBatches() {
346
+ _readFileInBatches = (0, _asyncToGenerator2["default"])( /*#__PURE__*/_regenerator["default"].mark(function _callee3(_ref) {
347
+ var file, _ref$loaders, loaders, _ref$loadOptions, loadOptions, batchIterator, progressIterator;
348
+
349
+ return _regenerator["default"].wrap(function _callee3$(_context3) {
350
+ while (1) {
351
+ switch (_context3.prev = _context3.next) {
352
+ case 0:
353
+ file = _ref.file, _ref$loaders = _ref.loaders, loaders = _ref$loaders === void 0 ? [] : _ref$loaders, _ref$loadOptions = _ref.loadOptions, loadOptions = _ref$loadOptions === void 0 ? {} : _ref$loadOptions;
354
+ loaders = [_json.JSONLoader, _csv.CSVLoader].concat((0, _toConsumableArray2["default"])(loaders));
355
+ loadOptions = _objectSpread({
356
+ csv: CSV_LOADER_OPTIONS,
357
+ json: JSON_LOADER_OPTIONS,
358
+ metadata: true
359
+ }, loadOptions);
360
+ _context3.next = 5;
361
+ return (0, _core.parseInBatches)(file, loaders, loadOptions);
362
+
363
+ case 5:
364
+ batchIterator = _context3.sent;
365
+ progressIterator = makeProgressIterator(batchIterator, {
366
+ size: file.size
367
+ });
368
+ return _context3.abrupt("return", readBatch(progressIterator, file.name));
369
+
370
+ case 8:
371
+ case "end":
372
+ return _context3.stop();
373
+ }
374
+ }
375
+ }, _callee3);
376
+ }));
377
+ return _readFileInBatches.apply(this, arguments);
378
+ }
379
+
380
+ function processFileData(_ref2) {
381
+ var content = _ref2.content,
382
+ fileCache = _ref2.fileCache;
383
+ return new Promise(function (resolve, reject) {
384
+ var data = content.data;
385
+ var format;
386
+ var processor;
387
+
388
+ if (isKeplerGlMap(data)) {
389
+ format = _constants.DATASET_FORMATS.keplergl;
390
+ processor = _dataProcessor.processKeplerglJSON;
391
+ } else if (isRowObject(data)) {
392
+ format = _constants.DATASET_FORMATS.row;
393
+ processor = _dataProcessor.processRowObject;
394
+ } else if (isGeoJson(data)) {
395
+ format = _constants.DATASET_FORMATS.geojson;
396
+ processor = _dataProcessor.processGeojson;
397
+ }
398
+
399
+ if (format && processor) {
400
+ var result = processor(data);
401
+ resolve([].concat((0, _toConsumableArray2["default"])(fileCache), [{
402
+ data: result,
403
+ info: {
404
+ label: content.fileName,
405
+ format: format
406
+ }
407
+ }]));
408
+ }
409
+
410
+ reject('Unknown File Format');
411
+ });
412
+ }
413
+
414
+ function filesToDataPayload(fileCache) {
415
+ // seperate out files which could be a single datasets. or a keplergl map json
416
+ var collection = fileCache.reduce(function (accu, file) {
417
+ var data = file.data,
418
+ info = file.info;
419
+
420
+ if ((info === null || info === void 0 ? void 0 : info.format) === _constants.DATASET_FORMATS.keplergl) {
421
+ // if file contains a single kepler map dataset & config
422
+ accu.keplerMaps.push(_objectSpread(_objectSpread({}, data), {}, {
423
+ options: {
424
+ centerMap: !(data.config && data.config.mapState)
425
+ }
426
+ }));
427
+ } else if (_constants.DATASET_FORMATS[info === null || info === void 0 ? void 0 : info.format]) {
428
+ // if file contains only data
429
+ var newDataset = {
430
+ data: data,
431
+ info: _objectSpread({
432
+ id: (info === null || info === void 0 ? void 0 : info.id) || (0, _utils.generateHashId)(4)
433
+ }, info || {})
434
+ };
435
+ accu.datasets.push(newDataset);
436
+ }
437
+
438
+ return accu;
439
+ }, {
440
+ datasets: [],
441
+ keplerMaps: []
442
+ }); // add kepler map first with config
443
+ // add datasets later in one add data call
444
+
445
+ return collection.keplerMaps.concat({
446
+ datasets: collection.datasets
447
+ });
448
+ }
449
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../src/file-handler.ts"],"names":["BATCH_TYPE","METADATA","PARTIAL_RESULT","FINAL_RESULT","CSV_LOADER_OPTIONS","shape","dynamicTyping","JSON_LOADER_OPTIONS","jsonpaths","isGeoJson","json","isFeature","isFeatureCollection","type","Boolean","geometry","features","isRowObject","Array","isArray","isKeplerGlMap","datasets","config","info","app","makeProgressIterator","asyncIterator","rowCount","batch","rowCountInBatch","data","length","percent","Number","isFinite","bytesUsed","size","progress","readBatch","fileName","result","batches","batchType","container","jsonpath","streamingPath","_JSONPath","setFieldAtPath","i","push","schema","headers","Object","keys","readFileInBatches","file","loaders","loadOptions","JSONLoader","CSVLoader","csv","metadata","batchIterator","progressIterator","name","processFileData","content","fileCache","Promise","resolve","reject","format","processor","DATASET_FORMATS","keplergl","processKeplerglJSON","row","processRowObject","geojson","processGeojson","label","filesToDataPayload","collection","reduce","accu","keplerMaps","options","centerMap","mapState","newDataset","id","concat"],"mappings":"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","sourcesContent":["// Copyright (c) 2022 Uber Technologies, Inc.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\nimport {parseInBatches} from '@loaders.gl/core';\nimport {JSONLoader, _JSONPath} from '@loaders.gl/json';\nimport {CSVLoader} from '@loaders.gl/csv';\nimport {processGeojson, processKeplerglJSON, processRowObject} from './data-processor';\nimport {generateHashId, isPlainObject} from '@kepler.gl/utils';\nimport {DATASET_FORMATS} from '@kepler.gl/constants';\nimport {Loader} from '@loaders.gl/loader-utils';\nimport {FileCacheItem, ValidKeplerGlMap} from './types';\nimport {Feature, AddDataToMapPayload} from '@kepler.gl/types';\nimport {FeatureCollection} from '@turf/helpers';\n\nconst BATCH_TYPE = {\n  METADATA: 'metadata',\n  PARTIAL_RESULT: 'partial-result',\n  FINAL_RESULT: 'final-result'\n};\n\nconst CSV_LOADER_OPTIONS = {\n  shape: 'object-row-table',\n  dynamicTyping: false // not working for now\n};\n\nconst JSON_LOADER_OPTIONS = {\n  shape: 'object-row-table',\n  // instruct loaders.gl on what json paths to stream\n  jsonpaths: [\n    '$', // JSON Row array\n    '$.features', // GeoJSON\n    '$.datasets' // KeplerGL JSON\n  ]\n};\n\nexport function isGeoJson(json: unknown): json is Feature | FeatureCollection {\n  // json can be feature collection\n  // or single feature\n  return isPlainObject(json) && (isFeature(json) || isFeatureCollection(json));\n}\n\nexport function isFeature(json: unknown): json is Feature {\n  return isPlainObject(json) && json.type === 'Feature' && Boolean(json.geometry);\n}\n\nexport function isFeatureCollection(json: unknown): json is FeatureCollection {\n  return isPlainObject(json) && json.type === 'FeatureCollection' && Boolean(json.features);\n}\n\nexport function isRowObject(json: any): boolean {\n  return Array.isArray(json) && isPlainObject(json[0]);\n}\n\nexport function isKeplerGlMap(json: unknown): json is ValidKeplerGlMap {\n  return Boolean(\n    isPlainObject(json) &&\n      json.datasets &&\n      json.config &&\n      json.info &&\n      isPlainObject(json.info) &&\n      json.info.app === 'kepler.gl'\n  );\n}\n\nexport async function* makeProgressIterator(\n  asyncIterator: AsyncIterable<any>,\n  info: {size: number}\n): AsyncGenerator {\n  let rowCount = 0;\n\n  for await (const batch of asyncIterator) {\n    const rowCountInBatch = (batch.data && batch.data.length) || 0;\n    rowCount += rowCountInBatch;\n    const percent = Number.isFinite(batch.bytesUsed) ? batch.bytesUsed / info.size : null;\n\n    // Update progress object\n    const progress = {\n      rowCount,\n      rowCountInBatch,\n      ...(Number.isFinite(percent) ? {percent} : {})\n    };\n\n    yield {...batch, progress};\n  }\n}\n\n// eslint-disable-next-line complexity\nexport async function* readBatch(\n  asyncIterator: AsyncIterable<any>,\n  fileName: string\n): AsyncGenerator {\n  let result = null;\n  const batches = <any>[];\n\n  for await (const batch of asyncIterator) {\n    // Last batch will have this special type and will provide all the root\n    // properties of the parsed document.\n    // Only json parse will have `FINAL_RESULT`\n    if (batch.batchType === BATCH_TYPE.FINAL_RESULT) {\n      if (batch.container) {\n        result = {...batch.container};\n      }\n      // Set the streamed data correctly is Batch json path is set\n      // and the path streamed is not the top level object (jsonpath = '$')\n      if (batch.jsonpath && batch.jsonpath.length > 1) {\n        const streamingPath = new _JSONPath(batch.jsonpath);\n        streamingPath.setFieldAtPath(result, batches);\n      } else if (batch.jsonpath && batch.jsonpath.length === 1) {\n        // The streamed object is a ROW JSON-batch (jsonpath = '$')\n        // row objects\n        result = batches;\n      }\n    } else {\n      for (let i = 0; i < batch.data.length; i++) {\n        batches.push(batch.data[i]);\n      }\n    }\n\n    yield {\n      ...batch,\n      ...(batch.schema ? {headers: Object.keys(batch.schema)} : {}),\n      fileName,\n      // if dataset is CSV, data is set to the raw batches\n      data: result ? result : batches\n    };\n  }\n}\n\nexport async function readFileInBatches({\n  file,\n  loaders = [],\n  loadOptions = {}\n}: {\n  file: File;\n  fileCache: FileCacheItem[];\n  loaders: Loader[];\n  loadOptions: any;\n}): Promise<AsyncGenerator> {\n  loaders = [JSONLoader, CSVLoader, ...loaders];\n  loadOptions = {\n    csv: CSV_LOADER_OPTIONS,\n    json: JSON_LOADER_OPTIONS,\n    metadata: true,\n    ...loadOptions\n  };\n\n  const batchIterator = await parseInBatches(file, loaders, loadOptions);\n  const progressIterator = makeProgressIterator(batchIterator, {size: file.size});\n\n  return readBatch(progressIterator, file.name);\n}\n\nexport function processFileData({\n  content,\n  fileCache\n}: {\n  content: {data: unknown; fileName: string};\n  fileCache: FileCacheItem[];\n}): Promise<FileCacheItem[]> {\n  return new Promise((resolve, reject) => {\n    const {data} = content;\n\n    let format: string | undefined;\n    let processor: Function | undefined;\n    if (isKeplerGlMap(data)) {\n      format = DATASET_FORMATS.keplergl;\n      processor = processKeplerglJSON;\n    } else if (isRowObject(data)) {\n      format = DATASET_FORMATS.row;\n      processor = processRowObject;\n    } else if (isGeoJson(data)) {\n      format = DATASET_FORMATS.geojson;\n      processor = processGeojson;\n    }\n\n    if (format && processor) {\n      const result = processor(data);\n\n      resolve([\n        ...fileCache,\n        {\n          data: result,\n          info: {\n            label: content.fileName,\n            format\n          }\n        }\n      ]);\n    }\n\n    reject('Unknown File Format');\n  });\n}\n\nexport function filesToDataPayload(fileCache: FileCacheItem[]): AddDataToMapPayload[] {\n  // seperate out files which could be a single datasets. or a keplergl map json\n  const collection = fileCache.reduce<{\n    datasets: FileCacheItem[];\n    keplerMaps: AddDataToMapPayload[];\n  }>(\n    (accu, file) => {\n      const {data, info} = file;\n      if (info?.format === DATASET_FORMATS.keplergl) {\n        // if file contains a single kepler map dataset & config\n        accu.keplerMaps.push({\n          ...data,\n          options: {\n            centerMap: !(data.config && data.config.mapState)\n          }\n        });\n      } else if (DATASET_FORMATS[info?.format]) {\n        // if file contains only data\n        const newDataset = {\n          data,\n          info: {\n            id: info?.id || generateHashId(4),\n            ...(info || {})\n          }\n        };\n        accu.datasets.push(newDataset);\n      }\n      return accu;\n    },\n    {datasets: [], keplerMaps: []}\n  );\n\n  // add kepler map first with config\n  // add datasets later in one add data call\n  return collection.keplerMaps.concat({datasets: collection.datasets});\n}\n"]}
@@ -0,0 +1,3 @@
1
+ export * from './data-processor';
2
+ export * from './file-handler';
3
+ export * from './types';
package/dist/index.js ADDED
@@ -0,0 +1,65 @@
1
+ // Copyright (c) 2022 Uber Technologies, Inc.
2
+ //
3
+ // Permission is hereby granted, free of charge, to any person obtaining a copy
4
+ // of this software and associated documentation files (the "Software"), to deal
5
+ // in the Software without restriction, including without limitation the rights
6
+ // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7
+ // copies of the Software, and to permit persons to whom the Software is
8
+ // furnished to do so, subject to the following conditions:
9
+ //
10
+ // The above copyright notice and this permission notice shall be included in
11
+ // all copies or substantial portions of the Software.
12
+ //
13
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14
+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15
+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16
+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17
+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19
+ // THE SOFTWARE.
20
+
21
+ "use strict";
22
+
23
+ Object.defineProperty(exports, "__esModule", {
24
+ value: true
25
+ });
26
+
27
+ var _dataProcessor = require("./data-processor");
28
+
29
+ Object.keys(_dataProcessor).forEach(function (key) {
30
+ if (key === "default" || key === "__esModule") return;
31
+ if (key in exports && exports[key] === _dataProcessor[key]) return;
32
+ Object.defineProperty(exports, key, {
33
+ enumerable: true,
34
+ get: function get() {
35
+ return _dataProcessor[key];
36
+ }
37
+ });
38
+ });
39
+
40
+ var _fileHandler = require("./file-handler");
41
+
42
+ Object.keys(_fileHandler).forEach(function (key) {
43
+ if (key === "default" || key === "__esModule") return;
44
+ if (key in exports && exports[key] === _fileHandler[key]) return;
45
+ Object.defineProperty(exports, key, {
46
+ enumerable: true,
47
+ get: function get() {
48
+ return _fileHandler[key];
49
+ }
50
+ });
51
+ });
52
+
53
+ var _types = require("./types");
54
+
55
+ Object.keys(_types).forEach(function (key) {
56
+ if (key === "default" || key === "__esModule") return;
57
+ if (key in exports && exports[key] === _types[key]) return;
58
+ Object.defineProperty(exports, key, {
59
+ enumerable: true,
60
+ get: function get() {
61
+ return _types[key];
62
+ }
63
+ });
64
+ });
65
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,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
@@ -0,0 +1,13 @@
1
+ export declare type FileCacheItem = {
2
+ data: any;
3
+ info: {
4
+ id?: string;
5
+ label: string;
6
+ format: string;
7
+ };
8
+ };
9
+ export declare type ValidKeplerGlMap = {
10
+ datasets: unknown;
11
+ config: unknown;
12
+ info: Record<string, string>;
13
+ };
package/dist/types.js ADDED
@@ -0,0 +1,26 @@
1
+ // Copyright (c) 2022 Uber Technologies, Inc.
2
+ //
3
+ // Permission is hereby granted, free of charge, to any person obtaining a copy
4
+ // of this software and associated documentation files (the "Software"), to deal
5
+ // in the Software without restriction, including without limitation the rights
6
+ // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7
+ // copies of the Software, and to permit persons to whom the Software is
8
+ // furnished to do so, subject to the following conditions:
9
+ //
10
+ // The above copyright notice and this permission notice shall be included in
11
+ // all copies or substantial portions of the Software.
12
+ //
13
+ // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14
+ // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15
+ // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16
+ // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17
+ // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18
+ // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19
+ // THE SOFTWARE.
20
+
21
+ "use strict";
22
+
23
+ Object.defineProperty(exports, "__esModule", {
24
+ value: true
25
+ });
26
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=
package/package.json ADDED
@@ -0,0 +1,62 @@
1
+ {
2
+ "name": "@kepler.gl/processors",
3
+ "author": "Shan He <shan@uber.com>",
4
+ "version": "3.0.0-alpha.0",
5
+ "description": "kepler.gl constants used by kepler.gl components, actions and reducers",
6
+ "license": "MIT",
7
+ "main": "dist/index.js",
8
+ "types": "dist/index.d.ts",
9
+ "keywords": [
10
+ "babel",
11
+ "es6",
12
+ "react",
13
+ "webgl",
14
+ "visualization",
15
+ "deck.gl"
16
+ ],
17
+ "repository": {
18
+ "type": "git",
19
+ "url": "https://github.com/keplergl/kepler.gl.git"
20
+ },
21
+ "scripts": {
22
+ "build": "rm -fr dist && babel src --out-dir dist --source-maps inline --extensions '.ts,.tsx,.js,.jsx' --ignore '**/*.d.ts'",
23
+ "build:umd": "webpack --config ./webpack/umd.js --progress --env.prod",
24
+ "build:types": "tsc --project ./tsconfig.production.json",
25
+ "prepublish": "uber-licence && yarn build && yarn build:types",
26
+ "stab": "mkdir -p dist && touch dist/index.js"
27
+ },
28
+ "files": [
29
+ "dist",
30
+ "umd"
31
+ ],
32
+ "dependencies": {
33
+ "@danmarshall/deckgl-typings": "4.9.22",
34
+ "@kepler.gl/constants": "3.0.0-alpha.0",
35
+ "@kepler.gl/schemas": "3.0.0-alpha.0",
36
+ "@kepler.gl/types": "3.0.0-alpha.0",
37
+ "@kepler.gl/utils": "3.0.0-alpha.0",
38
+ "@loaders.gl/core": "^3.0.9",
39
+ "@loaders.gl/csv": "^3.0.9",
40
+ "@loaders.gl/json": "^3.0.9",
41
+ "@loaders.gl/loader-utils": "^3.0.9",
42
+ "@mapbox/geojson-normalize": "0.0.1",
43
+ "@nebula.gl/edit-modes": "0.14.0",
44
+ "@turf/helpers": "^6.1.4",
45
+ "d3-dsv": "^2.0.0"
46
+ },
47
+ "nyc": {
48
+ "sourceMap": false,
49
+ "instrument": false
50
+ },
51
+ "engines": {
52
+ "node": ">=12.0.0"
53
+ },
54
+ "maintainers": [
55
+ "Shan He <heshan0131@gmail.com>",
56
+ "Giuseppe Macri <gmacri@uber.com>"
57
+ ],
58
+ "volta": {
59
+ "node": "12.22.0",
60
+ "yarn": "1.22.17"
61
+ }
62
+ }