@kepler.gl/processors 3.3.0-alpha.2 → 3.3.0-alpha.20

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.
Files changed (50) hide show
  1. package/dist/cjs/data-processor.js +719 -0
  2. package/dist/cjs/export/dataset-to-geojson.js +138 -0
  3. package/dist/cjs/export/geopackage-writer.js +385 -0
  4. package/dist/cjs/export/geoparquet-writer.js +351 -0
  5. package/dist/cjs/export/kml-writer.js +347 -0
  6. package/dist/cjs/export/shapefile-writer.js +708 -0
  7. package/dist/cjs/export/sql-js.js +95 -0
  8. package/dist/cjs/export/vector-export.js +187 -0
  9. package/dist/cjs/file-handler.js +997 -0
  10. package/dist/cjs/index.js +114 -0
  11. package/dist/cjs/kepler-csv-loader.js +163 -0
  12. package/dist/cjs/loader-registry.js +542 -0
  13. package/dist/cjs/remote-file.js +675 -0
  14. package/dist/cjs/shapefile-files.js +281 -0
  15. package/dist/cjs/types.js +6 -0
  16. package/dist/data-processor.d.ts +30 -16
  17. package/dist/esm/data-processor.js +700 -0
  18. package/dist/esm/export/dataset-to-geojson.js +132 -0
  19. package/dist/esm/export/geopackage-writer.js +381 -0
  20. package/dist/esm/export/geoparquet-writer.js +336 -0
  21. package/dist/esm/export/kml-writer.js +341 -0
  22. package/dist/esm/export/shapefile-writer.js +701 -0
  23. package/dist/esm/export/sql-js.js +80 -0
  24. package/dist/esm/export/vector-export.js +176 -0
  25. package/dist/esm/file-handler.js +972 -0
  26. package/dist/esm/index.js +12 -0
  27. package/dist/esm/kepler-csv-loader.js +152 -0
  28. package/dist/esm/loader-registry.js +510 -0
  29. package/dist/esm/remote-file.js +664 -0
  30. package/dist/esm/shapefile-files.js +264 -0
  31. package/dist/esm/types.js +3 -0
  32. package/dist/export/dataset-to-geojson.d.ts +12 -0
  33. package/dist/export/geopackage-writer.d.ts +28 -0
  34. package/dist/export/geoparquet-writer.d.ts +7 -0
  35. package/dist/export/kml-writer.d.ts +13 -0
  36. package/dist/export/shapefile-writer.d.ts +28 -0
  37. package/dist/export/sql-js.d.ts +8 -0
  38. package/dist/export/vector-export.d.ts +22 -0
  39. package/dist/file-handler.d.ts +55 -8
  40. package/dist/index.d.ts +6 -0
  41. package/dist/kepler-csv-loader.d.ts +12 -0
  42. package/dist/loader-registry.d.ts +29 -0
  43. package/dist/remote-file.d.ts +79 -0
  44. package/dist/shapefile-files.d.ts +39 -0
  45. package/dist/types.d.ts +13 -0
  46. package/package.json +35 -17
  47. package/dist/data-processor.js +0 -637
  48. package/dist/file-handler.js +0 -409
  49. package/dist/index.js +0 -39
  50. package/dist/types.js +0 -6
@@ -0,0 +1,719 @@
1
+ "use strict";
2
+
3
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
4
+ var _typeof3 = 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.detectDelimiter = detectDelimiter;
11
+ exports.getGeoArrowMetadataFromSchema = getGeoArrowMetadataFromSchema;
12
+ exports.parseCsvRowsByFieldType = parseCsvRowsByFieldType;
13
+ exports.parseRowsByFields = parseRowsByFields;
14
+ exports.processArrowBatches = processArrowBatches;
15
+ exports.processArrowTable = processArrowTable;
16
+ exports.processCsvData = processCsvData;
17
+ exports.processGeojson = processGeojson;
18
+ exports.processKeplerglDataset = processKeplerglDataset;
19
+ exports.processKeplerglJSON = processKeplerglJSON;
20
+ exports.processRowObject = processRowObject;
21
+ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
22
+ var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
23
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
24
+ var arrow = _interopRequireWildcard(require("apache-arrow"));
25
+ var _d3Dsv = require("d3-dsv");
26
+ var _typeAnalyzer = require("type-analyzer");
27
+ var _geojsonNormalize = _interopRequireDefault(require("@mapbox/geojson-normalize"));
28
+ var _core = require("@loaders.gl/core");
29
+ var _wkt = require("@loaders.gl/wkt");
30
+ var _constants = require("@kepler.gl/constants");
31
+ var _utils = require("@kepler.gl/utils");
32
+ var _commonUtils = require("@kepler.gl/common-utils");
33
+ var _schemas = require("@kepler.gl/schemas");
34
+ function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function _interopRequireWildcard(e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, "default": e }; if (null === e || "object" != _typeof3(e) && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (var _t in e) "default" !== _t && {}.hasOwnProperty.call(e, _t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, _t)) && (i.get || i.set) ? o(f, _t, i) : f[_t] = e[_t]); return f; })(e, t); }
35
+ 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; }
36
+ 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; }
37
+ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
38
+ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
39
+ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; } // SPDX-License-Identifier: MIT
40
+ // Copyright contributors to the kepler.gl project
41
+ // if any of these value occurs in csv, parse it to null;
42
+ // const CSV_NULLS = ['', 'null', 'NULL', 'Null', 'NaN', '/N'];
43
+ // matches empty string
44
+ var CSV_NULLS = exports.CSV_NULLS = /^(null|NULL|Null|NaN|\/N||)$/;
45
+ var SUPPORTED_DELIMITERS = [',', '\t', ';', '|'];
46
+ function getRowParser(delimiter) {
47
+ if (delimiter === ',') return _d3Dsv.csvParseRows;
48
+ if (delimiter === '\t') return _d3Dsv.tsvParseRows;
49
+ return (0, _d3Dsv.dsvFormat)(delimiter).parseRows;
50
+ }
51
+
52
+ /**
53
+ * Detect the delimiter used in a DSV string by checking the first line.
54
+ * Returns the delimiter that produces the most columns (minimum 2).
55
+ * Falls back to comma if no delimiter produces multiple columns.
56
+ */
57
+ function detectDelimiter(rawData) {
58
+ var newlineIdx = rawData.indexOf('\n');
59
+ var firstLine = newlineIdx === -1 ? rawData : rawData.slice(0, newlineIdx);
60
+ if (!firstLine) return ',';
61
+ var bestDelimiter = ',';
62
+ var bestCount = 1;
63
+ var _iterator = _createForOfIteratorHelper(SUPPORTED_DELIMITERS),
64
+ _step;
65
+ try {
66
+ for (_iterator.s(); !(_step = _iterator.n()).done;) {
67
+ var _parsed$;
68
+ var delimiter = _step.value;
69
+ var parsed = getRowParser(delimiter)(firstLine);
70
+ var count = ((_parsed$ = parsed[0]) === null || _parsed$ === void 0 ? void 0 : _parsed$.length) || 0;
71
+ if (count > bestCount) {
72
+ bestCount = count;
73
+ bestDelimiter = delimiter;
74
+ }
75
+ }
76
+ } catch (err) {
77
+ _iterator.e(err);
78
+ } finally {
79
+ _iterator.f();
80
+ }
81
+ return bestDelimiter;
82
+ }
83
+ function tryParseJsonString(str) {
84
+ try {
85
+ return JSON.parse(str);
86
+ } catch (e) {
87
+ return null;
88
+ }
89
+ }
90
+ 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"], {
91
+ valid: function valid(d) {
92
+ return typeof d === 'boolean';
93
+ },
94
+ parse: function parse(d) {
95
+ var s = String(d).toLowerCase();
96
+ return s === 'true' || s === 'yes' || s === '1';
97
+ }
98
+ }), _constants.ALL_FIELD_TYPES.integer, {
99
+ // @ts-ignore
100
+ valid: function valid(d) {
101
+ return parseInt(d, 10) === d;
102
+ },
103
+ // @ts-ignore
104
+ parse: function parse(d) {
105
+ return parseInt(d, 10);
106
+ }
107
+ }), _constants.ALL_FIELD_TYPES.timestamp, {
108
+ valid: function valid(d, field) {
109
+ return ['x', 'X'].includes(field.format) ? typeof d === 'number' : typeof d === 'string';
110
+ },
111
+ parse: function parse(d, field) {
112
+ return ['x', 'X'].includes(field.format) ? Number(d) : d;
113
+ }
114
+ }), _constants.ALL_FIELD_TYPES.real, {
115
+ // @ts-ignore
116
+ valid: function valid(d) {
117
+ return parseFloat(d) === d;
118
+ },
119
+ // Note this will result in NaN for some string
120
+ parse: parseFloat
121
+ }), _constants.ALL_FIELD_TYPES.object, {
122
+ valid: _utils.isPlainObject,
123
+ parse: tryParseJsonString
124
+ }), _constants.ALL_FIELD_TYPES.array, {
125
+ valid: Array.isArray,
126
+ parse: tryParseJsonString
127
+ }), _constants.ALL_FIELD_TYPES.h3, {
128
+ valid: function valid(d) {
129
+ return (0, _commonUtils.h3IsValid)(d);
130
+ },
131
+ parse: function parse(d) {
132
+ return d;
133
+ }
134
+ });
135
+
136
+ /**
137
+ * Process csv data, output a data object with `{fields: [], rows: []}`.
138
+ * The data object can be wrapped in a `dataset` and pass to [`addDataToMap`](../actions/actions.md#adddatatomap)
139
+ * @param rawData raw csv string
140
+ * @returns data object `{fields: [], rows: []}` can be passed to addDataToMaps
141
+ * @public
142
+ * @example
143
+ * import {processCsvData} from '@kepler.gl/processors';
144
+ *
145
+ * 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
146
+ * 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
147
+ * 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
148
+ * 2016-09-17 00:11:56,29.9907261,31.2312742,driver_analytics,1472688000000,False,3,2016-09-23T00:00:00.000Z,,,2016-09-23
149
+ * 2016-09-17 00:12:58,29.9870074,31.2175827,driver_analytics,1472688000000,False,4,2016-09-23T00:00:00.000Z,,,2016-09-23`
150
+ *
151
+ * const dataset = {
152
+ * info: {id: 'test_data', label: 'My Csv'},
153
+ * data: processCsvData(testData)
154
+ * };
155
+ *
156
+ * dispatch(addDataToMap({
157
+ * datasets: [dataset],
158
+ * options: {centerMap: true, readOnly: true}
159
+ * }));
160
+ */
161
+ function processCsvData(rawData, header) {
162
+ var rows;
163
+ var headerRow;
164
+ if (typeof rawData === 'string') {
165
+ var delimiter = detectDelimiter(rawData);
166
+ var _parsedRows = getRowParser(delimiter)(rawData);
167
+ if (!Array.isArray(_parsedRows) || _parsedRows.length < 2) {
168
+ throw new Error('processCsvData Failed: delimited text is empty or has no data rows');
169
+ }
170
+ headerRow = _parsedRows[0];
171
+ rows = _parsedRows.slice(1);
172
+ } else if (Array.isArray(rawData) && rawData.length) {
173
+ rows = rawData;
174
+ headerRow = header;
175
+ if (!Array.isArray(headerRow)) {
176
+ // if data is passed in as array of rows and missing header
177
+ // assume first row is header
178
+ // @ts-ignore
179
+ headerRow = rawData[0];
180
+ rows = rawData.slice(1);
181
+ }
182
+ }
183
+ if (!rows || !headerRow) {
184
+ throw new Error('invalid input passed to processCsvData');
185
+ }
186
+
187
+ // here we assume the csv file that people uploaded will have first row
188
+ // as name of the column
189
+
190
+ cleanUpFalsyCsvValue(rows);
191
+ // No need to run type detection on every data point
192
+ // here we get a list of none null values to run analyze on
193
+ var sample = (0, _commonUtils.getSampleForTypeAnalyze)({
194
+ fields: headerRow,
195
+ rows: rows
196
+ });
197
+ var fields = (0, _commonUtils.getFieldsFromData)(sample, headerRow);
198
+ var parsedRows = parseRowsByFields(rows, fields);
199
+ return {
200
+ fields: fields,
201
+ rows: parsedRows
202
+ };
203
+ }
204
+
205
+ /**
206
+ * Parse rows of csv by analyzed field types. So that `'1'` -> `1`, `'True'` -> `true`
207
+ * @param rows
208
+ * @param fields
209
+ */
210
+ function parseRowsByFields(rows, fields) {
211
+ // Edit rows in place
212
+ var geojsonFieldIdx = fields.findIndex(function (f) {
213
+ return f.name === '_geojson';
214
+ });
215
+ fields.forEach(parseCsvRowsByFieldType.bind(null, rows, geojsonFieldIdx));
216
+ return rows;
217
+ }
218
+
219
+ /**
220
+ * Convert falsy value in csv including `'', 'null', 'NULL', 'Null', 'NaN'` to `null`,
221
+ * so that type-analyzer won't detect it as string
222
+ *
223
+ * @param rows
224
+ */
225
+ function cleanUpFalsyCsvValue(rows) {
226
+ var re = new RegExp(CSV_NULLS, 'g');
227
+ for (var i = 0; i < rows.length; i++) {
228
+ for (var j = 0; j < rows[i].length; j++) {
229
+ // analyzer will set any fields to 'string' if there are empty values
230
+ // which will be parsed as '' by d3.csv
231
+ // here we parse empty data as null
232
+ // TODO: create warning when deltect `CSV_NULLS` in the data
233
+ if (typeof rows[i][j] === 'string' && rows[i][j].match(re)) {
234
+ rows[i][j] = null;
235
+ }
236
+ }
237
+ }
238
+ }
239
+
240
+ /**
241
+ * Process uploaded csv file to parse value by field type
242
+ *
243
+ * @param rows
244
+ * @param geoFieldIdx field index
245
+ * @param field
246
+ * @param i
247
+ */
248
+ function parseCsvRowsByFieldType(rows, geoFieldIdx, field, i) {
249
+ var parser = PARSE_FIELD_VALUE_FROM_STRING[field.type];
250
+ if (parser) {
251
+ // check first not null value of it's already parsed
252
+ var first = rows.find(function (r) {
253
+ return (0, _commonUtils.notNullorUndefined)(r[i]);
254
+ });
255
+ if (!first || parser.valid(first[i], field)) {
256
+ return;
257
+ }
258
+ rows.forEach(function (row) {
259
+ // parse string value based on field type
260
+ if (row[i] !== null) {
261
+ row[i] = parser.parse(row[i], field);
262
+ if (geoFieldIdx > -1 && (0, _utils.isPlainObject)(row[geoFieldIdx]) &&
263
+ // @ts-ignore
264
+ (0, _utils.hasOwnProperty)(row[geoFieldIdx], 'properties')) {
265
+ // @ts-ignore
266
+ row[geoFieldIdx].properties[field.name] = row[i];
267
+ }
268
+ }
269
+ });
270
+ }
271
+ }
272
+
273
+ /* eslint-enable complexity */
274
+
275
+ /**
276
+ * Process data where each row is an object, output can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
277
+ * NOTE: This function may mutate input.
278
+ * @param rawData an array of row object, each object should have the same number of keys
279
+ * @returns dataset containing `fields` and `rows`
280
+ * @public
281
+ * @example
282
+ * import {addDataToMap} from '@kepler.gl/actions';
283
+ * import {processRowObject} from '@kepler.gl/processors';
284
+ *
285
+ * const data = [
286
+ * {lat: 31.27, lng: 127.56, value: 3},
287
+ * {lat: 31.22, lng: 126.26, value: 1}
288
+ * ];
289
+ *
290
+ * dispatch(addDataToMap({
291
+ * datasets: {
292
+ * info: {label: 'My Data', id: 'my_data'},
293
+ * data: processRowObject(data)
294
+ * }
295
+ * }));
296
+ */
297
+ function processRowObject(rawData) {
298
+ if (!Array.isArray(rawData)) {
299
+ return null;
300
+ } else if (!rawData.length) {
301
+ // data is empty
302
+ return {
303
+ fields: [],
304
+ rows: []
305
+ };
306
+ }
307
+ var firstRow = rawData[0];
308
+ var keys = Object.keys(firstRow); // [lat, lng, value]
309
+ var rows = rawData.map(function (d) {
310
+ return keys.map(function (key) {
311
+ return d[key];
312
+ });
313
+ }); // [[31.27, 127.56, 3]]
314
+
315
+ // row object can still contain values like `Null` or `N/A`
316
+ cleanUpFalsyCsvValue(rows);
317
+ return processCsvData(rows, keys);
318
+ }
319
+ var WGS84_CRS_NAMES = [/^(?:EPSG:4326|OGC:CRS84h?|CRS84h?|WGS ?84)$/i, /^urn:(?:x-)?ogc:def:crs:(?:EPSG:(?:[\d.]*:)?4326|OGC:(?:(?:[\d.]*:)?CRS84h?|2:84))$/i, /^https?:\/\/www\.opengis\.net\/def\/crs\/(?:EPSG\/[\d.]+\/4326|OGC\/[\d.]+\/CRS84h?)$/i, /^https?:\/\/www\.opengis\.net\/gml\/srs\/epsg\.xml#4326$/i];
320
+ function validateGeojsonCrs(rawData) {
321
+ var pending = [rawData];
322
+ var _loop = function _loop() {
323
+ var value = pending.pop();
324
+ if (!(0, _utils.isPlainObject)(value)) return 1; // continue
325
+ var crs = value.crs;
326
+ if ((0, _utils.isPlainObject)(crs) && (0, _utils.isPlainObject)(crs.properties)) {
327
+ var identifier = crs.type === 'name' ? crs.properties.name : crs.type === 'link' ? crs.properties.href : undefined;
328
+ // Preserve existing handling of absent, null, and malformed declarations.
329
+ // Recognize known identifiers without fetching linked CRS definitions.
330
+ if (typeof identifier === 'string' && identifier.trim() && !WGS84_CRS_NAMES.some(function (pattern) {
331
+ return pattern.test(identifier.trim());
332
+ })) {
333
+ throw new Error('Read File Failed: GeoJSON uses an unsupported coordinate reference system. ' + 'Convert coordinates to WGS84 (EPSG:4326) before importing.');
334
+ }
335
+ }
336
+
337
+ // CRS can be declared on collections, features, or their geometries, but a
338
+ // feature property named "crs" is ordinary data and must not be inspected.
339
+ if (value.type === 'Feature') {
340
+ pending.push(value.geometry);
341
+ } else {
342
+ var children = value.type === 'FeatureCollection' ? value.features : value.type === 'GeometryCollection' ? value.geometries : null;
343
+ if (Array.isArray(children)) {
344
+ var _iterator2 = _createForOfIteratorHelper(children),
345
+ _step2;
346
+ try {
347
+ for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
348
+ var child = _step2.value;
349
+ pending.push(child);
350
+ }
351
+ } catch (err) {
352
+ _iterator2.e(err);
353
+ } finally {
354
+ _iterator2.f();
355
+ }
356
+ }
357
+ }
358
+ };
359
+ while (pending.length) {
360
+ if (_loop()) continue;
361
+ }
362
+ }
363
+
364
+ /**
365
+ * Process GeoJSON [`FeatureCollection`](http://wiki.geojson.org/GeoJSON_draft_version_6#FeatureCollection),
366
+ * output a data object with `{fields: [], rows: []}`.
367
+ * The data object can be wrapped in a `dataset` and passed to [`addDataToMap`](../actions/actions.md#adddatatomap)
368
+ * NOTE: This function may mutate input.
369
+ *
370
+ * @param rawData raw geojson feature collection
371
+ * @returns dataset containing `fields` and `rows`
372
+ * @public
373
+ * @example
374
+ * import {addDataToMap} from '@kepler.gl/actions';
375
+ * import {processGeojson} from '@kepler.gl/processors';
376
+ *
377
+ * const geojson = {
378
+ * "type" : "FeatureCollection",
379
+ * "features" : [{
380
+ * "type" : "Feature",
381
+ * "properties" : {
382
+ * "capacity" : "10",
383
+ * "type" : "U-Rack"
384
+ * },
385
+ * "geometry" : {
386
+ * "type" : "Point",
387
+ * "coordinates" : [ -71.073283, 42.417500 ]
388
+ * }
389
+ * }]
390
+ * };
391
+ *
392
+ * dispatch(addDataToMap({
393
+ * datasets: {
394
+ * info: {
395
+ * label: 'Sample Taxi Trips in New York City',
396
+ * id: 'test_trip_data'
397
+ * },
398
+ * data: processGeojson(geojson)
399
+ * }
400
+ * }));
401
+ */
402
+ function processGeojson(rawData) {
403
+ validateGeojsonCrs(rawData);
404
+ var normalizedGeojson = (0, _geojsonNormalize["default"])(rawData);
405
+ if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {
406
+ throw new Error("Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](".concat(_constants.GUIDES_FILE_FORMAT_DOC, ")"));
407
+ }
408
+
409
+ // getting all feature fields
410
+ var allDataRows = [];
411
+ for (var i = 0; i < normalizedGeojson.features.length; i++) {
412
+ var f = normalizedGeojson.features[i];
413
+ if (f.geometry) {
414
+ var row = _objectSpread({
415
+ // Reserve the first field for geometry to preserve existing field indices.
416
+ _geojson: f
417
+ }, f.properties || {});
418
+ // A property with the reserved name must not replace the feature.
419
+ row._geojson = f;
420
+ allDataRows.push(row);
421
+ }
422
+ }
423
+ // get all the field
424
+ var fields = allDataRows.reduce(function (accu, curr) {
425
+ Object.keys(curr).forEach(function (key) {
426
+ if (!accu.includes(key)) {
427
+ accu.push(key);
428
+ }
429
+ });
430
+ return accu;
431
+ }, []);
432
+
433
+ // make sure each feature has exact same fields
434
+ allDataRows.forEach(function (d) {
435
+ fields.forEach(function (f) {
436
+ if (!(f in d)) {
437
+ d[f] = null;
438
+ if (d._geojson.properties) {
439
+ d._geojson.properties[f] = null;
440
+ }
441
+ }
442
+ });
443
+ });
444
+ return processRowObject(allDataRows);
445
+ }
446
+
447
+ /**
448
+ * Process saved kepler.gl json to be pass to [`addDataToMap`](../actions/actions.md#adddatatomap).
449
+ * The json object should contain `datasets` and `config`.
450
+ * @param rawData
451
+ * @param schema
452
+ * @returns datasets and config `{datasets: {}, config: {}}`
453
+ * @public
454
+ * @example
455
+ * import {addDataToMap} from '@kepler.gl/actions';
456
+ * import {processKeplerglJSON} from '@kepler.gl/processors';
457
+ *
458
+ * dispatch(addDataToMap(processKeplerglJSON(keplerGlJson)));
459
+ */
460
+ function savedMapDisplayInfo(info) {
461
+ var saved = info && (0, _typeof2["default"])(info) === 'object' ? (0, _utils.optionalMapInfo)(info) : undefined;
462
+ // Both keys are always present: setMapInfo merges, so omitting one would keep
463
+ // the previously loaded map's value instead of clearing it.
464
+ return {
465
+ title: saved === null || saved === void 0 ? void 0 : saved.title,
466
+ description: saved === null || saved === void 0 ? void 0 : saved.description
467
+ };
468
+ }
469
+ function processKeplerglJSON(rawData) {
470
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
471
+ if (!rawData) {
472
+ return null;
473
+ }
474
+ return _objectSpread(_objectSpread({}, schema.load(rawData.datasets, rawData.config)), {}, {
475
+ info: savedMapDisplayInfo(rawData.info)
476
+ });
477
+ }
478
+
479
+ /**
480
+ * Parse a single or an array of datasets saved using kepler.gl schema
481
+ * @param rawData
482
+ * @param schema
483
+ */
484
+ function processKeplerglDataset(rawData) {
485
+ var schema = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : _schemas.KeplerGlSchema;
486
+ if (!rawData) {
487
+ return null;
488
+ }
489
+ var results = schema.parseSavedData((0, _commonUtils.toArray)(rawData));
490
+ if (!results) {
491
+ return null;
492
+ }
493
+ return Array.isArray(rawData) ? results : results[0];
494
+ }
495
+
496
+ /**
497
+ * Process a loaders.gl [`ArrowTable`](https://loaders.gl/docs/specifications/category-table) (`{shape: 'arrow-table', data}`)
498
+ * and return a data object that can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap).
499
+ * Load arrow files with `GeoArrowLoader` and `{arrow: {shape: 'arrow-table'}}`.
500
+ *
501
+ * @param arrowTable ArrowTable to parse, see loaders.gl/schema
502
+ * @returns dataset containing `fields` and `rows` or null
503
+ * @public
504
+ * @example
505
+ * import {addDataToMap} from '@kepler.gl/actions';
506
+ * import {processArrowTable} from '@kepler.gl/processors';
507
+ * import {load} from '@loaders.gl/core';
508
+ * import {GeoArrowLoader} from '@loaders.gl/arrow';
509
+ *
510
+ * const arrowTable = await load(url, GeoArrowLoader, {arrow: {shape: 'arrow-table'}});
511
+ *
512
+ * dispatch(addDataToMap({
513
+ * datasets: {
514
+ * info: {id: 'arrow_dataset', label: 'My Arrow'},
515
+ * data: processArrowTable(arrowTable)
516
+ * }
517
+ * }));
518
+ */
519
+ function processArrowTable(arrowTable) {
520
+ // @ts-ignore - Unknown data type causing build failures
521
+ return processArrowBatches(arrowTable.data.batches);
522
+ }
523
+
524
+ /**
525
+ * Extracts GeoArrow metadata from an Apache Arrow table schema.
526
+ * For geoparquet files geoarrow metadata isn't present in fields, so extract extra info from schema.
527
+ * @param table The Apache Arrow table to extract metadata from.
528
+ * @returns An object mapping column names to their GeoArrow encoding type.
529
+ * @throws Logs an error message if parsing of metadata fails.
530
+ */
531
+ function getGeoArrowMetadataFromSchema(table) {
532
+ var geoArrowMetadata = {};
533
+ try {
534
+ var _table$schema$metadat;
535
+ var geoString = (_table$schema$metadat = table.schema.metadata) === null || _table$schema$metadat === void 0 ? void 0 : _table$schema$metadat.get('geo');
536
+ if (geoString) {
537
+ var parsedGeoString = JSON.parse(geoString);
538
+ if (parsedGeoString.columns) {
539
+ Object.keys(parsedGeoString.columns).forEach(function (columnName) {
540
+ var columnData = parsedGeoString.columns[columnName];
541
+ if ((columnData === null || columnData === void 0 ? void 0 : columnData.encoding) === 'WKB') {
542
+ geoArrowMetadata[columnName] = _constants.GEOARROW_EXTENSIONS.WKB;
543
+ }
544
+ // TODO potentially there are other types but no datasets to test
545
+ });
546
+ }
547
+ }
548
+ } catch (error) {
549
+ console.error('An error during arrow table schema metadata parsing');
550
+ }
551
+ return geoArrowMetadata;
552
+ }
553
+
554
+ /**
555
+ * Converts an Apache Arrow table schema into an array of Kepler.gl field objects.
556
+ * @param table The Apache Arrow table whose schema needs to be converted.
557
+ * @param fieldTypeSuggestions Optional mapping of field names to suggested field types.
558
+ * @returns An array of field objects suitable for Kepler.gl.
559
+ */
560
+ function arrowSchemaToFields(table) {
561
+ var fieldTypeSuggestions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
562
+ var headerRow = table.schema.fields.map(function (f) {
563
+ return f.name;
564
+ });
565
+ var sample = (0, _commonUtils.getSampleForTypeAnalyzeArrow)(table, headerRow);
566
+ var keplerFields = (0, _commonUtils.getFieldsFromData)(sample, headerRow);
567
+ var geoArrowMetadata = getGeoArrowMetadataFromSchema(table);
568
+ return table.schema.fields.map(function (field, fieldIndex) {
569
+ var _field$metadata$get;
570
+ var type = (0, _utils.arrowDataTypeToFieldType)(field.type);
571
+ var analyzerType = (0, _utils.arrowDataTypeToAnalyzerDataType)(field.type);
572
+ var format = '';
573
+ var fieldTypeSuggestion = fieldTypeSuggestions[field.name];
574
+ var keplerField = keplerFields[fieldIndex];
575
+
576
+ // geometry fields produced by DuckDB's st_asgeojson()
577
+ if (fieldTypeSuggestion === 'JSON') {
578
+ type = _constants.ALL_FIELD_TYPES.geojson;
579
+ analyzerType = _typeAnalyzer.DATA_TYPES.GEOMETRY_FROM_STRING;
580
+ } else if (fieldTypeSuggestion === 'GEOMETRY' || (_field$metadata$get = field.metadata.get(_constants.GEOARROW_METADATA_KEY)) !== null && _field$metadata$get !== void 0 && _field$metadata$get.startsWith('geoarrow')) {
581
+ type = _constants.ALL_FIELD_TYPES.geoarrow;
582
+ analyzerType = _typeAnalyzer.DATA_TYPES.GEOMETRY;
583
+ } else if (geoArrowMetadata[field.name]) {
584
+ var _field$metadata;
585
+ type = _constants.ALL_FIELD_TYPES.geoarrow;
586
+ analyzerType = _typeAnalyzer.DATA_TYPES.GEOMETRY;
587
+ (_field$metadata = field.metadata) === null || _field$metadata === void 0 || _field$metadata.set(_constants.GEOARROW_METADATA_KEY, geoArrowMetadata[field.name]);
588
+ } else if (fieldTypeSuggestion === 'BLOB') {
589
+ // When arrow wkb column saved to DuckDB as BLOB without any metadata, then queried back
590
+ try {
591
+ var _table$getChildAt;
592
+ var data = (_table$getChildAt = table.getChildAt(fieldIndex)) === null || _table$getChildAt === void 0 ? void 0 : _table$getChildAt.get(0);
593
+ if (data) {
594
+ var binaryGeo = (0, _core.parseSync)(data, _wkt.WKBLoader);
595
+ if (binaryGeo) {
596
+ var _field$metadata2;
597
+ type = _constants.ALL_FIELD_TYPES.geoarrow;
598
+ analyzerType = _typeAnalyzer.DATA_TYPES.GEOMETRY;
599
+ (_field$metadata2 = field.metadata) === null || _field$metadata2 === void 0 || _field$metadata2.set(_constants.GEOARROW_METADATA_KEY, _constants.GEOARROW_EXTENSIONS.WKB);
600
+ }
601
+ }
602
+ } catch (error) {
603
+ // ignore, not WKB
604
+ }
605
+ } else if (fieldTypeSuggestion === 'VARCHAR' && (keplerField.analyzerType === _typeAnalyzer.DATA_TYPES.GEOMETRY || keplerField.analyzerType === _typeAnalyzer.DATA_TYPES.GEOMETRY_FROM_STRING)) {
606
+ // When wkb/wkt was saved as varchar in DuckDB
607
+ type = keplerField.type;
608
+ analyzerType = keplerField.analyzerType;
609
+ format = keplerField.format;
610
+ } else if (fieldTypeSuggestion === 'VARCHAR' && keplerField.type === _constants.ALL_FIELD_TYPES.h3) {
611
+ // when kepler detected h3 column using getFieldsFromData(), set type to h3 and analyzerType to H3
612
+ type = _constants.ALL_FIELD_TYPES.h3;
613
+ analyzerType = keplerField.analyzerType;
614
+ } else {
615
+ // TODO should we use Kepler getFieldsFromData instead
616
+ // of arrowDataTypeToFieldType for all fields?
617
+ if (keplerField.type === _constants.ALL_FIELD_TYPES.timestamp) {
618
+ type = keplerField.type;
619
+ analyzerType = keplerField.analyzerType;
620
+ format = keplerField.format;
621
+ }
622
+ }
623
+ return _objectSpread(_objectSpread({}, field), {}, {
624
+ name: field.name,
625
+ id: field.name,
626
+ displayName: field.name,
627
+ format: format,
628
+ fieldIdx: fieldIndex,
629
+ type: type,
630
+ analyzerType: analyzerType,
631
+ valueAccessor: function valueAccessor(dc) {
632
+ return function (d) {
633
+ return dc.valueAt(d.index, fieldIndex);
634
+ };
635
+ },
636
+ metadata: field.metadata
637
+ });
638
+ });
639
+ }
640
+ var CAST_BIGINTS = false;
641
+
642
+ /**
643
+ * Cast 64-bit integer Arrow columns (Int64, Uint64) to Float64 to avoid BigInt values
644
+ * that are incompatible with d3 scales, sorting, and other numeric operations.
645
+ * Mirrors the DuckDB approach of casting BIGINT/UBIGINT to DOUBLE.
646
+ *
647
+ * Left off so Uint64 values are not rounded through Float64. Samples are
648
+ * stringified for type-analyzer instead.
649
+ */
650
+ function castBigIntColumnsToFloat64(arrowTable) {
651
+ if (!CAST_BIGINTS) {
652
+ return arrowTable;
653
+ }
654
+ var needsCast = arrowTable.schema.fields.some(function (f) {
655
+ return arrow.DataType.isInt(f.type) && f.type.bitWidth === 64;
656
+ });
657
+ if (!needsCast) {
658
+ return arrowTable;
659
+ }
660
+ var newColumns = {};
661
+ for (var i = 0; i < arrowTable.numCols; i++) {
662
+ var field = arrowTable.schema.fields[i];
663
+ var col = arrowTable.getChildAt(i);
664
+ if (!col) continue;
665
+ if (arrow.DataType.isInt(field.type) && field.type.bitWidth === 64) {
666
+ var float64Array = new Float64Array(col.length);
667
+ for (var j = 0; j < col.length; j++) {
668
+ var val = col.get(j);
669
+ float64Array[j] = val === null ? NaN : Number(val);
670
+ }
671
+ newColumns[field.name] = arrow.makeVector(float64Array);
672
+ } else {
673
+ newColumns[field.name] = col;
674
+ }
675
+ }
676
+ return new arrow.Table(newColumns);
677
+ }
678
+ /**
679
+ * Parse arrow batches returned from parseInBatches()
680
+ *
681
+ * @param arrowBatches the arrow record batches to parse
682
+ * @param options optional processing flags
683
+ * @returns dataset containing `fields` and `rows` or null
684
+ */
685
+ function processArrowBatches(arrowBatches, options) {
686
+ if (arrowBatches.length === 0) {
687
+ return null;
688
+ }
689
+ var arrowTable = (options === null || options === void 0 ? void 0 : options.compact) === false ? castBigIntColumnsToFloat64(new arrow.Table(arrowBatches)) : (0, _utils.compactArrowTable)(castBigIntColumnsToFloat64(new arrow.Table(arrowBatches)));
690
+ var fields = arrowSchemaToFields(arrowTable);
691
+ var cols = (0, _toConsumableArray2["default"])(Array(arrowTable.numCols).keys()).map(function (i) {
692
+ return arrowTable.getChildAt(i);
693
+ });
694
+
695
+ // return empty rows and use raw arrow table to construct column-wise data container
696
+ return {
697
+ fields: fields,
698
+ rows: [],
699
+ cols: cols,
700
+ metadata: arrowTable.schema.metadata,
701
+ // Save original arrow schema, for better ingestion into DuckDB.
702
+ // TODO consider returning arrowTable in cols, not an array of Vectors from arrowTable.
703
+ arrowSchema: arrowTable.schema
704
+ };
705
+ }
706
+ 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);
707
+ var Processors = exports.Processors = {
708
+ processGeojson: processGeojson,
709
+ processCsvData: processCsvData,
710
+ processArrowTable: processArrowTable,
711
+ processArrowBatches: processArrowBatches,
712
+ processRowObject: processRowObject,
713
+ processKeplerglJSON: processKeplerglJSON,
714
+ processKeplerglDataset: processKeplerglDataset,
715
+ analyzerTypeToFieldType: _commonUtils.analyzerTypeToFieldType,
716
+ getFieldsFromData: _commonUtils.getFieldsFromData,
717
+ parseCsvRowsByFieldType: parseCsvRowsByFieldType
718
+ };
719
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["arrow","_interopRequireWildcard","require","_d3Dsv","_typeAnalyzer","_geojsonNormalize","_interopRequireDefault","_core","_wkt","_constants","_utils","_commonUtils","_schemas","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof3","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","_createForOfIteratorHelper","Symbol","iterator","Array","isArray","_unsupportedIterableToArray","_n","F","s","done","value","TypeError","a","u","next","_arrayLikeToArray","toString","slice","constructor","name","from","test","CSV_NULLS","exports","SUPPORTED_DELIMITERS","getRowParser","delimiter","csvParseRows","tsvParseRows","dsvFormat","parseRows","detectDelimiter","rawData","newlineIdx","indexOf","firstLine","bestDelimiter","bestCount","_iterator","_step","_parsed$","parsed","count","err","tryParseJsonString","str","JSON","parse","PARSE_FIELD_VALUE_FROM_STRING","ALL_FIELD_TYPES","valid","d","String","toLowerCase","integer","parseInt","timestamp","field","includes","format","Number","real","parseFloat","object","isPlainObject","array","h3","h3IsValid","processCsvData","header","rows","headerRow","parsedRows","Error","cleanUpFalsyCsvValue","sample","getSampleForTypeAnalyze","fields","getFieldsFromData","parseRowsByFields","geojsonFieldIdx","findIndex","parseCsvRowsByFieldType","bind","re","RegExp","j","match","geoFieldIdx","parser","type","first","find","notNullorUndefined","row","properties","processRowObject","firstRow","map","key","WGS84_CRS_NAMES","validateGeojsonCrs","pending","_loop","pop","crs","identifier","href","undefined","trim","some","pattern","geometry","children","features","geometries","_iterator2","_step2","child","processGeojson","normalizedGeojson","normalize","concat","GUIDES_FILE_FORMAT_DOC","allDataRows","_geojson","reduce","accu","curr","savedMapDisplayInfo","info","saved","_typeof2","optionalMapInfo","title","description","processKeplerglJSON","schema","KeplerGlSchema","load","datasets","config","processKeplerglDataset","results","parseSavedData","toArray","processArrowTable","arrowTable","processArrowBatches","data","batches","getGeoArrowMetadataFromSchema","table","geoArrowMetadata","_table$schema$metadat","geoString","metadata","parsedGeoString","columns","columnName","columnData","encoding","GEOARROW_EXTENSIONS","WKB","error","console","arrowSchemaToFields","fieldTypeSuggestions","getSampleForTypeAnalyzeArrow","keplerFields","fieldIndex","_field$metadata$get","arrowDataTypeToFieldType","analyzerType","arrowDataTypeToAnalyzerDataType","fieldTypeSuggestion","keplerField","geojson","AnalyzerDATA_TYPES","GEOMETRY_FROM_STRING","GEOARROW_METADATA_KEY","startsWith","geoarrow","GEOMETRY","_field$metadata","_table$getChildAt","getChildAt","binaryGeo","parseSync","WKBLoader","_field$metadata2","id","displayName","fieldIdx","valueAccessor","dc","valueAt","index","CAST_BIGINTS","castBigIntColumnsToFloat64","needsCast","DataType","isInt","bitWidth","newColumns","numCols","col","float64Array","Float64Array","val","NaN","makeVector","Table","arrowBatches","options","compact","compactArrowTable","cols","_toConsumableArray2","arrowSchema","DATASET_HANDLERS","DATASET_FORMATS","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, tsvParseRows, dsvFormat} from 'd3-dsv';\nimport {DATA_TYPES as AnalyzerDATA_TYPES} from 'type-analyzer';\nimport normalize from '@mapbox/geojson-normalize';\nimport {parseSync} from '@loaders.gl/core';\nimport {ArrowTable} from '@loaders.gl/schema';\nimport {WKBLoader} from '@loaders.gl/wkt';\n\nimport {\n  ALL_FIELD_TYPES,\n  DATASET_FORMATS,\n  GEOARROW_EXTENSIONS,\n  GEOARROW_METADATA_KEY,\n  GUIDES_FILE_FORMAT_DOC\n} from '@kepler.gl/constants';\nimport {ProcessorResult, Field} from '@kepler.gl/types';\nimport {\n  arrowDataTypeToAnalyzerDataType,\n  arrowDataTypeToFieldType,\n  compactArrowTable,\n  hasOwnProperty,\n  isPlainObject,\n  optionalMapInfo\n} from '@kepler.gl/utils';\nimport {\n  analyzerTypeToFieldType,\n  getSampleForTypeAnalyze,\n  getSampleForTypeAnalyzeArrow,\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 '@deck.gl-community/editable-layers';\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\nconst SUPPORTED_DELIMITERS = [',', '\\t', ';', '|'] as const;\n\nfunction getRowParser(delimiter: string): (raw: string) => string[][] {\n  if (delimiter === ',') return csvParseRows;\n  if (delimiter === '\\t') return tsvParseRows;\n  return dsvFormat(delimiter).parseRows;\n}\n\n/**\n * Detect the delimiter used in a DSV string by checking the first line.\n * Returns the delimiter that produces the most columns (minimum 2).\n * Falls back to comma if no delimiter produces multiple columns.\n */\nexport function detectDelimiter(rawData: string): string {\n  const newlineIdx = rawData.indexOf('\\n');\n  const firstLine = newlineIdx === -1 ? rawData : rawData.slice(0, newlineIdx);\n  if (!firstLine) return ',';\n\n  let bestDelimiter = ',';\n  let bestCount = 1;\n\n  for (const delimiter of SUPPORTED_DELIMITERS) {\n    const parsed = getRowParser(delimiter)(firstLine);\n    const count = parsed[0]?.length || 0;\n    if (count > bestCount) {\n      bestCount = count;\n      bestDelimiter = delimiter;\n    }\n  }\n\n  return bestDelimiter;\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 => {\n      const s = String(d).toLowerCase();\n      return s === 'true' || s === 'yes' || s === '1';\n    }\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 delimiter = detectDelimiter(rawData);\n    const parsedRows: string[][] = getRowParser(delimiter)(rawData);\n\n    if (!Array.isArray(parsedRows) || parsedRows.length < 2) {\n      throw new Error('processCsvData Failed: delimited text is empty or has no data rows');\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 firstRow = rawData[0] as Record<string, unknown>;\n  const keys = Object.keys(firstRow); // [lat, lng, value]\n  const rows = rawData.map(d => keys.map(key => (d as Record<string, unknown>)[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\nconst WGS84_CRS_NAMES = [\n  /^(?:EPSG:4326|OGC:CRS84h?|CRS84h?|WGS ?84)$/i,\n  /^urn:(?:x-)?ogc:def:crs:(?:EPSG:(?:[\\d.]*:)?4326|OGC:(?:(?:[\\d.]*:)?CRS84h?|2:84))$/i,\n  /^https?:\\/\\/www\\.opengis\\.net\\/def\\/crs\\/(?:EPSG\\/[\\d.]+\\/4326|OGC\\/[\\d.]+\\/CRS84h?)$/i,\n  /^https?:\\/\\/www\\.opengis\\.net\\/gml\\/srs\\/epsg\\.xml#4326$/i\n];\n\nfunction validateGeojsonCrs(rawData: unknown): void {\n  const pending = [rawData];\n  while (pending.length) {\n    const value = pending.pop();\n    if (!isPlainObject(value)) continue;\n\n    const {crs} = value;\n    if (isPlainObject(crs) && isPlainObject(crs.properties)) {\n      const identifier =\n        crs.type === 'name'\n          ? crs.properties.name\n          : crs.type === 'link'\n          ? crs.properties.href\n          : undefined;\n      // Preserve existing handling of absent, null, and malformed declarations.\n      // Recognize known identifiers without fetching linked CRS definitions.\n      if (\n        typeof identifier === 'string' &&\n        identifier.trim() &&\n        !WGS84_CRS_NAMES.some(pattern => pattern.test(identifier.trim()))\n      ) {\n        throw new Error(\n          'Read File Failed: GeoJSON uses an unsupported coordinate reference system. ' +\n            'Convert coordinates to WGS84 (EPSG:4326) before importing.'\n        );\n      }\n    }\n\n    // CRS can be declared on collections, features, or their geometries, but a\n    // feature property named \"crs\" is ordinary data and must not be inspected.\n    if (value.type === 'Feature') {\n      pending.push(value.geometry);\n    } else {\n      const children =\n        value.type === 'FeatureCollection'\n          ? value.features\n          : value.type === 'GeometryCollection'\n          ? value.geometries\n          : null;\n      if (Array.isArray(children)) {\n        for (const child of children) pending.push(child);\n      }\n    }\n  }\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  validateGeojsonCrs(rawData);\n  const normalizedGeojson = normalize(rawData);\n\n  if (!normalizedGeojson || !Array.isArray(normalizedGeojson.features)) {\n    throw new Error(\n      `Read File Failed: File is not a valid GeoJSON. Read more about [supported file format](${GUIDES_FILE_FORMAT_DOC})`\n    );\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      const row = {\n        // Reserve the first field for geometry to preserve existing field indices.\n        _geojson: f,\n        ...(f.properties || {})\n      };\n      // A property with the reserved name must not replace the feature.\n      row._geojson = f;\n      allDataRows.push(row);\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 */\nfunction savedMapDisplayInfo(info: unknown): {title?: string; description?: string} {\n  const saved =\n    info && typeof info === 'object'\n      ? optionalMapInfo(info as {title?: unknown; description?: unknown})\n      : undefined;\n  // Both keys are always present: setMapInfo merges, so omitting one would keep\n  // the previously loaded map's value instead of clearing it.\n  return {title: saved?.title, description: saved?.description};\n}\n\nexport function processKeplerglJSON(rawData: SavedMap, schema = KeplerGlSchema): LoadedMap | null {\n  if (!rawData) {\n    return null;\n  }\n  return {\n    ...schema.load(rawData.datasets, rawData.config),\n    info: savedMapDisplayInfo(rawData.info)\n  };\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 * Process a loaders.gl [`ArrowTable`](https://loaders.gl/docs/specifications/category-table) (`{shape: 'arrow-table', data}`)\n * and return a data object that can be passed to [`addDataToMap`](../actions/actions.md#adddatatomap).\n * Load arrow files with `GeoArrowLoader` and `{arrow: {shape: 'arrow-table'}}`.\n *\n * @param arrowTable ArrowTable to parse, see loaders.gl/schema\n * @returns dataset containing `fields` and `rows` or null\n * @public\n * @example\n * import {addDataToMap} from '@kepler.gl/actions';\n * import {processArrowTable} from '@kepler.gl/processors';\n * import {load} from '@loaders.gl/core';\n * import {GeoArrowLoader} from '@loaders.gl/arrow';\n *\n * const arrowTable = await load(url, GeoArrowLoader, {arrow: {shape: 'arrow-table'}});\n *\n * dispatch(addDataToMap({\n *   datasets: {\n *     info: {id: 'arrow_dataset', label: 'My Arrow'},\n *     data: processArrowTable(arrowTable)\n *   }\n * }));\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\n/**\n * Extracts GeoArrow metadata from an Apache Arrow table schema.\n * For geoparquet files geoarrow metadata isn't present in fields, so extract extra info from schema.\n * @param table The Apache Arrow table to extract metadata from.\n * @returns An object mapping column names to their GeoArrow encoding type.\n * @throws Logs an error message if parsing of metadata fails.\n */\nexport function getGeoArrowMetadataFromSchema(table: arrow.Table): Record<string, string> {\n  const geoArrowMetadata: Record<string, string> = {};\n  try {\n    const geoString = table.schema.metadata?.get('geo');\n    if (geoString) {\n      const parsedGeoString = JSON.parse(geoString);\n      if (parsedGeoString.columns) {\n        Object.keys(parsedGeoString.columns).forEach(columnName => {\n          const columnData = parsedGeoString.columns[columnName];\n          if (columnData?.encoding === 'WKB') {\n            geoArrowMetadata[columnName] = GEOARROW_EXTENSIONS.WKB;\n          }\n          // TODO potentially there are other types but no datasets to test\n        });\n      }\n    }\n  } catch (error) {\n    console.error('An error during arrow table schema metadata parsing');\n  }\n  return geoArrowMetadata;\n}\n\n/**\n * Converts an Apache Arrow table schema into an array of Kepler.gl field objects.\n * @param table The Apache Arrow table whose schema needs to be converted.\n * @param fieldTypeSuggestions Optional mapping of field names to suggested field types.\n * @returns An array of field objects suitable for Kepler.gl.\n */\nexport function arrowSchemaToFields(\n  table: arrow.Table,\n  fieldTypeSuggestions: Record<string, string> = {}\n): Field[] {\n  const headerRow = table.schema.fields.map(f => f.name);\n  const sample = getSampleForTypeAnalyzeArrow(table, headerRow);\n  const keplerFields = getFieldsFromData(sample, headerRow);\n  const geoArrowMetadata = getGeoArrowMetadataFromSchema(table);\n\n  return table.schema.fields.map((field: arrow.Field, fieldIndex: number) => {\n    let type = arrowDataTypeToFieldType(field.type);\n    let analyzerType = arrowDataTypeToAnalyzerDataType(field.type);\n    let format = '';\n\n    const fieldTypeSuggestion = fieldTypeSuggestions[field.name];\n    const keplerField = keplerFields[fieldIndex];\n\n    // geometry fields produced by DuckDB's st_asgeojson()\n    if (fieldTypeSuggestion === 'JSON') {\n      type = ALL_FIELD_TYPES.geojson;\n      analyzerType = AnalyzerDATA_TYPES.GEOMETRY_FROM_STRING;\n    } else if (\n      fieldTypeSuggestion === 'GEOMETRY' ||\n      field.metadata.get(GEOARROW_METADATA_KEY)?.startsWith('geoarrow')\n    ) {\n      type = ALL_FIELD_TYPES.geoarrow;\n      analyzerType = AnalyzerDATA_TYPES.GEOMETRY;\n    } else if (geoArrowMetadata[field.name]) {\n      type = ALL_FIELD_TYPES.geoarrow;\n      analyzerType = AnalyzerDATA_TYPES.GEOMETRY;\n      field.metadata?.set(GEOARROW_METADATA_KEY, geoArrowMetadata[field.name]);\n    } else if (fieldTypeSuggestion === 'BLOB') {\n      // When arrow wkb column saved to DuckDB as BLOB without any metadata, then queried back\n      try {\n        const data = table.getChildAt(fieldIndex)?.get(0);\n        if (data) {\n          const binaryGeo = parseSync(data, WKBLoader);\n          if (binaryGeo) {\n            type = ALL_FIELD_TYPES.geoarrow;\n            analyzerType = AnalyzerDATA_TYPES.GEOMETRY;\n            field.metadata?.set(GEOARROW_METADATA_KEY, GEOARROW_EXTENSIONS.WKB);\n          }\n        }\n      } catch (error) {\n        // ignore, not WKB\n      }\n    } else if (\n      fieldTypeSuggestion === 'VARCHAR' &&\n      (keplerField.analyzerType === AnalyzerDATA_TYPES.GEOMETRY ||\n        keplerField.analyzerType === AnalyzerDATA_TYPES.GEOMETRY_FROM_STRING)\n    ) {\n      // When wkb/wkt was saved as varchar in DuckDB\n      type = keplerField.type;\n      analyzerType = keplerField.analyzerType;\n      format = keplerField.format;\n    } else if (fieldTypeSuggestion === 'VARCHAR' && keplerField.type === ALL_FIELD_TYPES.h3) {\n      // when kepler detected h3 column using getFieldsFromData(), set type to h3 and analyzerType to H3\n      type = ALL_FIELD_TYPES.h3;\n      analyzerType = keplerField.analyzerType;\n    } else {\n      // TODO should we use Kepler getFieldsFromData instead\n      // of arrowDataTypeToFieldType for all fields?\n      if (keplerField.type === ALL_FIELD_TYPES.timestamp) {\n        type = keplerField.type;\n        analyzerType = keplerField.analyzerType;\n        format = keplerField.format;\n      }\n    }\n\n    return {\n      ...field,\n      name: field.name,\n      id: field.name,\n      displayName: field.name,\n      format: format,\n      fieldIdx: fieldIndex,\n      type,\n      analyzerType,\n      valueAccessor: (dc: any) => d => {\n        return dc.valueAt(d.index, fieldIndex);\n      },\n      metadata: field.metadata\n    };\n  });\n}\n\nconst CAST_BIGINTS = false;\n\n/**\n * Cast 64-bit integer Arrow columns (Int64, Uint64) to Float64 to avoid BigInt values\n * that are incompatible with d3 scales, sorting, and other numeric operations.\n * Mirrors the DuckDB approach of casting BIGINT/UBIGINT to DOUBLE.\n *\n * Left off so Uint64 values are not rounded through Float64. Samples are\n * stringified for type-analyzer instead.\n */\nfunction castBigIntColumnsToFloat64(arrowTable: arrow.Table): arrow.Table {\n  if (!CAST_BIGINTS) {\n    return arrowTable;\n  }\n\n  const needsCast = arrowTable.schema.fields.some(\n    f => arrow.DataType.isInt(f.type) && f.type.bitWidth === 64\n  );\n  if (!needsCast) {\n    return arrowTable;\n  }\n\n  const newColumns: Record<string, arrow.Vector> = {};\n  for (let i = 0; i < arrowTable.numCols; i++) {\n    const field = arrowTable.schema.fields[i];\n    const col = arrowTable.getChildAt(i);\n    if (!col) continue;\n    if (arrow.DataType.isInt(field.type) && field.type.bitWidth === 64) {\n      const float64Array = new Float64Array(col.length);\n      for (let j = 0; j < col.length; j++) {\n        const val = col.get(j);\n        float64Array[j] = val === null ? NaN : Number(val);\n      }\n      newColumns[field.name] = arrow.makeVector(float64Array);\n    } else {\n      newColumns[field.name] = col;\n    }\n  }\n  return new arrow.Table(newColumns);\n}\n\nexport type ProcessArrowBatchesOptions = {\n  /**\n   * When false, skip compactArrowTable. Progressive Arrow loading uses this so\n   * each incoming batch does not copy the accumulated table. Defaults to true.\n   * The final processFileContent call leaves this unset so the completed table\n   * is compacted once.\n   */\n  compact?: boolean;\n};\n\n/**\n * Parse arrow batches returned from parseInBatches()\n *\n * @param arrowBatches the arrow record batches to parse\n * @param options optional processing flags\n * @returns dataset containing `fields` and `rows` or null\n */\nexport function processArrowBatches(\n  arrowBatches: arrow.RecordBatch[],\n  options?: ProcessArrowBatchesOptions\n): ProcessorResult | null {\n  if (arrowBatches.length === 0) {\n    return null;\n  }\n  const arrowTable =\n    options?.compact === false\n      ? castBigIntColumnsToFloat64(new arrow.Table(arrowBatches))\n      : compactArrowTable(castBigIntColumnsToFloat64(new arrow.Table(arrowBatches)));\n  const fields = arrowSchemaToFields(arrowTable);\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 {\n    fields,\n    rows: [],\n    cols,\n    metadata: arrowTable.schema.metadata,\n    // Save original arrow schema, for better ingestion into DuckDB.\n    // TODO consider returning arrowTable in cols, not an array of Vectors from arrowTable.\n    arrowSchema: arrowTable.schema\n  };\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":[]}