@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.
- package/dist/data-processor.d.ts +161 -0
- package/dist/data-processor.js +427 -0
- package/dist/file-handler.d.ts +27 -0
- package/dist/file-handler.js +449 -0
- package/dist/index.d.ts +3 -0
- package/dist/index.js +65 -0
- package/dist/types.d.ts +13 -0
- package/dist/types.js +26 -0
- package/package.json +62 -0
|
@@ -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":";;;;;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AAEA;;AASA;;;;;;;;AAGA;AACA;AACA;AACO,IAAMA,SAAS,GAAG,8BAAlB;;AAEA,IAAMC,6BAA6B,wFACvCC,qCADuC,EACb;AACzBC,EAAAA,KAAK,EAAE,eAACC,CAAD;AAAA,WAAyB,OAAOA,CAAP,KAAa,SAAtC;AAAA,GADkB;AAEzBC,EAAAA,KAAK,EAAE,eAACD,CAAD;AAAA,WAAyBA,CAAC,KAAK,MAAN,IAAgBA,CAAC,KAAK,MAAtB,IAAgCA,CAAC,KAAK,MAAtC,IAAgDA,CAAC,KAAK,GAA/E;AAAA;AAFkB,CADa,2DAKvCF,2BAAgBI,OALuB,EAKb;AACzB;AACAH,EAAAA,KAAK,EAAE,eAACC,CAAD;AAAA,WAAyBG,QAAQ,CAACH,CAAD,EAAI,EAAJ,CAAR,KAAoBA,CAA7C;AAAA,GAFkB;AAGzB;AACAC,EAAAA,KAAK,EAAE,eAACD,CAAD;AAAA,WAAwBG,QAAQ,CAACH,CAAD,EAAI,EAAJ,CAAhC;AAAA;AAJkB,CALa,2DAWvCF,2BAAgBM,SAXuB,EAWX;AAC3BL,EAAAA,KAAK,EAAE,eAACC,CAAD,EAAaK,KAAb;AAAA,WACL,CAAC,GAAD,EAAM,GAAN,EAAWC,QAAX,CAAoBD,KAAK,CAACE,MAA1B,IAAoC,OAAOP,CAAP,KAAa,QAAjD,GAA4D,OAAOA,CAAP,KAAa,QADpE;AAAA,GADoB;AAG3BC,EAAAA,KAAK,EAAE,eAACD,CAAD,EAASK,KAAT;AAAA,WAA2B,CAAC,GAAD,EAAM,GAAN,EAAWC,QAAX,CAAoBD,KAAK,CAACE,MAA1B,IAAoCC,MAAM,CAACR,CAAD,CAA1C,GAAgDA,CAA3E;AAAA;AAHoB,CAXW,2DAgBvCF,2BAAgBW,IAhBuB,EAgBhB;AACtB;AACAV,EAAAA,KAAK,EAAE,eAACC,CAAD;AAAA,WAAyBU,UAAU,CAACV,CAAD,CAAV,KAAkBA,CAA3C;AAAA,GAFe;AAGtB;AACAC,EAAAA,KAAK,EAAES;AAJe,CAhBgB,yBAAnC;AAwBP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AACO,SAASC,cAAT,CAAwBC,OAAxB,EAA8CC,MAA9C,EAAkF;AACvF,MAAIC,IAAJ;AACA,MAAIC,SAAJ;;AAEA,MAAI,OAAOH,OAAP,KAAmB,QAAvB,EAAiC;AAC/B,QAAMI,WAAsB,GAAG,yBAAaJ,OAAb,CAA/B;;AAEA,QAAI,CAACK,KAAK,CAACC,OAAN,CAAcF,WAAd,CAAD,IAA8BA,WAAU,CAACG,MAAX,GAAoB,CAAtD,EAAyD;AACvD;AACA,YAAM,IAAIC,KAAJ,CAAU,uCAAV,CAAN;AACD;;AACDL,IAAAA,SAAS,GAAGC,WAAU,CAAC,CAAD,CAAtB;AACAF,IAAAA,IAAI,GAAGE,WAAU,CAACK,KAAX,CAAiB,CAAjB,CAAP;AACD,GATD,MASO,IAAIJ,KAAK,CAACC,OAAN,CAAcN,OAAd,KAA0BA,OAAO,CAACO,MAAtC,EAA8C;AACnDL,IAAAA,IAAI,GAAGF,OAAP;AACAG,IAAAA,SAAS,GAAGF,MAAZ;;AAEA,QAAI,CAACI,KAAK,CAACC,OAAN,CAAcH,SAAd,CAAL,EAA+B;AAC7B;AACA;AACA;AACAA,MAAAA,SAAS,GAAGH,OAAO,CAAC,CAAD,CAAnB;AACAE,MAAAA,IAAI,GAAGF,OAAO,CAACS,KAAR,CAAc,CAAd,CAAP;AACD;AACF;;AAED,MAAI,CAACP,IAAD,IAAS,CAACC,SAAd,EAAyB;AACvB,UAAM,IAAIK,KAAJ,CAAU,wCAAV,CAAN;AACD,GA5BsF,CA8BvF;AACA;;;AAEAE,EAAAA,oBAAoB,CAACR,IAAD,CAApB,CAjCuF,CAkCvF;AACA;;AACA,MAAMS,MAAM,GAAG,oCAAwB;AAACC,IAAAA,MAAM,EAAET,SAAT;AAAoBD,IAAAA,IAAI,EAAJA;AAApB,GAAxB,CAAf;AACA,MAAMU,MAAM,GAAG,8BAAkBD,MAAlB,EAA0BR,SAA1B,CAAf;AACA,MAAMC,UAAU,GAAGS,iBAAiB,CAACX,IAAD,EAAOU,MAAP,CAApC;AAEA,SAAO;AAACA,IAAAA,MAAM,EAANA,MAAD;AAASV,IAAAA,IAAI,EAAEE;AAAf,GAAP;AACD;AAED;AACA;AACA;AACA;AACA;;;AACO,SAASS,iBAAT,CAA2BX,IAA3B,EAA0CU,MAA1C,EAA2D;AAChE;AACA,MAAME,eAAe,GAAGF,MAAM,CAACG,SAAP,CAAiB,UAAAC,CAAC;AAAA,WAAIA,CAAC,CAACC,IAAF,KAAW,UAAf;AAAA,GAAlB,CAAxB;AACAL,EAAAA,MAAM,CAACM,OAAP,CAAeC,uBAAuB,CAACC,IAAxB,CAA6B,IAA7B,EAAmClB,IAAnC,EAAyCY,eAAzC,CAAf;AAEA,SAAOZ,IAAP;AACD;AAED;AACA;AACA;AACA;AACA;AACA;;;AACA,SAASQ,oBAAT,CAA8BR,IAA9B,EAAuD;AACrD,MAAMmB,EAAE,GAAG,IAAIC,MAAJ,CAAWtC,SAAX,EAAsB,GAAtB,CAAX;;AACA,OAAK,IAAIuC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGrB,IAAI,CAACK,MAAzB,EAAiCgB,CAAC,EAAlC,EAAsC;AACpC,SAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGtB,IAAI,CAACqB,CAAD,CAAJ,CAAQhB,MAA5B,EAAoCiB,CAAC,EAArC,EAAyC;AACvC;AACA;AACA;AACA;AACA,UAAI,OAAOtB,IAAI,CAACqB,CAAD,CAAJ,CAAQC,CAAR,CAAP,KAAsB,QAAtB,IAAmCtB,IAAI,CAACqB,CAAD,CAAJ,CAAQC,CAAR,CAAD,CAAuBC,KAAvB,CAA6BJ,EAA7B,CAAtC,EAAwE;AACtEnB,QAAAA,IAAI,CAACqB,CAAD,CAAJ,CAAQC,CAAR,IAAa,IAAb;AACD;AACF;AACF;AACF;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAASL,uBAAT,CACLjB,IADK,EAELwB,WAFK,EAGLjC,KAHK,EAIL8B,CAJK,EAKC;AACN,MAAMI,MAAM,GAAG1C,6BAA6B,CAACQ,KAAK,CAACmC,IAAP,CAA5C;;AACA,MAAID,MAAJ,EAAY;AACV;AACA,QAAME,KAAK,GAAG3B,IAAI,CAAC4B,IAAL,CAAU,UAAAC,CAAC;AAAA,aAAI,+BAAmBA,CAAC,CAACR,CAAD,CAApB,CAAJ;AAAA,KAAX,CAAd;;AACA,QAAI,CAACM,KAAD,IAAUF,MAAM,CAACxC,KAAP,CAAa0C,KAAK,CAACN,CAAD,CAAlB,EAAuB9B,KAAvB,CAAd,EAA6C;AAC3C;AACD;;AACDS,IAAAA,IAAI,CAACgB,OAAL,CAAa,UAAAc,GAAG,EAAI;AAClB;AACA,UAAIA,GAAG,CAACT,CAAD,CAAH,KAAW,IAAf,EAAqB;AACnBS,QAAAA,GAAG,CAACT,CAAD,CAAH,GAASI,MAAM,CAACtC,KAAP,CAAa2C,GAAG,CAACT,CAAD,CAAhB,EAAqB9B,KAArB,CAAT;;AACA,YACEiC,WAAW,GAAG,CAAC,CAAf,IACA,0BAAcM,GAAG,CAACN,WAAD,CAAjB,CADA,IAEA;AACA,mCAAeM,GAAG,CAACN,WAAD,CAAlB,EAAiC,YAAjC,CAJF,EAKE;AACA;AACAM,UAAAA,GAAG,CAACN,WAAD,CAAH,CAAiBO,UAAjB,CAA4BxC,KAAK,CAACwB,IAAlC,IAA0Ce,GAAG,CAACT,CAAD,CAA7C;AACD;AACF;AACF,KAdD;AAeD;AACF;AAED;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAASW,gBAAT,CAA0BlC,OAA1B,EAA+D;AACpE,MAAI,CAACK,KAAK,CAACC,OAAN,CAAcN,OAAd,CAAL,EAA6B;AAC3B,WAAO,IAAP;AACD,GAFD,MAEO,IAAI,CAACA,OAAO,CAACO,MAAb,EAAqB;AAC1B;AACA,WAAO;AACLK,MAAAA,MAAM,EAAE,EADH;AAELV,MAAAA,IAAI,EAAE;AAFD,KAAP;AAID;;AAED,MAAMiC,IAAI,GAAGC,MAAM,CAACD,IAAP,CAAYnC,OAAO,CAAC,CAAD,CAAnB,CAAb,CAXoE,CAW9B;;AACtC,MAAME,IAAI,GAAGF,OAAO,CAACqC,GAAR,CAAY,UAAAjD,CAAC;AAAA,WAAI+C,IAAI,CAACE,GAAL,CAAS,UAAAC,GAAG;AAAA,aAAIlD,CAAC,CAACkD,GAAD,CAAL;AAAA,KAAZ,CAAJ;AAAA,GAAb,CAAb,CAZoE,CAYZ;AAExD;;AACA5B,EAAAA,oBAAoB,CAACR,IAAD,CAApB;AAEA,SAAOH,cAAc,CAACG,IAAD,EAAOiC,IAAP,CAArB;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAASI,cAAT,CAAwBvC,OAAxB,EAA2D;AAChE,MAAMwC,iBAAiB,GAAG,kCAAUxC,OAAV,CAA1B;;AAEA,MAAI,CAACwC,iBAAD,IAAsB,CAACnC,KAAK,CAACC,OAAN,CAAckC,iBAAiB,CAACC,QAAhC,CAA3B,EAAsE;AACpE,QAAMC,KAAK,GAAG,IAAIlC,KAAJ,kGAC8EmC,iCAD9E,OAAd;AAGA,UAAMD,KAAN,CAJoE,CAKpE;AACD,GAT+D,CAWhE;;;AACA,MAAME,WAAuD,GAAG,EAAhE;;AACA,OAAK,IAAIrB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGiB,iBAAiB,CAACC,QAAlB,CAA2BlC,MAA/C,EAAuDgB,CAAC,EAAxD,EAA4D;AAC1D,QAAMP,CAAC,GAAGwB,iBAAiB,CAACC,QAAlB,CAA2BlB,CAA3B,CAAV;;AACA,QAAIP,CAAC,CAAC6B,QAAN,EAAgB;AACdD,MAAAA,WAAW,CAACE,IAAZ;AACE;AACAC,QAAAA,QAAQ,EAAE/B;AAFZ,SAGMA,CAAC,CAACiB,UAAF,IAAgB,EAHtB;AAKD;AACF,GAtB+D,CAuBhE;;;AACA,MAAMrB,MAAM,GAAGgC,WAAW,CAACI,MAAZ,CAA6B,UAACC,IAAD,EAAOC,IAAP,EAAgB;AAC1Dd,IAAAA,MAAM,CAACD,IAAP,CAAYe,IAAZ,EAAkBhC,OAAlB,CAA0B,UAAAoB,GAAG,EAAI;AAC/B,UAAI,CAACW,IAAI,CAACvD,QAAL,CAAc4C,GAAd,CAAL,EAAyB;AACvBW,QAAAA,IAAI,CAACH,IAAL,CAAUR,GAAV;AACD;AACF,KAJD;AAKA,WAAOW,IAAP;AACD,GAPc,EAOZ,EAPY,CAAf,CAxBgE,CAiChE;;AACAL,EAAAA,WAAW,CAAC1B,OAAZ,CAAoB,UAAA9B,CAAC,EAAI;AACvBwB,IAAAA,MAAM,CAACM,OAAP,CAAe,UAAAF,CAAC,EAAI;AAClB,UAAI,EAAEA,CAAC,IAAI5B,CAAP,CAAJ,EAAe;AACbA,QAAAA,CAAC,CAAC4B,CAAD,CAAD,GAAO,IAAP;AACA5B,QAAAA,CAAC,CAAC2D,QAAF,CAAWd,UAAX,CAAsBjB,CAAtB,IAA2B,IAA3B;AACD;AACF,KALD;AAMD,GAPD;AASA,SAAOkB,gBAAgB,CAACU,WAAD,CAAvB;AACD;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACO,SAASO,mBAAT,CAA6BnD,OAA7B,EAA2F;AAAA,MAA3CoD,MAA2C,uEAAlCC,uBAAkC;AAChG,SAAOrD,OAAO,GAAGoD,MAAM,CAACE,IAAP,CAAYtD,OAAO,CAACuD,QAApB,EAA8BvD,OAAO,CAACwD,MAAtC,CAAH,GAAmD,IAAjE;AACD;AAED;AACA;AACA;AACA;AACA;;;AACO,SAASC,sBAAT,CACLzD,OADK,EAGmC;AAAA,MADxCoD,MACwC,uEAD/BC,uBAC+B;;AACxC,MAAI,CAACrD,OAAL,EAAc;AACZ,WAAO,IAAP;AACD;;AAED,MAAM0D,OAAO,GAAGN,MAAM,CAACO,cAAP,CAAsB,oBAAQ3D,OAAR,CAAtB,CAAhB;;AACA,MAAI,CAAC0D,OAAL,EAAc;AACZ,WAAO,IAAP;AACD;;AACD,SAAOrD,KAAK,CAACC,OAAN,CAAcN,OAAd,IAAyB0D,OAAzB,GAAmCA,OAAO,CAAC,CAAD,CAAjD;AACD;;AAEM,IAAME,gBAKZ,gFACEC,2BAAgB7B,GADlB,EACwBE,gBADxB,uDAEE2B,2BAAgBC,OAFlB,EAE4BvB,cAF5B,uDAGEsB,2BAAgBE,GAHlB,EAGwBhE,cAHxB,uDAIE8D,2BAAgBG,QAJlB,EAI6BP,sBAJ7B,qBALM;;AAYA,IAAMQ,UASZ,GAAG;AACF1B,EAAAA,cAAc,EAAdA,cADE;AAEFxC,EAAAA,cAAc,EAAdA,cAFE;AAGFmC,EAAAA,gBAAgB,EAAhBA,gBAHE;AAIFiB,EAAAA,mBAAmB,EAAnBA,mBAJE;AAKFM,EAAAA,sBAAsB,EAAtBA,sBALE;AAMFS,EAAAA,uBAAuB,EAAvBA,8BANE;AAOFC,EAAAA,iBAAiB,EAAjBA,wBAPE;AAQFhD,EAAAA,uBAAuB,EAAvBA;AARE,CATG","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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoBA;;AACA;;AACA;;AACA;;AACA;;AACA;;;;;;AAMA,IAAMA,UAAU,GAAG;AACjBC,EAAAA,QAAQ,EAAE,UADO;AAEjBC,EAAAA,cAAc,EAAE,gBAFC;AAGjBC,EAAAA,YAAY,EAAE;AAHG,CAAnB;AAMA,IAAMC,kBAAkB,GAAG;AACzBC,EAAAA,KAAK,EAAE,kBADkB;AAEzBC,EAAAA,aAAa,EAAE,KAFU,CAEJ;;AAFI,CAA3B;AAKA,IAAMC,mBAAmB,GAAG;AAC1BF,EAAAA,KAAK,EAAE,kBADmB;AAE1B;AACAG,EAAAA,SAAS,EAAE,CACT,GADS,EACJ;AACL,cAFS,EAEK;AACd,cAHS,CAGI;AAHJ;AAHe,CAA5B;;AAUO,SAASC,SAAT,CAAmBC,IAAnB,EAAuE;AAC5E;AACA;AACA,SAAO,0BAAcA,IAAd,MAAwBC,SAAS,CAACD,IAAD,CAAT,IAAmBE,mBAAmB,CAACF,IAAD,CAA9D,CAAP;AACD;;AAEM,SAASC,SAAT,CAAmBD,IAAnB,EAAmD;AACxD,SAAO,0BAAcA,IAAd,KAAuBA,IAAI,CAACG,IAAL,KAAc,SAArC,IAAkDC,OAAO,CAACJ,IAAI,CAACK,QAAN,CAAhE;AACD;;AAEM,SAASH,mBAAT,CAA6BF,IAA7B,EAAuE;AAC5E,SAAO,0BAAcA,IAAd,KAAuBA,IAAI,CAACG,IAAL,KAAc,mBAArC,IAA4DC,OAAO,CAACJ,IAAI,CAACM,QAAN,CAA1E;AACD;;AAEM,SAASC,WAAT,CAAqBP,IAArB,EAAyC;AAC9C,SAAOQ,KAAK,CAACC,OAAN,CAAcT,IAAd,KAAuB,0BAAcA,IAAI,CAAC,CAAD,CAAlB,CAA9B;AACD;;AAEM,SAASU,aAAT,CAAuBV,IAAvB,EAAgE;AACrE,SAAOI,OAAO,CACZ,0BAAcJ,IAAd,KACEA,IAAI,CAACW,QADP,IAEEX,IAAI,CAACY,MAFP,IAGEZ,IAAI,CAACa,IAHP,IAIE,0BAAcb,IAAI,CAACa,IAAnB,CAJF,IAKEb,IAAI,CAACa,IAAL,CAAUC,GAAV,KAAkB,WANR,CAAd;AAQD;;SAEsBC,oB;;EAsBvB;;;;0GAtBO,iBACLC,aADK,EAELH,IAFK;AAAA;;AAAA;AAAA;AAAA;AAAA;AAIDI,YAAAA,QAJC,GAIU,CAJV;AAAA;AAAA;AAAA;AAAA,wDAMqBD,aANrB;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAMYE,YAAAA,KANZ;AAOGC,YAAAA,eAPH,GAOsBD,KAAK,CAACE,IAAN,IAAcF,KAAK,CAACE,IAAN,CAAWC,MAA1B,IAAqC,CAP1D;AAQHJ,YAAAA,QAAQ,IAAIE,eAAZ;AACMG,YAAAA,OATH,GASaC,MAAM,CAACC,QAAP,CAAgBN,KAAK,CAACO,SAAtB,IAAmCP,KAAK,CAACO,SAAN,GAAkBZ,IAAI,CAACa,IAA1D,GAAiE,IAT9E,EAWH;;AACMC,YAAAA,QAZH;AAaDV,cAAAA,QAAQ,EAARA,QAbC;AAcDE,cAAAA,eAAe,EAAfA;AAdC,eAeGI,MAAM,CAACC,QAAP,CAAgBF,OAAhB,IAA2B;AAACA,cAAAA,OAAO,EAAPA;AAAD,aAA3B,GAAuC,EAf1C;AAAA;AAkBH,mDAAUJ,KAAV;AAAiBS,cAAAA,QAAQ,EAARA;AAAjB;;AAlBG;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAuBgBC,S;;;;;+FAAhB,kBACLZ,aADK,EAELa,QAFK;AAAA;;AAAA;AAAA;AAAA;AAAA;AAIDC,YAAAA,MAJC,GAIQ,IAJR;AAKCC,YAAAA,OALD,GAKgB,EALhB;AAAA;AAAA;AAAA;AAAA,yDAOqBf,aAPrB;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAOYE,YAAAA,KAPZ;;AAQH;AACA;AACA;AACA,gBAAIA,KAAK,CAACc,SAAN,KAAoB1C,UAAU,CAACG,YAAnC,EAAiD;AAC/C,kBAAIyB,KAAK,CAACe,SAAV,EAAqB;AACnBH,gBAAAA,MAAM,qBAAOZ,KAAK,CAACe,SAAb,CAAN;AACD,eAH8C,CAI/C;AACA;;;AACA,kBAAIf,KAAK,CAACgB,QAAN,IAAkBhB,KAAK,CAACgB,QAAN,CAAeb,MAAf,GAAwB,CAA9C,EAAiD;AACzCc,gBAAAA,aADyC,GACzB,IAAIC,eAAJ,CAAclB,KAAK,CAACgB,QAApB,CADyB;AAE/CC,gBAAAA,aAAa,CAACE,cAAd,CAA6BP,MAA7B,EAAqCC,OAArC;AACD,eAHD,MAGO,IAAIb,KAAK,CAACgB,QAAN,IAAkBhB,KAAK,CAACgB,QAAN,CAAeb,MAAf,KAA0B,CAAhD,EAAmD;AACxD;AACA;AACAS,gBAAAA,MAAM,GAAGC,OAAT;AACD;AACF,aAdD,MAcO;AACL,mBAASO,CAAT,GAAa,CAAb,EAAgBA,CAAC,GAAGpB,KAAK,CAACE,IAAN,CAAWC,MAA/B,EAAuCiB,CAAC,EAAxC,EAA4C;AAC1CP,gBAAAA,OAAO,CAACQ,IAAR,CAAarB,KAAK,CAACE,IAAN,CAAWkB,CAAX,CAAb;AACD;AACF;;AA7BE;AA+BH,iEACKpB,KADL,GAEMA,KAAK,CAACsB,MAAN,GAAe;AAACC,cAAAA,OAAO,EAAEC,MAAM,CAACC,IAAP,CAAYzB,KAAK,CAACsB,MAAlB;AAAV,aAAf,GAAsD,EAF5D;AAGEX,cAAAA,QAAQ,EAARA,QAHF;AAIE;AACAT,cAAAA,IAAI,EAAEU,MAAM,GAAGA,MAAH,GAAYC;AAL1B;;AA/BG;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;;AAAA;;AAAA;AAAA;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAyCea,iB;;;;;qGAAf;AAAA;;AAAA;AAAA;AAAA;AAAA;AACLC,YAAAA,IADK,QACLA,IADK,sBAELC,OAFK,EAELA,OAFK,6BAEK,EAFL,yCAGLC,WAHK,EAGLA,WAHK,iCAGS,EAHT;AAULD,YAAAA,OAAO,IAAIE,gBAAJ,EAAgBC,cAAhB,6CAA8BH,OAA9B,EAAP;AACAC,YAAAA,WAAW;AACTG,cAAAA,GAAG,EAAExD,kBADI;AAETM,cAAAA,IAAI,EAAEH,mBAFG;AAGTsD,cAAAA,QAAQ,EAAE;AAHD,eAINJ,WAJM,CAAX;AAXK;AAAA,mBAkBuB,0BAAeF,IAAf,EAAqBC,OAArB,EAA8BC,WAA9B,CAlBvB;;AAAA;AAkBCK,YAAAA,aAlBD;AAmBCC,YAAAA,gBAnBD,GAmBoBtC,oBAAoB,CAACqC,aAAD,EAAgB;AAAC1B,cAAAA,IAAI,EAAEmB,IAAI,CAACnB;AAAZ,aAAhB,CAnBxC;AAAA,8CAqBEE,SAAS,CAACyB,gBAAD,EAAmBR,IAAI,CAACS,IAAxB,CArBX;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;AAwBA,SAASC,eAAT,QAMsB;AAAA,MAL3BC,OAK2B,SAL3BA,OAK2B;AAAA,MAJ3BC,SAI2B,SAJ3BA,SAI2B;AAC3B,SAAO,IAAIC,OAAJ,CAAY,UAACC,OAAD,EAAUC,MAAV,EAAqB;AAAA,QAC/BxC,IAD+B,GACvBoC,OADuB,CAC/BpC,IAD+B;AAGtC,QAAIyC,MAAJ;AACA,QAAIC,SAAJ;;AACA,QAAIpD,aAAa,CAACU,IAAD,CAAjB,EAAyB;AACvByC,MAAAA,MAAM,GAAGE,2BAAgBC,QAAzB;AACAF,MAAAA,SAAS,GAAGG,kCAAZ;AACD,KAHD,MAGO,IAAI1D,WAAW,CAACa,IAAD,CAAf,EAAuB;AAC5ByC,MAAAA,MAAM,GAAGE,2BAAgBG,GAAzB;AACAJ,MAAAA,SAAS,GAAGK,+BAAZ;AACD,KAHM,MAGA,IAAIpE,SAAS,CAACqB,IAAD,CAAb,EAAqB;AAC1ByC,MAAAA,MAAM,GAAGE,2BAAgBK,OAAzB;AACAN,MAAAA,SAAS,GAAGO,6BAAZ;AACD;;AAED,QAAIR,MAAM,IAAIC,SAAd,EAAyB;AACvB,UAAMhC,MAAM,GAAGgC,SAAS,CAAC1C,IAAD,CAAxB;AAEAuC,MAAAA,OAAO,+CACFF,SADE,IAEL;AACErC,QAAAA,IAAI,EAAEU,MADR;AAEEjB,QAAAA,IAAI,EAAE;AACJyD,UAAAA,KAAK,EAAEd,OAAO,CAAC3B,QADX;AAEJgC,UAAAA,MAAM,EAANA;AAFI;AAFR,OAFK,GAAP;AAUD;;AAEDD,IAAAA,MAAM,CAAC,qBAAD,CAAN;AACD,GAhCM,CAAP;AAiCD;;AAEM,SAASW,kBAAT,CAA4Bd,SAA5B,EAA+E;AACpF;AACA,MAAMe,UAAU,GAAGf,SAAS,CAACgB,MAAV,CAIjB,UAACC,IAAD,EAAO7B,IAAP,EAAgB;AAAA,QACPzB,IADO,GACOyB,IADP,CACPzB,IADO;AAAA,QACDP,IADC,GACOgC,IADP,CACDhC,IADC;;AAEd,QAAI,CAAAA,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAEgD,MAAN,MAAiBE,2BAAgBC,QAArC,EAA+C;AAC7C;AACAU,MAAAA,IAAI,CAACC,UAAL,CAAgBpC,IAAhB,iCACKnB,IADL;AAEEwD,QAAAA,OAAO,EAAE;AACPC,UAAAA,SAAS,EAAE,EAAEzD,IAAI,CAACR,MAAL,IAAeQ,IAAI,CAACR,MAAL,CAAYkE,QAA7B;AADJ;AAFX;AAMD,KARD,MAQO,IAAIf,2BAAgBlD,IAAhB,aAAgBA,IAAhB,uBAAgBA,IAAI,CAAEgD,MAAtB,CAAJ,EAAmC;AACxC;AACA,UAAMkB,UAAU,GAAG;AACjB3D,QAAAA,IAAI,EAAJA,IADiB;AAEjBP,QAAAA,IAAI;AACFmE,UAAAA,EAAE,EAAE,CAAAnE,IAAI,SAAJ,IAAAA,IAAI,WAAJ,YAAAA,IAAI,CAAEmE,EAAN,KAAY,2BAAe,CAAf;AADd,WAEEnE,IAAI,IAAI,EAFV;AAFa,OAAnB;AAOA6D,MAAAA,IAAI,CAAC/D,QAAL,CAAc4B,IAAd,CAAmBwC,UAAnB;AACD;;AACD,WAAOL,IAAP;AACD,GA1BgB,EA2BjB;AAAC/D,IAAAA,QAAQ,EAAE,EAAX;AAAegE,IAAAA,UAAU,EAAE;AAA3B,GA3BiB,CAAnB,CAFoF,CAgCpF;AACA;;AACA,SAAOH,UAAU,CAACG,UAAX,CAAsBM,MAAtB,CAA6B;AAACtE,IAAAA,QAAQ,EAAE6D,UAAU,CAAC7D;AAAtB,GAA7B,CAAP;AACD","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"]}
|
package/dist/index.d.ts
ADDED
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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
|
package/dist/types.d.ts
ADDED
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
|
+
}
|