@kepler.gl/processors 3.3.0-alpha.16 → 3.3.0-alpha.18

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 (40) hide show
  1. package/dist/cjs/data-processor.js +19 -4
  2. package/dist/cjs/export/dataset-to-geojson.js +157 -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/sql-js.spec.js +48 -0
  9. package/dist/cjs/export/vector-export.js +187 -0
  10. package/dist/cjs/export/vector-export.spec.js +666 -0
  11. package/dist/cjs/file-handler.js +343 -45
  12. package/dist/cjs/index.js +32 -1
  13. package/dist/cjs/types.js +1 -1
  14. package/dist/data-processor.d.ts +0 -13
  15. package/dist/esm/data-processor.js +18 -3
  16. package/dist/esm/export/dataset-to-geojson.js +151 -0
  17. package/dist/esm/export/geopackage-writer.js +381 -0
  18. package/dist/esm/export/geoparquet-writer.js +336 -0
  19. package/dist/esm/export/kml-writer.js +341 -0
  20. package/dist/esm/export/shapefile-writer.js +701 -0
  21. package/dist/esm/export/sql-js.js +80 -0
  22. package/dist/esm/export/sql-js.spec.js +45 -0
  23. package/dist/esm/export/vector-export.js +176 -0
  24. package/dist/esm/export/vector-export.spec.js +651 -0
  25. package/dist/esm/file-handler.js +343 -46
  26. package/dist/esm/index.js +2 -1
  27. package/dist/esm/types.js +1 -1
  28. package/dist/export/dataset-to-geojson.d.ts +12 -0
  29. package/dist/export/geopackage-writer.d.ts +28 -0
  30. package/dist/export/geoparquet-writer.d.ts +7 -0
  31. package/dist/export/kml-writer.d.ts +13 -0
  32. package/dist/export/shapefile-writer.d.ts +28 -0
  33. package/dist/export/sql-js.d.ts +8 -0
  34. package/dist/export/sql-js.spec.d.ts +1 -0
  35. package/dist/export/vector-export.d.ts +22 -0
  36. package/dist/export/vector-export.spec.d.ts +1 -0
  37. package/dist/file-handler.d.ts +21 -1
  38. package/dist/index.d.ts +2 -0
  39. package/dist/types.d.ts +6 -0
  40. package/package.json +13 -8
@@ -0,0 +1,666 @@
1
+ "use strict";
2
+
3
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
4
+ var _typeof = require("@babel/runtime/helpers/typeof");
5
+ var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
6
+ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
7
+ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
8
+ var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
9
+ var _gis = require("@loaders.gl/gis");
10
+ var _schemaUtils = require("@loaders.gl/schema-utils");
11
+ var _shapefile = require("@loaders.gl/shapefile");
12
+ var _constants = require("@kepler.gl/constants");
13
+ var _utils = require("@kepler.gl/utils");
14
+ var _apacheArrow = require("apache-arrow");
15
+ var _vectorExport = require("./vector-export");
16
+ var _shapefileWriter = require("./shapefile-writer");
17
+ var _sqlJs = require("./sql-js");
18
+ 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" != _typeof(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); }
19
+ 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; }
20
+ function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2["default"])(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; } // SPDX-License-Identifier: MIT
21
+ // Copyright contributors to the kepler.gl project
22
+ var fields = [{
23
+ name: 'name',
24
+ type: _constants.ALL_FIELD_TYPES.string
25
+ }, {
26
+ name: 'secret',
27
+ type: _constants.ALL_FIELD_TYPES.string
28
+ }, {
29
+ name: 'lat',
30
+ type: _constants.ALL_FIELD_TYPES.real
31
+ }, {
32
+ name: 'lng',
33
+ type: _constants.ALL_FIELD_TYPES.real
34
+ }];
35
+ var rows = [['Harbor', 'hidden-value', 37.8, -122.4], ['Pier', 'also-hidden', 37.81, -122.41]];
36
+ var fieldPairs = [{
37
+ defaultName: 'point',
38
+ pair: {
39
+ lat: {
40
+ fieldIdx: 2,
41
+ value: 'lat'
42
+ },
43
+ lng: {
44
+ fieldIdx: 3,
45
+ value: 'lng'
46
+ }
47
+ },
48
+ suffix: ['lat', 'lng']
49
+ }];
50
+ function container() {
51
+ return (0, _utils.createDataContainer)(rows);
52
+ }
53
+ describe('dataset export', function () {
54
+ test('omits columns hidden in the attribute table', function () {
55
+ var collection = (0, _vectorExport.datasetToFeatureCollection)(container(), fields, {
56
+ hiddenColumns: ['secret'],
57
+ fieldPairs: fieldPairs
58
+ });
59
+ expect(collection.features).toHaveLength(2);
60
+ expect(collection.features[0].geometry).toEqual({
61
+ type: 'Point',
62
+ coordinates: [-122.4, 37.8]
63
+ });
64
+ expect(collection.features[0].properties).toEqual({
65
+ name: 'Harbor',
66
+ lat: 37.8,
67
+ lng: -122.4
68
+ });
69
+ expect(collection.features[0].properties).not.toHaveProperty('secret');
70
+ });
71
+ test('writes geojson, kml, kmz, shapefile, geopackage, and geoparquet', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee() {
72
+ var shared, geojson, parsed, kml, kmz, shapefile, shapefileBytes, geopackage, SQL, db, exported, columns, columnNames, geoparquet, parquetBytes;
73
+ return _regenerator["default"].wrap(function _callee$(_context) {
74
+ while (1) switch (_context.prev = _context.next) {
75
+ case 0:
76
+ shared = {
77
+ data: container(),
78
+ fields: fields,
79
+ fieldPairs: fieldPairs,
80
+ hiddenColumns: ['secret'],
81
+ layerName: 'places'
82
+ };
83
+ _context.next = 3;
84
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
85
+ dataType: _constants.EXPORT_DATA_TYPE.GEOJSON
86
+ }));
87
+ case 3:
88
+ geojson = _context.sent;
89
+ parsed = JSON.parse(String(geojson.data));
90
+ expect(parsed.features[1].properties.name).toBe('Pier');
91
+ expect(parsed.features[1].properties.secret).toBeUndefined();
92
+ expect(geojson.extension).toBe('geojson');
93
+ _context.next = 10;
94
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
95
+ dataType: _constants.EXPORT_DATA_TYPE.KML
96
+ }));
97
+ case 10:
98
+ kml = _context.sent;
99
+ expect(String(kml.data)).toContain('<coordinates>-122.4,37.8</coordinates>');
100
+ expect(String(kml.data)).not.toContain('hidden-value');
101
+ _context.next = 15;
102
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
103
+ dataType: _constants.EXPORT_DATA_TYPE.KMZ
104
+ }));
105
+ case 15:
106
+ kmz = _context.sent;
107
+ expect(Buffer.from(kmz.data).includes(Buffer.from('doc.kml'))).toBe(true);
108
+ _context.next = 19;
109
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
110
+ dataType: _constants.EXPORT_DATA_TYPE.SHAPEFILE
111
+ }));
112
+ case 19:
113
+ shapefile = _context.sent;
114
+ shapefileBytes = Buffer.from(shapefile.data);
115
+ expect(shapefile.extension).toBe('zip');
116
+ expect(shapefileBytes.includes(Buffer.from('places.shp'))).toBe(true);
117
+ expect(shapefileBytes.includes(Buffer.from('places.dbf'))).toBe(true);
118
+ expect(shapefileBytes.includes(Buffer.from('hidden-value'))).toBe(false);
119
+ _context.next = 27;
120
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
121
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPACKAGE
122
+ }));
123
+ case 27:
124
+ geopackage = _context.sent;
125
+ _context.next = 30;
126
+ return (0, _sqlJs.loadSqlJs)();
127
+ case 30:
128
+ SQL = _context.sent;
129
+ db = new SQL.Database(new Uint8Array(geopackage.data));
130
+ exported = db.exec('SELECT name FROM places');
131
+ expect(exported[0].values.map(function (row) {
132
+ return row[0];
133
+ })).toEqual(['Harbor', 'Pier']);
134
+ columns = db.exec('PRAGMA table_info(places)');
135
+ columnNames = columns[0].values.map(function (row) {
136
+ return row[1];
137
+ });
138
+ expect(columnNames).not.toContain('secret');
139
+ db.close();
140
+ _context.next = 40;
141
+ return (0, _vectorExport.encodeDatasetExport)(_objectSpread(_objectSpread({}, shared), {}, {
142
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPARQUET
143
+ }));
144
+ case 40:
145
+ geoparquet = _context.sent;
146
+ parquetBytes = Buffer.from(geoparquet.data);
147
+ expect(parquetBytes.subarray(0, 4).toString()).toBe('PAR1');
148
+ expect(parquetBytes.includes(Buffer.from('"encoding":"WKB"'))).toBe(true);
149
+ expect(parquetBytes.includes(Buffer.from('hidden-value'))).toBe(false);
150
+ case 45:
151
+ case "end":
152
+ return _context.stop();
153
+ }
154
+ }, _callee);
155
+ })));
156
+ test.each([{
157
+ dimension: '2D',
158
+ altitudes: [null, ''],
159
+ expectedZ: 0,
160
+ expectedCoordinates: [[-122.4, 37.8], [-122.41, 37.81]]
161
+ }, {
162
+ dimension: '3D',
163
+ altitudes: [12, 24],
164
+ expectedZ: 1,
165
+ expectedCoordinates: [[-122.4, 37.8, 12], [-122.41, 37.81, 24]]
166
+ }, {
167
+ dimension: 'mixed 2D and 3D',
168
+ altitudes: [12, null],
169
+ expectedZ: 2,
170
+ expectedCoordinates: [[-122.4, 37.8, 12], [-122.41, 37.81]]
171
+ }])('writes $dimension GeoPackage points with matching Z metadata', /*#__PURE__*/function () {
172
+ var _ref3 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee2(_ref2) {
173
+ var altitudes, expectedZ, expectedCoordinates, altitudeFields, altitudeFieldPairs, altitudeRows, geopackage, SQL, db, z, coordinates;
174
+ return _regenerator["default"].wrap(function _callee2$(_context2) {
175
+ while (1) switch (_context2.prev = _context2.next) {
176
+ case 0:
177
+ altitudes = _ref2.altitudes, expectedZ = _ref2.expectedZ, expectedCoordinates = _ref2.expectedCoordinates;
178
+ altitudeFields = [].concat(fields, [{
179
+ name: 'altitude',
180
+ type: _constants.ALL_FIELD_TYPES.real
181
+ }]);
182
+ altitudeFieldPairs = [{
183
+ defaultName: 'point',
184
+ pair: {
185
+ lat: {
186
+ fieldIdx: 2,
187
+ value: 'lat'
188
+ },
189
+ lng: {
190
+ fieldIdx: 3,
191
+ value: 'lng'
192
+ },
193
+ altitude: {
194
+ fieldIdx: 4,
195
+ value: 'altitude'
196
+ }
197
+ },
198
+ suffix: ['lat', 'lng', 'altitude']
199
+ }];
200
+ altitudeRows = rows.map(function (row, index) {
201
+ return [].concat((0, _toConsumableArray2["default"])(row), [altitudes[index]]);
202
+ });
203
+ _context2.next = 6;
204
+ return (0, _vectorExport.encodeDatasetExport)({
205
+ data: (0, _utils.createDataContainer)(altitudeRows),
206
+ fields: altitudeFields,
207
+ fieldPairs: altitudeFieldPairs,
208
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPACKAGE,
209
+ layerName: 'places'
210
+ });
211
+ case 6:
212
+ geopackage = _context2.sent;
213
+ _context2.next = 9;
214
+ return (0, _sqlJs.loadSqlJs)();
215
+ case 9:
216
+ SQL = _context2.sent;
217
+ db = new SQL.Database(new Uint8Array(geopackage.data));
218
+ try {
219
+ z = db.exec('SELECT z FROM gpkg_geometry_columns')[0].values[0][0];
220
+ coordinates = db.exec('SELECT geom FROM places ORDER BY fid')[0].values.map(function (row) {
221
+ var blob = row[0];
222
+ var geometry = (0, _gis.convertWKBToGeometry)(blob.slice(8).buffer);
223
+ return geometry.type === 'Point' ? geometry.coordinates : null;
224
+ });
225
+ expect({
226
+ z: z,
227
+ coordinates: coordinates
228
+ }).toEqual({
229
+ z: expectedZ,
230
+ coordinates: expectedCoordinates
231
+ });
232
+ } finally {
233
+ db.close();
234
+ }
235
+ case 12:
236
+ case "end":
237
+ return _context2.stop();
238
+ }
239
+ }, _callee2);
240
+ }));
241
+ return function (_x) {
242
+ return _ref3.apply(this, arguments);
243
+ };
244
+ }());
245
+ test('rejects mixed geometry families when exporting a shapefile', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee3() {
246
+ var geometryFields, geometryRows;
247
+ return _regenerator["default"].wrap(function _callee3$(_context3) {
248
+ while (1) switch (_context3.prev = _context3.next) {
249
+ case 0:
250
+ geometryFields = [{
251
+ name: '_geojson',
252
+ type: _constants.ALL_FIELD_TYPES.geojson
253
+ }, {
254
+ name: 'label',
255
+ type: _constants.ALL_FIELD_TYPES.string
256
+ }];
257
+ geometryRows = [[{
258
+ type: 'Point',
259
+ coordinates: [0, 0]
260
+ }, 'point'], [{
261
+ type: 'LineString',
262
+ coordinates: [[0, 0], [1, 1]]
263
+ }, 'line']];
264
+ _context3.next = 4;
265
+ return expect((0, _vectorExport.encodeDatasetExport)({
266
+ data: (0, _utils.createDataContainer)(geometryRows),
267
+ fields: geometryFields,
268
+ dataType: _constants.EXPORT_DATA_TYPE.SHAPEFILE,
269
+ layerName: 'mixed'
270
+ })).rejects.toThrow('Shapefile export requires all geometries to have the same shape family.');
271
+ case 4:
272
+ case "end":
273
+ return _context3.stop();
274
+ }
275
+ }, _callee3);
276
+ })));
277
+ test('rounds noisy and tiny DBF numbers at the maximum supported precision', function () {
278
+ var _DBFLoader$parseSync;
279
+ var values = [0.1 + 0.2, 1e-7, -1e-7, 1e-16, -1e-16, null];
280
+ var collection = {
281
+ type: 'FeatureCollection',
282
+ features: values.map(function (value, index) {
283
+ return {
284
+ type: 'Feature',
285
+ geometry: {
286
+ type: 'Point',
287
+ coordinates: [index, index]
288
+ },
289
+ properties: {
290
+ value: value
291
+ }
292
+ };
293
+ })
294
+ };
295
+ var _writeShapefile = (0, _shapefileWriter.writeShapefile)(collection),
296
+ dbf = _writeShapefile.dbf;
297
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
298
+ var headerLength = view.getUint16(8, true);
299
+ var recordLength = view.getUint16(10, true);
300
+ var fieldLength = dbf[32 + 16];
301
+ var decimalCount = dbf[32 + 17];
302
+ var decoder = new TextDecoder();
303
+ var cells = values.map(function (_, index) {
304
+ var start = headerLength + index * recordLength + 1;
305
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
306
+ });
307
+ expect({
308
+ fieldLength: fieldLength,
309
+ decimalCount: decimalCount
310
+ }).toEqual({
311
+ fieldLength: 18,
312
+ decimalCount: 15
313
+ });
314
+ expect(cells).toEqual(['0.300000000000000', '0.000000100000000', '-0.000000100000000', '0.000000000000000', '0.000000000000000', '']);
315
+ expect(cells.filter(Boolean).every(function (cell) {
316
+ return /^-?\d+(?:\.\d+)?$/.test(cell);
317
+ })).toBe(true);
318
+ var parsed = (_DBFLoader$parseSync = _shapefile.DBFLoader.parseSync) === null || _DBFLoader$parseSync === void 0 ? void 0 : _DBFLoader$parseSync.call(_shapefile.DBFLoader, dbf.buffer, {
319
+ dbf: {
320
+ shape: 'rows'
321
+ }
322
+ });
323
+ expect(parsed.map(function (row) {
324
+ return row.value;
325
+ })).toEqual([0.3, 1e-7, -1e-7, 0, 0, null]);
326
+ });
327
+ test('uses the highest common precision that fits mixed magnitudes after rounding', function () {
328
+ var _DBFLoader$parseSync2;
329
+ var values = [-1234567890123456, 999.9999, -12.3456, null];
330
+ var collection = {
331
+ type: 'FeatureCollection',
332
+ features: values.map(function (value, index) {
333
+ return {
334
+ type: 'Feature',
335
+ geometry: {
336
+ type: 'Point',
337
+ coordinates: [index, index]
338
+ },
339
+ properties: {
340
+ value: value
341
+ }
342
+ };
343
+ })
344
+ };
345
+ var _writeShapefile2 = (0, _shapefileWriter.writeShapefile)(collection),
346
+ dbf = _writeShapefile2.dbf;
347
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
348
+ var headerLength = view.getUint16(8, true);
349
+ var recordLength = view.getUint16(10, true);
350
+ var fieldLength = dbf[32 + 16];
351
+ var decimalCount = dbf[32 + 17];
352
+ var decoder = new TextDecoder();
353
+ var cells = values.map(function (_, index) {
354
+ var start = headerLength + index * recordLength + 1;
355
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
356
+ });
357
+ expect({
358
+ fieldLength: fieldLength,
359
+ decimalCount: decimalCount
360
+ }).toEqual({
361
+ fieldLength: 19,
362
+ decimalCount: 1
363
+ });
364
+ expect(cells).toEqual(['-1234567890123456.0', '1000.0', '-12.3', '']);
365
+ var parsed = (_DBFLoader$parseSync2 = _shapefile.DBFLoader.parseSync) === null || _DBFLoader$parseSync2 === void 0 ? void 0 : _DBFLoader$parseSync2.call(_shapefile.DBFLoader, dbf.buffer, {
366
+ dbf: {
367
+ shape: 'rows'
368
+ }
369
+ });
370
+ expect(parsed.map(function (row) {
371
+ return row.value;
372
+ })).toEqual([-1234567890123456, 1000, -12.3, null]);
373
+ });
374
+ test('keeps large positive and negative integers in numeric fields', function () {
375
+ var values = [1e18, -1e17, null];
376
+ var collection = {
377
+ type: 'FeatureCollection',
378
+ features: values.map(function (value, index) {
379
+ return {
380
+ type: 'Feature',
381
+ geometry: {
382
+ type: 'Point',
383
+ coordinates: [index, index]
384
+ },
385
+ properties: {
386
+ value: value
387
+ }
388
+ };
389
+ })
390
+ };
391
+ var _writeShapefile3 = (0, _shapefileWriter.writeShapefile)(collection),
392
+ dbf = _writeShapefile3.dbf;
393
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
394
+ var headerLength = view.getUint16(8, true);
395
+ var recordLength = view.getUint16(10, true);
396
+ var fieldLength = dbf[32 + 16];
397
+ var decimalCount = dbf[32 + 17];
398
+ var decoder = new TextDecoder();
399
+ var cells = values.map(function (_, index) {
400
+ var start = headerLength + index * recordLength + 1;
401
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
402
+ });
403
+ expect({
404
+ fieldLength: fieldLength,
405
+ decimalCount: decimalCount
406
+ }).toEqual({
407
+ fieldLength: 19,
408
+ decimalCount: 0
409
+ });
410
+ expect(cells).toEqual(['1000000000000000000', '-100000000000000000', '']);
411
+ });
412
+ test.each([[1e19, 20], [-1e18, 20], [1e21, 22]])('rejects the DBF number %s when its rounded integer needs %i bytes', function (value, width) {
413
+ var collection = {
414
+ type: 'FeatureCollection',
415
+ features: [{
416
+ type: 'Feature',
417
+ geometry: {
418
+ type: 'Point',
419
+ coordinates: [0, 0]
420
+ },
421
+ properties: {
422
+ value: value
423
+ }
424
+ }]
425
+ };
426
+ expect(function () {
427
+ return (0, _shapefileWriter.writeShapefile)(collection);
428
+ }).toThrow("DBF numeric field \"value\" requires ".concat(width, " bytes at zero decimal places; ") + 'dBASE III numeric fields support at most 19.');
429
+ });
430
+ test('keeps mixed finite and non-finite values in a DBF text field', function () {
431
+ var values = [1, Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, null];
432
+ var collection = {
433
+ type: 'FeatureCollection',
434
+ features: values.map(function (value, index) {
435
+ return {
436
+ type: 'Feature',
437
+ geometry: {
438
+ type: 'Point',
439
+ coordinates: [index, index]
440
+ },
441
+ properties: {
442
+ value: value
443
+ }
444
+ };
445
+ })
446
+ };
447
+ var _writeShapefile4 = (0, _shapefileWriter.writeShapefile)(collection),
448
+ dbf = _writeShapefile4.dbf;
449
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
450
+ var headerLength = view.getUint16(8, true);
451
+ var recordLength = view.getUint16(10, true);
452
+ var fieldLength = dbf[32 + 16];
453
+ var decoder = new TextDecoder();
454
+ var cells = values.map(function (_, index) {
455
+ var start = headerLength + index * recordLength + 1;
456
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
457
+ });
458
+ expect(String.fromCharCode(dbf[32 + 11])).toBe('C');
459
+ expect(cells).toEqual(['1', 'NaN', 'Infinity', '-Infinity', '']);
460
+ });
461
+ test('writes geoparquet string columns the importer can read', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee4() {
462
+ var _arrowTable$getChild, _arrowTable$getChild2, _schema$fields$find, _schema$fields$find2;
463
+ var geoparquet, specifier, imported, api, wasmTable, arrowTable, schema;
464
+ return _regenerator["default"].wrap(function _callee4$(_context4) {
465
+ while (1) switch (_context4.prev = _context4.next) {
466
+ case 0:
467
+ _context4.next = 2;
468
+ return (0, _vectorExport.encodeDatasetExport)({
469
+ data: container(),
470
+ fields: fields,
471
+ fieldPairs: fieldPairs,
472
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPARQUET,
473
+ layerName: 'places'
474
+ });
475
+ case 2:
476
+ geoparquet = _context4.sent;
477
+ specifier = 'parquet-wasm/node';
478
+ _context4.next = 6;
479
+ return function (specifier) {
480
+ return new Promise(function (r) {
481
+ return r("".concat(specifier));
482
+ }).then(function (s) {
483
+ return _interopRequireWildcard(require(s));
484
+ });
485
+ }(specifier);
486
+ case 6:
487
+ imported = _context4.sent;
488
+ api = imported.readParquet ? imported : imported["default"];
489
+ if (api !== null && api !== void 0 && api.readParquet) {
490
+ _context4.next = 10;
491
+ break;
492
+ }
493
+ throw new Error('parquet-wasm failed to load');
494
+ case 10:
495
+ wasmTable = api.readParquet(new Uint8Array(geoparquet.data));
496
+ arrowTable = (0, _apacheArrow.tableFromIPC)(wasmTable.intoIPCStream());
497
+ expect((_arrowTable$getChild = arrowTable.getChild('name')) === null || _arrowTable$getChild === void 0 ? void 0 : _arrowTable$getChild.toArray()).toEqual(['Harbor', 'Pier']);
498
+ expect((_arrowTable$getChild2 = arrowTable.getChild('geometry')) === null || _arrowTable$getChild2 === void 0 ? void 0 : _arrowTable$getChild2.get(0)).toBeInstanceOf(Uint8Array);
499
+ schema = (0, _schemaUtils.convertArrowToSchema)(arrowTable.schema);
500
+ expect((_schema$fields$find = schema.fields.find(function (field) {
501
+ return field.name === 'geometry';
502
+ })) === null || _schema$fields$find === void 0 ? void 0 : _schema$fields$find.type).toBe('binary');
503
+ expect((_schema$fields$find2 = schema.fields.find(function (field) {
504
+ return field.name === 'name';
505
+ })) === null || _schema$fields$find2 === void 0 ? void 0 : _schema$fields$find2.type).toBe('utf8');
506
+ case 17:
507
+ case "end":
508
+ return _context4.stop();
509
+ }
510
+ }, _callee4);
511
+ })));
512
+ test('writes typed integer fields without reclassifying integer-valued real fields', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee5() {
513
+ var _count$length, _arrowTable$getChild3, _arrowTable$getChild4, _arrowTable$getChild5;
514
+ var typedFields, typedRows, geoparquet, specifier, imported, api, wasmTable, arrowTable, count;
515
+ return _regenerator["default"].wrap(function _callee5$(_context5) {
516
+ while (1) switch (_context5.prev = _context5.next) {
517
+ case 0:
518
+ typedFields = [{
519
+ name: 'count',
520
+ type: _constants.ALL_FIELD_TYPES.integer
521
+ }, {
522
+ name: 'measurement',
523
+ type: _constants.ALL_FIELD_TYPES.real
524
+ }, {
525
+ name: 'unsafe_count',
526
+ type: _constants.ALL_FIELD_TYPES.integer
527
+ }, {
528
+ name: 'out_of_range_count',
529
+ type: _constants.ALL_FIELD_TYPES.integer
530
+ }, {
531
+ name: 'lat',
532
+ type: _constants.ALL_FIELD_TYPES.real
533
+ }, {
534
+ name: 'lng',
535
+ type: _constants.ALL_FIELD_TYPES.real
536
+ }];
537
+ typedRows = [[1, 1, Number.MAX_SAFE_INTEGER + 1, 9223372036854775808n, 37.8, -122.4], [null, 2, null, null, 37.81, -122.41], [2147483648, 3, null, null, 37.82, -122.42], [Number.MAX_SAFE_INTEGER, 4, null, null, 37.83, -122.43]];
538
+ _context5.next = 4;
539
+ return (0, _vectorExport.encodeDatasetExport)({
540
+ data: (0, _utils.createDataContainer)(typedRows),
541
+ fields: typedFields,
542
+ fieldPairs: [{
543
+ defaultName: 'point',
544
+ pair: {
545
+ lat: {
546
+ fieldIdx: 4,
547
+ value: 'lat'
548
+ },
549
+ lng: {
550
+ fieldIdx: 5,
551
+ value: 'lng'
552
+ }
553
+ },
554
+ suffix: ['lat', 'lng']
555
+ }],
556
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPARQUET,
557
+ layerName: 'typed-numbers'
558
+ });
559
+ case 4:
560
+ geoparquet = _context5.sent;
561
+ specifier = 'parquet-wasm/node';
562
+ _context5.next = 8;
563
+ return function (specifier) {
564
+ return new Promise(function (r) {
565
+ return r("".concat(specifier));
566
+ }).then(function (s) {
567
+ return _interopRequireWildcard(require(s));
568
+ });
569
+ }(specifier);
570
+ case 8:
571
+ imported = _context5.sent;
572
+ api = imported.readParquet ? imported : imported["default"];
573
+ if (api !== null && api !== void 0 && api.readParquet) {
574
+ _context5.next = 12;
575
+ break;
576
+ }
577
+ throw new Error('parquet-wasm failed to load');
578
+ case 12:
579
+ wasmTable = api.readParquet(new Uint8Array(geoparquet.data));
580
+ arrowTable = (0, _apacheArrow.tableFromIPC)(wasmTable.intoIPCStream());
581
+ count = arrowTable.getChild('count');
582
+ expect(String(count === null || count === void 0 ? void 0 : count.type)).toBe('Int64');
583
+ expect(Array.from({
584
+ length: (_count$length = count === null || count === void 0 ? void 0 : count.length) !== null && _count$length !== void 0 ? _count$length : 0
585
+ }, function (_, index) {
586
+ return count === null || count === void 0 ? void 0 : count.get(index);
587
+ })).toEqual([1n, null, 2147483648n, BigInt(Number.MAX_SAFE_INTEGER)]);
588
+ expect(String((_arrowTable$getChild3 = arrowTable.getChild('measurement')) === null || _arrowTable$getChild3 === void 0 ? void 0 : _arrowTable$getChild3.type)).toBe('Float64');
589
+ expect(String((_arrowTable$getChild4 = arrowTable.getChild('unsafe_count')) === null || _arrowTable$getChild4 === void 0 ? void 0 : _arrowTable$getChild4.type)).toBe('Float64');
590
+ expect(String((_arrowTable$getChild5 = arrowTable.getChild('out_of_range_count')) === null || _arrowTable$getChild5 === void 0 ? void 0 : _arrowTable$getChild5.type)).toBe('Utf8');
591
+ case 20:
592
+ case "end":
593
+ return _context5.stop();
594
+ }
595
+ }, _callee5);
596
+ })));
597
+ test.each(['gpkg_contents', 'gpkg_geometry_columns', 'sqlite_sequence'])('sanitizes the reserved GeoPackage layer name %s', /*#__PURE__*/function () {
598
+ var _ref7 = (0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee6(layerName) {
599
+ var geopackage, SQL, db, contents, exportedTable;
600
+ return _regenerator["default"].wrap(function _callee6$(_context6) {
601
+ while (1) switch (_context6.prev = _context6.next) {
602
+ case 0:
603
+ _context6.next = 2;
604
+ return (0, _vectorExport.encodeDatasetExport)({
605
+ data: container(),
606
+ fields: fields,
607
+ fieldPairs: fieldPairs,
608
+ dataType: _constants.EXPORT_DATA_TYPE.GEOPACKAGE,
609
+ layerName: layerName
610
+ });
611
+ case 2:
612
+ geopackage = _context6.sent;
613
+ _context6.next = 5;
614
+ return (0, _sqlJs.loadSqlJs)();
615
+ case 5:
616
+ SQL = _context6.sent;
617
+ db = new SQL.Database(new Uint8Array(geopackage.data));
618
+ try {
619
+ contents = db.exec('SELECT table_name FROM gpkg_contents');
620
+ exportedTable = String(contents[0].values[0][0]);
621
+ expect(exportedTable).not.toBe(layerName);
622
+ expect(exportedTable).not.toMatch(/^sqlite_/i);
623
+ expect(db.exec("SELECT COUNT(*) FROM \"".concat(exportedTable, "\""))[0].values[0][0]).toBe(2);
624
+ } finally {
625
+ db.close();
626
+ }
627
+ case 8:
628
+ case "end":
629
+ return _context6.stop();
630
+ }
631
+ }, _callee6);
632
+ }));
633
+ return function (_x2) {
634
+ return _ref7.apply(this, arguments);
635
+ };
636
+ }());
637
+ test('uses a geojson column as feature geometry and drops it from properties', /*#__PURE__*/(0, _asyncToGenerator2["default"])(/*#__PURE__*/_regenerator["default"].mark(function _callee7() {
638
+ var polygon, geoFields, geoRows, collection;
639
+ return _regenerator["default"].wrap(function _callee7$(_context7) {
640
+ while (1) switch (_context7.prev = _context7.next) {
641
+ case 0:
642
+ polygon = {
643
+ type: 'Polygon',
644
+ coordinates: [[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]]
645
+ };
646
+ geoFields = [{
647
+ name: '_geojson',
648
+ type: _constants.ALL_FIELD_TYPES.geojson
649
+ }, {
650
+ name: 'label',
651
+ type: _constants.ALL_FIELD_TYPES.string
652
+ }];
653
+ geoRows = [[polygon, 'block']];
654
+ collection = (0, _vectorExport.datasetToFeatureCollection)((0, _utils.createDataContainer)(geoRows), geoFields);
655
+ expect(collection.features[0].geometry).toEqual(polygon);
656
+ expect(collection.features[0].properties).toEqual({
657
+ label: 'block'
658
+ });
659
+ case 6:
660
+ case "end":
661
+ return _context7.stop();
662
+ }
663
+ }, _callee7);
664
+ })));
665
+ });
666
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_gis","require","_schemaUtils","_shapefile","_constants","_utils","_apacheArrow","_vectorExport","_shapefileWriter","_sqlJs","_interopRequireWildcard","e","t","WeakMap","r","n","__esModule","o","i","f","__proto__","_typeof","has","get","set","_t","hasOwnProperty","call","Object","defineProperty","getOwnPropertyDescriptor","ownKeys","keys","getOwnPropertySymbols","filter","enumerable","push","apply","_objectSpread","arguments","length","forEach","_defineProperty2","getOwnPropertyDescriptors","defineProperties","fields","name","type","ALL_FIELD_TYPES","string","real","rows","fieldPairs","defaultName","pair","lat","fieldIdx","value","lng","suffix","container","createDataContainer","describe","test","collection","datasetToFeatureCollection","hiddenColumns","expect","features","toHaveLength","geometry","toEqual","coordinates","properties","not","toHaveProperty","_asyncToGenerator2","_regenerator","mark","_callee","shared","geojson","parsed","kml","kmz","shapefile","shapefileBytes","geopackage","SQL","db","exported","columns","columnNames","geoparquet","parquetBytes","wrap","_callee$","_context","prev","next","data","layerName","encodeDatasetExport","dataType","EXPORT_DATA_TYPE","GEOJSON","sent","JSON","parse","String","toBe","secret","toBeUndefined","extension","KML","toContain","KMZ","Buffer","from","includes","SHAPEFILE","GEOPACKAGE","loadSqlJs","Database","Uint8Array","exec","values","map","row","close","GEOPARQUET","subarray","toString","stop","each","dimension","altitudes","expectedZ","expectedCoordinates","_ref3","_callee2","_ref2","altitudeFields","altitudeFieldPairs","altitudeRows","z","_callee2$","_context2","concat","altitude","index","_toConsumableArray2","blob","convertWKBToGeometry","slice","buffer","_x","_callee3","geometryFields","geometryRows","_callee3$","_context3","rejects","toThrow","_DBFLoader$parseSync","_writeShapefile","writeShapefile","dbf","view","DataView","byteOffset","byteLength","headerLength","getUint16","recordLength","fieldLength","decimalCount","decoder","TextDecoder","cells","_","start","decode","trim","Boolean","every","cell","DBFLoader","parseSync","shape","_DBFLoader$parseSync2","_writeShapefile2","_writeShapefile3","width","Number","NaN","POSITIVE_INFINITY","NEGATIVE_INFINITY","_writeShapefile4","fromCharCode","_callee4","_arrowTable$getChild","_arrowTable$getChild2","_schema$fields$find","_schema$fields$find2","specifier","imported","api","wasmTable","arrowTable","schema","_callee4$","_context4","Promise","then","s","readParquet","Error","tableFromIPC","intoIPCStream","getChild","toArray","toBeInstanceOf","convertArrowToSchema","find","field","_callee5","_count$length","_arrowTable$getChild3","_arrowTable$getChild4","_arrowTable$getChild5","typedFields","typedRows","count","_callee5$","_context5","integer","MAX_SAFE_INTEGER","Array","BigInt","_ref7","_callee6","contents","exportedTable","_callee6$","_context6","toMatch","_x2","_callee7","polygon","geoFields","geoRows","_callee7$","_context7","label"],"sources":["../../../src/export/vector-export.spec.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {convertWKBToGeometry} from '@loaders.gl/gis';\nimport {convertArrowToSchema} from '@loaders.gl/schema-utils';\nimport {DBFLoader} from '@loaders.gl/shapefile';\nimport {ALL_FIELD_TYPES, EXPORT_DATA_TYPE} from '@kepler.gl/constants';\nimport {Field} from '@kepler.gl/types';\nimport {createDataContainer} from '@kepler.gl/utils';\nimport {tableFromIPC} from 'apache-arrow';\nimport type {FeatureCollection} from 'geojson';\n\nimport {datasetToFeatureCollection, encodeDatasetExport} from './vector-export';\nimport {writeShapefile} from './shapefile-writer';\nimport {loadSqlJs} from './sql-js';\n\nconst fields = [\n  {name: 'name', type: ALL_FIELD_TYPES.string},\n  {name: 'secret', type: ALL_FIELD_TYPES.string},\n  {name: 'lat', type: ALL_FIELD_TYPES.real},\n  {name: 'lng', type: ALL_FIELD_TYPES.real}\n] as Field[];\n\nconst rows = [\n  ['Harbor', 'hidden-value', 37.8, -122.4],\n  ['Pier', 'also-hidden', 37.81, -122.41]\n];\n\nconst fieldPairs = [\n  {\n    defaultName: 'point',\n    pair: {\n      lat: {fieldIdx: 2, value: 'lat'},\n      lng: {fieldIdx: 3, value: 'lng'}\n    },\n    suffix: ['lat', 'lng']\n  }\n];\n\nfunction container() {\n  return createDataContainer(rows);\n}\n\ndescribe('dataset export', () => {\n  test('omits columns hidden in the attribute table', () => {\n    const collection = datasetToFeatureCollection(container(), fields, {\n      hiddenColumns: ['secret'],\n      fieldPairs\n    });\n\n    expect(collection.features).toHaveLength(2);\n    expect(collection.features[0].geometry).toEqual({\n      type: 'Point',\n      coordinates: [-122.4, 37.8]\n    });\n    expect(collection.features[0].properties).toEqual({\n      name: 'Harbor',\n      lat: 37.8,\n      lng: -122.4\n    });\n    expect(collection.features[0].properties).not.toHaveProperty('secret');\n  });\n\n  test('writes geojson, kml, kmz, shapefile, geopackage, and geoparquet', async () => {\n    const shared = {\n      data: container(),\n      fields,\n      fieldPairs,\n      hiddenColumns: ['secret'],\n      layerName: 'places'\n    };\n\n    const geojson = await encodeDatasetExport({...shared, dataType: EXPORT_DATA_TYPE.GEOJSON});\n    const parsed = JSON.parse(String(geojson.data));\n    expect(parsed.features[1].properties.name).toBe('Pier');\n    expect(parsed.features[1].properties.secret).toBeUndefined();\n    expect(geojson.extension).toBe('geojson');\n\n    const kml = await encodeDatasetExport({...shared, dataType: EXPORT_DATA_TYPE.KML});\n    expect(String(kml.data)).toContain('<coordinates>-122.4,37.8</coordinates>');\n    expect(String(kml.data)).not.toContain('hidden-value');\n\n    const kmz = await encodeDatasetExport({...shared, dataType: EXPORT_DATA_TYPE.KMZ});\n    expect(Buffer.from(kmz.data as Uint8Array).includes(Buffer.from('doc.kml'))).toBe(true);\n\n    const shapefile = await encodeDatasetExport({\n      ...shared,\n      dataType: EXPORT_DATA_TYPE.SHAPEFILE\n    });\n    const shapefileBytes = Buffer.from(shapefile.data as Uint8Array);\n    expect(shapefile.extension).toBe('zip');\n    expect(shapefileBytes.includes(Buffer.from('places.shp'))).toBe(true);\n    expect(shapefileBytes.includes(Buffer.from('places.dbf'))).toBe(true);\n    expect(shapefileBytes.includes(Buffer.from('hidden-value'))).toBe(false);\n\n    const geopackage = await encodeDatasetExport({\n      ...shared,\n      dataType: EXPORT_DATA_TYPE.GEOPACKAGE\n    });\n    const SQL = await loadSqlJs();\n    const db = new SQL.Database(new Uint8Array(geopackage.data as Uint8Array));\n    const exported = db.exec('SELECT name FROM places');\n    expect(exported[0].values.map(row => row[0])).toEqual(['Harbor', 'Pier']);\n    const columns = db.exec('PRAGMA table_info(places)');\n    const columnNames = columns[0].values.map(row => row[1]);\n    expect(columnNames).not.toContain('secret');\n    db.close();\n\n    const geoparquet = await encodeDatasetExport({\n      ...shared,\n      dataType: EXPORT_DATA_TYPE.GEOPARQUET\n    });\n    const parquetBytes = Buffer.from(geoparquet.data as Uint8Array);\n    expect(parquetBytes.subarray(0, 4).toString()).toBe('PAR1');\n    expect(parquetBytes.includes(Buffer.from('\"encoding\":\"WKB\"'))).toBe(true);\n    expect(parquetBytes.includes(Buffer.from('hidden-value'))).toBe(false);\n  });\n\n  test.each([\n    {\n      dimension: '2D',\n      altitudes: [null, ''],\n      expectedZ: 0,\n      expectedCoordinates: [\n        [-122.4, 37.8],\n        [-122.41, 37.81]\n      ]\n    },\n    {\n      dimension: '3D',\n      altitudes: [12, 24],\n      expectedZ: 1,\n      expectedCoordinates: [\n        [-122.4, 37.8, 12],\n        [-122.41, 37.81, 24]\n      ]\n    },\n    {\n      dimension: 'mixed 2D and 3D',\n      altitudes: [12, null],\n      expectedZ: 2,\n      expectedCoordinates: [\n        [-122.4, 37.8, 12],\n        [-122.41, 37.81]\n      ]\n    }\n  ])(\n    'writes $dimension GeoPackage points with matching Z metadata',\n    async ({altitudes, expectedZ, expectedCoordinates}) => {\n      const altitudeFields = [\n        ...fields,\n        {name: 'altitude', type: ALL_FIELD_TYPES.real}\n      ] as Field[];\n      const altitudeFieldPairs = [\n        {\n          defaultName: 'point',\n          pair: {\n            lat: {fieldIdx: 2, value: 'lat'},\n            lng: {fieldIdx: 3, value: 'lng'},\n            altitude: {fieldIdx: 4, value: 'altitude'}\n          },\n          suffix: ['lat', 'lng', 'altitude']\n        }\n      ];\n      const altitudeRows = rows.map((row, index) => [...row, altitudes[index]]);\n      const geopackage = await encodeDatasetExport({\n        data: createDataContainer(altitudeRows),\n        fields: altitudeFields,\n        fieldPairs: altitudeFieldPairs,\n        dataType: EXPORT_DATA_TYPE.GEOPACKAGE,\n        layerName: 'places'\n      });\n      const SQL = await loadSqlJs();\n      const db = new SQL.Database(new Uint8Array(geopackage.data as Uint8Array));\n      try {\n        const z = db.exec('SELECT z FROM gpkg_geometry_columns')[0].values[0][0];\n        const coordinates = db.exec('SELECT geom FROM places ORDER BY fid')[0].values.map(row => {\n          const blob = row[0] as Uint8Array;\n          const geometry = convertWKBToGeometry(blob.slice(8).buffer);\n          return geometry.type === 'Point' ? geometry.coordinates : null;\n        });\n        expect({z, coordinates}).toEqual({z: expectedZ, coordinates: expectedCoordinates});\n      } finally {\n        db.close();\n      }\n    }\n  );\n\n  test('rejects mixed geometry families when exporting a shapefile', async () => {\n    const geometryFields = [\n      {name: '_geojson', type: ALL_FIELD_TYPES.geojson},\n      {name: 'label', type: ALL_FIELD_TYPES.string}\n    ] as Field[];\n    const geometryRows = [\n      [{type: 'Point', coordinates: [0, 0]}, 'point'],\n      [\n        {\n          type: 'LineString',\n          coordinates: [\n            [0, 0],\n            [1, 1]\n          ]\n        },\n        'line'\n      ]\n    ];\n\n    await expect(\n      encodeDatasetExport({\n        data: createDataContainer(geometryRows),\n        fields: geometryFields,\n        dataType: EXPORT_DATA_TYPE.SHAPEFILE,\n        layerName: 'mixed'\n      })\n    ).rejects.toThrow('Shapefile export requires all geometries to have the same shape family.');\n  });\n\n  test('rounds noisy and tiny DBF numbers at the maximum supported precision', () => {\n    const values = [0.1 + 0.2, 1e-7, -1e-7, 1e-16, -1e-16, null];\n    const collection: FeatureCollection = {\n      type: 'FeatureCollection',\n      features: values.map((value, index) => ({\n        type: 'Feature',\n        geometry: {type: 'Point', coordinates: [index, index]},\n        properties: {value}\n      }))\n    };\n\n    const {dbf} = writeShapefile(collection);\n    const view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);\n    const headerLength = view.getUint16(8, true);\n    const recordLength = view.getUint16(10, true);\n    const fieldLength = dbf[32 + 16];\n    const decimalCount = dbf[32 + 17];\n    const decoder = new TextDecoder();\n    const cells = values.map((_, index) => {\n      const start = headerLength + index * recordLength + 1;\n      return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();\n    });\n\n    expect({fieldLength, decimalCount}).toEqual({fieldLength: 18, decimalCount: 15});\n    expect(cells).toEqual([\n      '0.300000000000000',\n      '0.000000100000000',\n      '-0.000000100000000',\n      '0.000000000000000',\n      '0.000000000000000',\n      ''\n    ]);\n    expect(cells.filter(Boolean).every(cell => /^-?\\d+(?:\\.\\d+)?$/.test(cell))).toBe(true);\n\n    const parsed = DBFLoader.parseSync?.(dbf.buffer as ArrayBuffer, {\n      dbf: {shape: 'rows'}\n    }) as Array<{value: number | null}>;\n    expect(parsed.map(row => row.value)).toEqual([0.3, 1e-7, -1e-7, 0, 0, null]);\n  });\n\n  test('uses the highest common precision that fits mixed magnitudes after rounding', () => {\n    const values = [-1234567890123456, 999.9999, -12.3456, null];\n    const collection: FeatureCollection = {\n      type: 'FeatureCollection',\n      features: values.map((value, index) => ({\n        type: 'Feature',\n        geometry: {type: 'Point', coordinates: [index, index]},\n        properties: {value}\n      }))\n    };\n\n    const {dbf} = writeShapefile(collection);\n    const view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);\n    const headerLength = view.getUint16(8, true);\n    const recordLength = view.getUint16(10, true);\n    const fieldLength = dbf[32 + 16];\n    const decimalCount = dbf[32 + 17];\n    const decoder = new TextDecoder();\n    const cells = values.map((_, index) => {\n      const start = headerLength + index * recordLength + 1;\n      return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();\n    });\n\n    expect({fieldLength, decimalCount}).toEqual({fieldLength: 19, decimalCount: 1});\n    expect(cells).toEqual(['-1234567890123456.0', '1000.0', '-12.3', '']);\n\n    const parsed = DBFLoader.parseSync?.(dbf.buffer as ArrayBuffer, {\n      dbf: {shape: 'rows'}\n    }) as Array<{value: number | null}>;\n    expect(parsed.map(row => row.value)).toEqual([-1234567890123456, 1000, -12.3, null]);\n  });\n\n  test('keeps large positive and negative integers in numeric fields', () => {\n    const values = [1e18, -1e17, null];\n    const collection: FeatureCollection = {\n      type: 'FeatureCollection',\n      features: values.map((value, index) => ({\n        type: 'Feature',\n        geometry: {type: 'Point', coordinates: [index, index]},\n        properties: {value}\n      }))\n    };\n\n    const {dbf} = writeShapefile(collection);\n    const view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);\n    const headerLength = view.getUint16(8, true);\n    const recordLength = view.getUint16(10, true);\n    const fieldLength = dbf[32 + 16];\n    const decimalCount = dbf[32 + 17];\n    const decoder = new TextDecoder();\n    const cells = values.map((_, index) => {\n      const start = headerLength + index * recordLength + 1;\n      return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();\n    });\n\n    expect({fieldLength, decimalCount}).toEqual({fieldLength: 19, decimalCount: 0});\n    expect(cells).toEqual(['1000000000000000000', '-100000000000000000', '']);\n  });\n\n  test.each([\n    [1e19, 20],\n    [-1e18, 20],\n    [1e21, 22]\n  ])('rejects the DBF number %s when its rounded integer needs %i bytes', (value, width) => {\n    const collection: FeatureCollection = {\n      type: 'FeatureCollection',\n      features: [\n        {\n          type: 'Feature',\n          geometry: {type: 'Point', coordinates: [0, 0]},\n          properties: {value}\n        }\n      ]\n    };\n\n    expect(() => writeShapefile(collection)).toThrow(\n      `DBF numeric field \"value\" requires ${width} bytes at zero decimal places; ` +\n        'dBASE III numeric fields support at most 19.'\n    );\n  });\n\n  test('keeps mixed finite and non-finite values in a DBF text field', () => {\n    const values = [1, Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, null];\n    const collection: FeatureCollection = {\n      type: 'FeatureCollection',\n      features: values.map((value, index) => ({\n        type: 'Feature',\n        geometry: {type: 'Point', coordinates: [index, index]},\n        properties: {value}\n      }))\n    };\n\n    const {dbf} = writeShapefile(collection);\n    const view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);\n    const headerLength = view.getUint16(8, true);\n    const recordLength = view.getUint16(10, true);\n    const fieldLength = dbf[32 + 16];\n    const decoder = new TextDecoder();\n    const cells = values.map((_, index) => {\n      const start = headerLength + index * recordLength + 1;\n      return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();\n    });\n\n    expect(String.fromCharCode(dbf[32 + 11])).toBe('C');\n    expect(cells).toEqual(['1', 'NaN', 'Infinity', '-Infinity', '']);\n  });\n\n  test('writes geoparquet string columns the importer can read', async () => {\n    const geoparquet = await encodeDatasetExport({\n      data: container(),\n      fields,\n      fieldPairs,\n      dataType: EXPORT_DATA_TYPE.GEOPARQUET,\n      layerName: 'places'\n    });\n    const specifier = 'parquet-wasm/node';\n    const imported = (await import(specifier)) as {\n      readParquet?: (bytes: Uint8Array) => {intoIPCStream(): Uint8Array};\n      default?: {readParquet: (bytes: Uint8Array) => {intoIPCStream(): Uint8Array}};\n    };\n    const api = imported.readParquet ? imported : imported.default;\n    if (!api?.readParquet) {\n      throw new Error('parquet-wasm failed to load');\n    }\n    const wasmTable = api.readParquet(new Uint8Array(geoparquet.data as Uint8Array));\n    const arrowTable = tableFromIPC(wasmTable.intoIPCStream());\n\n    expect(arrowTable.getChild('name')?.toArray()).toEqual(['Harbor', 'Pier']);\n    expect(arrowTable.getChild('geometry')?.get(0)).toBeInstanceOf(Uint8Array);\n    const schema = convertArrowToSchema(arrowTable.schema);\n    expect(schema.fields.find(field => field.name === 'geometry')?.type).toBe('binary');\n    expect(schema.fields.find(field => field.name === 'name')?.type).toBe('utf8');\n  });\n\n  test('writes typed integer fields without reclassifying integer-valued real fields', async () => {\n    const typedFields = [\n      {name: 'count', type: ALL_FIELD_TYPES.integer},\n      {name: 'measurement', type: ALL_FIELD_TYPES.real},\n      {name: 'unsafe_count', type: ALL_FIELD_TYPES.integer},\n      {name: 'out_of_range_count', type: ALL_FIELD_TYPES.integer},\n      {name: 'lat', type: ALL_FIELD_TYPES.real},\n      {name: 'lng', type: ALL_FIELD_TYPES.real}\n    ] as Field[];\n    const typedRows = [\n      [1, 1, Number.MAX_SAFE_INTEGER + 1, 9223372036854775808n, 37.8, -122.4],\n      [null, 2, null, null, 37.81, -122.41],\n      [2147483648, 3, null, null, 37.82, -122.42],\n      [Number.MAX_SAFE_INTEGER, 4, null, null, 37.83, -122.43]\n    ];\n    const geoparquet = await encodeDatasetExport({\n      data: createDataContainer(typedRows),\n      fields: typedFields,\n      fieldPairs: [\n        {\n          defaultName: 'point',\n          pair: {\n            lat: {fieldIdx: 4, value: 'lat'},\n            lng: {fieldIdx: 5, value: 'lng'}\n          },\n          suffix: ['lat', 'lng']\n        }\n      ],\n      dataType: EXPORT_DATA_TYPE.GEOPARQUET,\n      layerName: 'typed-numbers'\n    });\n    const specifier = 'parquet-wasm/node';\n    const imported = (await import(specifier)) as {\n      readParquet?: (bytes: Uint8Array) => {intoIPCStream(): Uint8Array};\n      default?: {readParquet: (bytes: Uint8Array) => {intoIPCStream(): Uint8Array}};\n    };\n    const api = imported.readParquet ? imported : imported.default;\n    if (!api?.readParquet) {\n      throw new Error('parquet-wasm failed to load');\n    }\n    const wasmTable = api.readParquet(new Uint8Array(geoparquet.data as Uint8Array));\n    const arrowTable = tableFromIPC(wasmTable.intoIPCStream());\n\n    const count = arrowTable.getChild('count');\n    expect(String(count?.type)).toBe('Int64');\n    expect(Array.from({length: count?.length ?? 0}, (_, index) => count?.get(index))).toEqual([\n      1n,\n      null,\n      2147483648n,\n      BigInt(Number.MAX_SAFE_INTEGER)\n    ]);\n    expect(String(arrowTable.getChild('measurement')?.type)).toBe('Float64');\n    expect(String(arrowTable.getChild('unsafe_count')?.type)).toBe('Float64');\n    expect(String(arrowTable.getChild('out_of_range_count')?.type)).toBe('Utf8');\n  });\n\n  test.each(['gpkg_contents', 'gpkg_geometry_columns', 'sqlite_sequence'])(\n    'sanitizes the reserved GeoPackage layer name %s',\n    async layerName => {\n      const geopackage = await encodeDatasetExport({\n        data: container(),\n        fields,\n        fieldPairs,\n        dataType: EXPORT_DATA_TYPE.GEOPACKAGE,\n        layerName\n      });\n      const SQL = await loadSqlJs();\n      const db = new SQL.Database(new Uint8Array(geopackage.data as Uint8Array));\n      try {\n        const contents = db.exec('SELECT table_name FROM gpkg_contents');\n        const exportedTable = String(contents[0].values[0][0]);\n        expect(exportedTable).not.toBe(layerName);\n        expect(exportedTable).not.toMatch(/^sqlite_/i);\n        expect(db.exec(`SELECT COUNT(*) FROM \"${exportedTable}\"`)[0].values[0][0]).toBe(2);\n      } finally {\n        db.close();\n      }\n    }\n  );\n\n  test('uses a geojson column as feature geometry and drops it from properties', async () => {\n    const polygon = {\n      type: 'Polygon',\n      coordinates: [\n        [\n          [0, 0],\n          [1, 0],\n          [1, 1],\n          [0, 1],\n          [0, 0]\n        ]\n      ]\n    };\n    const geoFields = [\n      {name: '_geojson', type: ALL_FIELD_TYPES.geojson},\n      {name: 'label', type: ALL_FIELD_TYPES.string}\n    ] as Field[];\n    const geoRows = [[polygon, 'block']];\n    const collection = datasetToFeatureCollection(createDataContainer(geoRows), geoFields);\n\n    expect(collection.features[0].geometry).toEqual(polygon);\n    expect(collection.features[0].properties).toEqual({label: 'block'});\n  });\n});\n"],"mappings":"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","ignoreList":[]}