@kepler.gl/processors 3.3.0-alpha.17 → 3.3.0-alpha.19

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.
@@ -1,16 +1,27 @@
1
+ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
1
2
  import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
2
3
  import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
3
4
  import _regeneratorRuntime from "@babel/runtime/regenerator";
4
5
  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; }
5
6
  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) { _defineProperty(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; }
7
+ /** @jest-environment node */
8
+
6
9
  // SPDX-License-Identifier: MIT
7
10
  // Copyright contributors to the kepler.gl project
8
11
 
12
+ import { convertGeometryToWKB, convertWKBToGeometry } from '@loaders.gl/gis';
9
13
  import { convertArrowToSchema } from '@loaders.gl/schema-utils';
14
+ import { DBFLoader } from '@loaders.gl/shapefile';
10
15
  import { ALL_FIELD_TYPES, EXPORT_DATA_TYPE } from '@kepler.gl/constants';
11
- import { createDataContainer } from '@kepler.gl/utils';
16
+ import { createDataContainer, validateInputData } from '@kepler.gl/utils';
17
+ import { datasetSchema, VERSIONS } from '@kepler.gl/schemas';
18
+ import * as arrow from 'apache-arrow';
12
19
  import { tableFromIPC } from 'apache-arrow';
20
+ import { ZipLoader } from '@loaders.gl/zip';
21
+ import { KeplerTable } from '@kepler.gl/table';
22
+ import { arrowSchemaToFields, processArrowTable, processRowObject } from '../data-processor';
13
23
  import { datasetToFeatureCollection, encodeDatasetExport } from './vector-export';
24
+ import { writeShapefile } from './shapefile-writer';
14
25
  import { loadSqlJs } from './sql-js';
15
26
  var fields = [{
16
27
  name: 'name',
@@ -44,6 +55,250 @@ function container() {
44
55
  return createDataContainer(rows);
45
56
  }
46
57
  describe('dataset export', function () {
58
+ test.each(['DataView', 'Uint16Array', 'Uint8Array', 'ArrayBuffer'])('preserves WKB geometry from %s with bounded byte views', /*#__PURE__*/function () {
59
+ var _ref = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(viewType) {
60
+ var geometry, bytes, padded, value, shared, geojson, shapefile, files, shp;
61
+ return _regeneratorRuntime.wrap(function _callee$(_context) {
62
+ while (1) switch (_context.prev = _context.next) {
63
+ case 0:
64
+ geometry = {
65
+ type: 'MultiPoint',
66
+ coordinates: [[-122.4123456789, 37.8123456789], [0, 0], [1, 2]]
67
+ }; // Three WKB points occupy 72 bytes, so the Uint16Array has no padding inside its view.
68
+ bytes = new Uint8Array(convertGeometryToWKB(geometry));
69
+ padded = new Uint8Array(bytes.length + 16).fill(255);
70
+ padded.set(bytes, 8);
71
+ value = {
72
+ DataView: new DataView(padded.buffer, 8, bytes.length),
73
+ Uint16Array: new Uint16Array(padded.buffer, 8, bytes.length / 2),
74
+ Uint8Array: padded.subarray(8, 8 + bytes.length),
75
+ ArrayBuffer: bytes.buffer
76
+ }[viewType];
77
+ shared = {
78
+ data: createDataContainer([[value, 'p']]),
79
+ fields: [{
80
+ name: 'geometry',
81
+ type: ALL_FIELD_TYPES.geojson
82
+ }, {
83
+ name: 'id',
84
+ type: ALL_FIELD_TYPES.string
85
+ }],
86
+ layerName: 'views'
87
+ };
88
+ _context.next = 8;
89
+ return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
90
+ dataType: EXPORT_DATA_TYPE.GEOJSON
91
+ }));
92
+ case 8:
93
+ geojson = _context.sent;
94
+ expect(JSON.parse(String(geojson.data)).features).toEqual([{
95
+ type: 'Feature',
96
+ geometry: geometry,
97
+ properties: {
98
+ id: 'p'
99
+ }
100
+ }]);
101
+ _context.next = 12;
102
+ return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
103
+ dataType: EXPORT_DATA_TYPE.SHAPEFILE
104
+ }));
105
+ case 12:
106
+ shapefile = _context.sent;
107
+ _context.next = 15;
108
+ return ZipLoader.parse(shapefile.data);
109
+ case 15:
110
+ files = _context.sent;
111
+ shp = new DataView(files['views.shp']);
112
+ expect(shp.getInt32(108, true)).toBe(8);
113
+ expect(shp.getInt32(144, true)).toBe(geometry.coordinates.length);
114
+ expect(geometry.coordinates.map(function (_, i) {
115
+ return [shp.getFloat64(148 + i * 16, true), shp.getFloat64(156 + i * 16, true)];
116
+ })).toEqual(geometry.coordinates);
117
+ case 20:
118
+ case "end":
119
+ return _context.stop();
120
+ }
121
+ }, _callee);
122
+ }));
123
+ return function (_x) {
124
+ return _ref.apply(this, arguments);
125
+ };
126
+ }());
127
+ test('preserves native GeoArrow coordinate views when decoding exports', function () {
128
+ var coordinates = new Float64Array([999, -122.4123456789, 37.8123456789, 999]);
129
+ var value = coordinates.subarray(1, 3);
130
+ var collection = datasetToFeatureCollection(createDataContainer([[value]]), [{
131
+ name: 'geometry',
132
+ displayName: 'geometry',
133
+ type: ALL_FIELD_TYPES.geoarrow,
134
+ fieldIdx: 0,
135
+ format: '',
136
+ valueAccessor: function valueAccessor() {
137
+ return value;
138
+ },
139
+ metadata: new Map([['ARROW:extension:name', 'geoarrow.point']])
140
+ }]);
141
+ expect(collection.features[0].geometry).toEqual({
142
+ type: 'Point',
143
+ coordinates: [-122.4123456789, 37.8123456789]
144
+ });
145
+ });
146
+ test.each(['WKT', 'hex WKB', 'Arrow WKT', 'native GeoArrow point'])('preserves imported %s geometry in GeoJSON and shapefile exports', /*#__PURE__*/function () {
147
+ var _ref2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(encoding) {
148
+ var geometry, data, points, table, value, column, _table, dataset, shared, geojson, collection, saved, loaded, restored, shapefile, files, shp;
149
+ return _regeneratorRuntime.wrap(function _callee2$(_context2) {
150
+ while (1) switch (_context2.prev = _context2.next) {
151
+ case 0:
152
+ geometry = {
153
+ type: 'Point',
154
+ coordinates: [-122.4123456789, 37.8123456789]
155
+ };
156
+ if (encoding === 'native GeoArrow point') {
157
+ points = arrow.vectorFromArray([geometry.coordinates, null], new arrow.FixedSizeList(2, new arrow.Field('xy', new arrow.Float64())));
158
+ table = new arrow.Table({
159
+ geometry: points
160
+ });
161
+ table.schema.fields[0].metadata.set('ARROW:extension:name', 'geoarrow.point');
162
+ data = processArrowTable({
163
+ shape: 'arrow-table',
164
+ data: table
165
+ });
166
+ } else {
167
+ value = encoding.endsWith('WKT') ? "POINT (".concat(geometry.coordinates.join(' '), ")") : Buffer.from(convertGeometryToWKB(geometry)).toString('hex');
168
+ if (encoding === 'Arrow WKT') {
169
+ column = arrow.vectorFromArray([value, null], new arrow.Utf8());
170
+ _table = new arrow.Table({
171
+ geometry: column
172
+ });
173
+ data = {
174
+ fields: arrowSchemaToFields(_table, {
175
+ geometry: 'VARCHAR'
176
+ }),
177
+ cols: [column],
178
+ rows: []
179
+ };
180
+ } else {
181
+ data = processRowObject([{
182
+ geometry: value
183
+ }, {
184
+ geometry: null
185
+ }]);
186
+ }
187
+ }
188
+ if (data) {
189
+ _context2.next = 4;
190
+ break;
191
+ }
192
+ throw new Error('Geometry import failed');
193
+ case 4:
194
+ dataset = new KeplerTable({
195
+ color: [1, 2, 3]
196
+ });
197
+ _context2.next = 7;
198
+ return dataset.importData({
199
+ data: data
200
+ });
201
+ case 7:
202
+ shared = {
203
+ data: dataset.dataContainer,
204
+ fields: dataset.fields,
205
+ hiddenColumns: ['geometry'],
206
+ layerName: 'geometry'
207
+ };
208
+ _context2.next = 10;
209
+ return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
210
+ dataType: EXPORT_DATA_TYPE.GEOJSON
211
+ }));
212
+ case 10:
213
+ geojson = _context2.sent;
214
+ collection = JSON.parse(String(geojson.data));
215
+ expect(collection.features.map(function (feature) {
216
+ return feature.geometry;
217
+ })).toEqual([geometry, null]);
218
+ expect(collection.features[0].properties).not.toHaveProperty('geometry');
219
+ saved = JSON.parse(JSON.stringify(datasetSchema[VERSIONS.v1].save(dataset)));
220
+ loaded = validateInputData(datasetSchema[VERSIONS.v1].load(saved).data);
221
+ if (loaded) {
222
+ _context2.next = 18;
223
+ break;
224
+ }
225
+ throw new Error('Saved geometry validation failed');
226
+ case 18:
227
+ restored = new KeplerTable({
228
+ color: [1, 2, 3]
229
+ }).updateSchema(loaded);
230
+ expect(datasetToFeatureCollection(restored.dataContainer, restored.fields)).toEqual(collection);
231
+ _context2.next = 22;
232
+ return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
233
+ dataType: EXPORT_DATA_TYPE.SHAPEFILE
234
+ }));
235
+ case 22:
236
+ shapefile = _context2.sent;
237
+ _context2.next = 25;
238
+ return ZipLoader.parse(shapefile.data);
239
+ case 25:
240
+ files = _context2.sent;
241
+ shp = new DataView(files['geometry.shp']);
242
+ expect(shp.getInt32(0)).toBe(9994);
243
+ expect(shp.getInt32(108, true)).toBe(1);
244
+ expect([shp.getFloat64(112, true), shp.getFloat64(120, true)]).toEqual(geometry.coordinates);
245
+ expect(shp.getInt32(136, true)).toBe(0);
246
+ case 31:
247
+ case "end":
248
+ return _context2.stop();
249
+ }
250
+ }, _callee2);
251
+ }));
252
+ return function (_x2) {
253
+ return _ref2.apply(this, arguments);
254
+ };
255
+ }());
256
+ test.each([[[1, 2]], [['1', '2']], ['[1,2]']])('preserves numeric point coordinates from %j', function (value) {
257
+ var collection = datasetToFeatureCollection(createDataContainer([[value]]), [{
258
+ name: 'point',
259
+ type: ALL_FIELD_TYPES.point
260
+ }]);
261
+ expect(collection.features[0].geometry).toEqual({
262
+ type: 'Point',
263
+ coordinates: [1, 2]
264
+ });
265
+ });
266
+ test.each([[null, null], ['', ''], [' ', '\t'], [null, 10], [10, undefined], ['invalid', 10], [Infinity, 10], [false, true]])('exports missing or invalid coordinates [%s, %s] as null geometry', /*#__PURE__*/function () {
267
+ var _ref3 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(lat, lng) {
268
+ var exported;
269
+ return _regeneratorRuntime.wrap(function _callee3$(_context3) {
270
+ while (1) switch (_context3.prev = _context3.next) {
271
+ case 0:
272
+ _context3.next = 2;
273
+ return encodeDatasetExport({
274
+ data: createDataContainer([['missing', 'secret', lat, lng]]),
275
+ fields: fields,
276
+ fieldPairs: fieldPairs,
277
+ dataType: EXPORT_DATA_TYPE.GEOJSON,
278
+ layerName: 'missing'
279
+ });
280
+ case 2:
281
+ exported = _context3.sent;
282
+ expect(JSON.parse(String(exported.data)).features[0].geometry).toBeNull();
283
+ case 4:
284
+ case "end":
285
+ return _context3.stop();
286
+ }
287
+ }, _callee3);
288
+ }));
289
+ return function (_x3, _x4) {
290
+ return _ref3.apply(this, arguments);
291
+ };
292
+ }());
293
+ test.each([[0, 0], ['0', '0'], [' 37.8 ', '-122.4']])('preserves valid coordinates [%s, %s]', function (lat, lng) {
294
+ var collection = datasetToFeatureCollection(createDataContainer([['valid', 'secret', lat, lng]]), fields, {
295
+ fieldPairs: fieldPairs
296
+ });
297
+ expect(collection.features[0].geometry).toEqual({
298
+ type: 'Point',
299
+ coordinates: [Number(lng), Number(lat)]
300
+ });
301
+ });
47
302
  test('omits columns hidden in the attribute table', function () {
48
303
  var collection = datasetToFeatureCollection(container(), fields, {
49
304
  hiddenColumns: ['secret'],
@@ -61,10 +316,10 @@ describe('dataset export', function () {
61
316
  });
62
317
  expect(collection.features[0].properties).not.toHaveProperty('secret');
63
318
  });
64
- test('writes geojson, kml, kmz, shapefile, geopackage, and geoparquet', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
319
+ test('writes geojson, kml, kmz, shapefile, geopackage, and geoparquet', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
65
320
  var shared, geojson, parsed, kml, kmz, shapefile, shapefileBytes, geopackage, SQL, db, exported, columns, columnNames, geoparquet, parquetBytes;
66
- return _regeneratorRuntime.wrap(function _callee$(_context) {
67
- while (1) switch (_context.prev = _context.next) {
321
+ return _regeneratorRuntime.wrap(function _callee4$(_context4) {
322
+ while (1) switch (_context4.prev = _context4.next) {
68
323
  case 0:
69
324
  shared = {
70
325
  data: container(),
@@ -73,52 +328,52 @@ describe('dataset export', function () {
73
328
  hiddenColumns: ['secret'],
74
329
  layerName: 'places'
75
330
  };
76
- _context.next = 3;
331
+ _context4.next = 3;
77
332
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
78
333
  dataType: EXPORT_DATA_TYPE.GEOJSON
79
334
  }));
80
335
  case 3:
81
- geojson = _context.sent;
336
+ geojson = _context4.sent;
82
337
  parsed = JSON.parse(String(geojson.data));
83
338
  expect(parsed.features[1].properties.name).toBe('Pier');
84
339
  expect(parsed.features[1].properties.secret).toBeUndefined();
85
340
  expect(geojson.extension).toBe('geojson');
86
- _context.next = 10;
341
+ _context4.next = 10;
87
342
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
88
343
  dataType: EXPORT_DATA_TYPE.KML
89
344
  }));
90
345
  case 10:
91
- kml = _context.sent;
346
+ kml = _context4.sent;
92
347
  expect(String(kml.data)).toContain('<coordinates>-122.4,37.8</coordinates>');
93
348
  expect(String(kml.data)).not.toContain('hidden-value');
94
- _context.next = 15;
349
+ _context4.next = 15;
95
350
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
96
351
  dataType: EXPORT_DATA_TYPE.KMZ
97
352
  }));
98
353
  case 15:
99
- kmz = _context.sent;
354
+ kmz = _context4.sent;
100
355
  expect(Buffer.from(kmz.data).includes(Buffer.from('doc.kml'))).toBe(true);
101
- _context.next = 19;
356
+ _context4.next = 19;
102
357
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
103
358
  dataType: EXPORT_DATA_TYPE.SHAPEFILE
104
359
  }));
105
360
  case 19:
106
- shapefile = _context.sent;
361
+ shapefile = _context4.sent;
107
362
  shapefileBytes = Buffer.from(shapefile.data);
108
363
  expect(shapefile.extension).toBe('zip');
109
364
  expect(shapefileBytes.includes(Buffer.from('places.shp'))).toBe(true);
110
365
  expect(shapefileBytes.includes(Buffer.from('places.dbf'))).toBe(true);
111
366
  expect(shapefileBytes.includes(Buffer.from('hidden-value'))).toBe(false);
112
- _context.next = 27;
367
+ _context4.next = 27;
113
368
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
114
369
  dataType: EXPORT_DATA_TYPE.GEOPACKAGE
115
370
  }));
116
371
  case 27:
117
- geopackage = _context.sent;
118
- _context.next = 30;
372
+ geopackage = _context4.sent;
373
+ _context4.next = 30;
119
374
  return loadSqlJs();
120
375
  case 30:
121
- SQL = _context.sent;
376
+ SQL = _context4.sent;
122
377
  db = new SQL.Database(new Uint8Array(geopackage.data));
123
378
  exported = db.exec('SELECT name FROM places');
124
379
  expect(exported[0].values.map(function (row) {
@@ -130,26 +385,115 @@ describe('dataset export', function () {
130
385
  });
131
386
  expect(columnNames).not.toContain('secret');
132
387
  db.close();
133
- _context.next = 40;
388
+ _context4.next = 40;
134
389
  return encodeDatasetExport(_objectSpread(_objectSpread({}, shared), {}, {
135
390
  dataType: EXPORT_DATA_TYPE.GEOPARQUET
136
391
  }));
137
392
  case 40:
138
- geoparquet = _context.sent;
393
+ geoparquet = _context4.sent;
139
394
  parquetBytes = Buffer.from(geoparquet.data);
140
395
  expect(parquetBytes.subarray(0, 4).toString()).toBe('PAR1');
141
396
  expect(parquetBytes.includes(Buffer.from('"encoding":"WKB"'))).toBe(true);
142
397
  expect(parquetBytes.includes(Buffer.from('hidden-value'))).toBe(false);
143
398
  case 45:
144
399
  case "end":
145
- return _context.stop();
400
+ return _context4.stop();
146
401
  }
147
- }, _callee);
402
+ }, _callee4);
148
403
  })));
149
- test('rejects mixed geometry families when exporting a shapefile', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2() {
404
+ test.each([{
405
+ dimension: '2D',
406
+ altitudes: [null, ''],
407
+ expectedZ: 0,
408
+ expectedCoordinates: [[-122.4, 37.8], [-122.41, 37.81]]
409
+ }, {
410
+ dimension: '3D',
411
+ altitudes: [12, 24],
412
+ expectedZ: 1,
413
+ expectedCoordinates: [[-122.4, 37.8, 12], [-122.41, 37.81, 24]]
414
+ }, {
415
+ dimension: 'mixed 2D and 3D',
416
+ altitudes: [12, null],
417
+ expectedZ: 2,
418
+ expectedCoordinates: [[-122.4, 37.8, 12], [-122.41, 37.81]]
419
+ }])('writes $dimension GeoPackage points with matching Z metadata', /*#__PURE__*/function () {
420
+ var _ref6 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(_ref5) {
421
+ var altitudes, expectedZ, expectedCoordinates, altitudeFields, altitudeFieldPairs, altitudeRows, geopackage, SQL, db, z, coordinates;
422
+ return _regeneratorRuntime.wrap(function _callee5$(_context5) {
423
+ while (1) switch (_context5.prev = _context5.next) {
424
+ case 0:
425
+ altitudes = _ref5.altitudes, expectedZ = _ref5.expectedZ, expectedCoordinates = _ref5.expectedCoordinates;
426
+ altitudeFields = [].concat(fields, [{
427
+ name: 'altitude',
428
+ type: ALL_FIELD_TYPES.real
429
+ }]);
430
+ altitudeFieldPairs = [{
431
+ defaultName: 'point',
432
+ pair: {
433
+ lat: {
434
+ fieldIdx: 2,
435
+ value: 'lat'
436
+ },
437
+ lng: {
438
+ fieldIdx: 3,
439
+ value: 'lng'
440
+ },
441
+ altitude: {
442
+ fieldIdx: 4,
443
+ value: 'altitude'
444
+ }
445
+ },
446
+ suffix: ['lat', 'lng', 'altitude']
447
+ }];
448
+ altitudeRows = rows.map(function (row, index) {
449
+ return [].concat(_toConsumableArray(row), [altitudes[index]]);
450
+ });
451
+ _context5.next = 6;
452
+ return encodeDatasetExport({
453
+ data: createDataContainer(altitudeRows),
454
+ fields: altitudeFields,
455
+ fieldPairs: altitudeFieldPairs,
456
+ dataType: EXPORT_DATA_TYPE.GEOPACKAGE,
457
+ layerName: 'places'
458
+ });
459
+ case 6:
460
+ geopackage = _context5.sent;
461
+ _context5.next = 9;
462
+ return loadSqlJs();
463
+ case 9:
464
+ SQL = _context5.sent;
465
+ db = new SQL.Database(new Uint8Array(geopackage.data));
466
+ try {
467
+ z = db.exec('SELECT z FROM gpkg_geometry_columns')[0].values[0][0];
468
+ coordinates = db.exec('SELECT geom FROM places ORDER BY fid')[0].values.map(function (row) {
469
+ var blob = row[0];
470
+ var geometry = convertWKBToGeometry(blob.slice(8).buffer);
471
+ return geometry.type === 'Point' ? geometry.coordinates : null;
472
+ });
473
+ expect({
474
+ z: z,
475
+ coordinates: coordinates
476
+ }).toEqual({
477
+ z: expectedZ,
478
+ coordinates: expectedCoordinates
479
+ });
480
+ } finally {
481
+ db.close();
482
+ }
483
+ case 12:
484
+ case "end":
485
+ return _context5.stop();
486
+ }
487
+ }, _callee5);
488
+ }));
489
+ return function (_x5) {
490
+ return _ref6.apply(this, arguments);
491
+ };
492
+ }());
493
+ test('rejects mixed geometry families when exporting a shapefile', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee6() {
150
494
  var geometryFields, geometryRows;
151
- return _regeneratorRuntime.wrap(function _callee2$(_context2) {
152
- while (1) switch (_context2.prev = _context2.next) {
495
+ return _regeneratorRuntime.wrap(function _callee6$(_context6) {
496
+ while (1) switch (_context6.prev = _context6.next) {
153
497
  case 0:
154
498
  geometryFields = [{
155
499
  name: '_geojson',
@@ -165,7 +509,7 @@ describe('dataset export', function () {
165
509
  type: 'LineString',
166
510
  coordinates: [[0, 0], [1, 1]]
167
511
  }, 'line']];
168
- _context2.next = 4;
512
+ _context6.next = 4;
169
513
  return expect(encodeDatasetExport({
170
514
  data: createDataContainer(geometryRows),
171
515
  fields: geometryFields,
@@ -174,17 +518,201 @@ describe('dataset export', function () {
174
518
  })).rejects.toThrow('Shapefile export requires all geometries to have the same shape family.');
175
519
  case 4:
176
520
  case "end":
177
- return _context2.stop();
521
+ return _context6.stop();
178
522
  }
179
- }, _callee2);
523
+ }, _callee6);
180
524
  })));
181
- test('writes geoparquet string columns the importer can read', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3() {
525
+ test('rounds noisy and tiny DBF numbers at the maximum supported precision', function () {
526
+ var _DBFLoader$parseSync;
527
+ var values = [0.1 + 0.2, 1e-7, -1e-7, 1e-16, -1e-16, null];
528
+ var collection = {
529
+ type: 'FeatureCollection',
530
+ features: values.map(function (value, index) {
531
+ return {
532
+ type: 'Feature',
533
+ geometry: {
534
+ type: 'Point',
535
+ coordinates: [index, index]
536
+ },
537
+ properties: {
538
+ value: value
539
+ }
540
+ };
541
+ })
542
+ };
543
+ var _writeShapefile = writeShapefile(collection),
544
+ dbf = _writeShapefile.dbf;
545
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
546
+ var headerLength = view.getUint16(8, true);
547
+ var recordLength = view.getUint16(10, true);
548
+ var fieldLength = dbf[32 + 16];
549
+ var decimalCount = dbf[32 + 17];
550
+ var decoder = new TextDecoder();
551
+ var cells = values.map(function (_, index) {
552
+ var start = headerLength + index * recordLength + 1;
553
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
554
+ });
555
+ expect({
556
+ fieldLength: fieldLength,
557
+ decimalCount: decimalCount
558
+ }).toEqual({
559
+ fieldLength: 18,
560
+ decimalCount: 15
561
+ });
562
+ expect(cells).toEqual(['0.300000000000000', '0.000000100000000', '-0.000000100000000', '0.000000000000000', '0.000000000000000', '']);
563
+ expect(cells.filter(Boolean).every(function (cell) {
564
+ return /^-?\d+(?:\.\d+)?$/.test(cell);
565
+ })).toBe(true);
566
+ var parsed = (_DBFLoader$parseSync = DBFLoader.parseSync) === null || _DBFLoader$parseSync === void 0 ? void 0 : _DBFLoader$parseSync.call(DBFLoader, dbf.buffer, {
567
+ dbf: {
568
+ shape: 'rows'
569
+ }
570
+ });
571
+ expect(parsed.map(function (row) {
572
+ return row.value;
573
+ })).toEqual([0.3, 1e-7, -1e-7, 0, 0, null]);
574
+ });
575
+ test('uses the highest common precision that fits mixed magnitudes after rounding', function () {
576
+ var _DBFLoader$parseSync2;
577
+ var values = [-1234567890123456, 999.9999, -12.3456, null];
578
+ var collection = {
579
+ type: 'FeatureCollection',
580
+ features: values.map(function (value, index) {
581
+ return {
582
+ type: 'Feature',
583
+ geometry: {
584
+ type: 'Point',
585
+ coordinates: [index, index]
586
+ },
587
+ properties: {
588
+ value: value
589
+ }
590
+ };
591
+ })
592
+ };
593
+ var _writeShapefile2 = writeShapefile(collection),
594
+ dbf = _writeShapefile2.dbf;
595
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
596
+ var headerLength = view.getUint16(8, true);
597
+ var recordLength = view.getUint16(10, true);
598
+ var fieldLength = dbf[32 + 16];
599
+ var decimalCount = dbf[32 + 17];
600
+ var decoder = new TextDecoder();
601
+ var cells = values.map(function (_, index) {
602
+ var start = headerLength + index * recordLength + 1;
603
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
604
+ });
605
+ expect({
606
+ fieldLength: fieldLength,
607
+ decimalCount: decimalCount
608
+ }).toEqual({
609
+ fieldLength: 19,
610
+ decimalCount: 1
611
+ });
612
+ expect(cells).toEqual(['-1234567890123456.0', '1000.0', '-12.3', '']);
613
+ var parsed = (_DBFLoader$parseSync2 = DBFLoader.parseSync) === null || _DBFLoader$parseSync2 === void 0 ? void 0 : _DBFLoader$parseSync2.call(DBFLoader, dbf.buffer, {
614
+ dbf: {
615
+ shape: 'rows'
616
+ }
617
+ });
618
+ expect(parsed.map(function (row) {
619
+ return row.value;
620
+ })).toEqual([-1234567890123456, 1000, -12.3, null]);
621
+ });
622
+ test('keeps large positive and negative integers in numeric fields', function () {
623
+ var values = [1e18, -1e17, null];
624
+ var collection = {
625
+ type: 'FeatureCollection',
626
+ features: values.map(function (value, index) {
627
+ return {
628
+ type: 'Feature',
629
+ geometry: {
630
+ type: 'Point',
631
+ coordinates: [index, index]
632
+ },
633
+ properties: {
634
+ value: value
635
+ }
636
+ };
637
+ })
638
+ };
639
+ var _writeShapefile3 = writeShapefile(collection),
640
+ dbf = _writeShapefile3.dbf;
641
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
642
+ var headerLength = view.getUint16(8, true);
643
+ var recordLength = view.getUint16(10, true);
644
+ var fieldLength = dbf[32 + 16];
645
+ var decimalCount = dbf[32 + 17];
646
+ var decoder = new TextDecoder();
647
+ var cells = values.map(function (_, index) {
648
+ var start = headerLength + index * recordLength + 1;
649
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
650
+ });
651
+ expect({
652
+ fieldLength: fieldLength,
653
+ decimalCount: decimalCount
654
+ }).toEqual({
655
+ fieldLength: 19,
656
+ decimalCount: 0
657
+ });
658
+ expect(cells).toEqual(['1000000000000000000', '-100000000000000000', '']);
659
+ });
660
+ test.each([[1e19, 20], [-1e18, 20], [1e21, 22]])('rejects the DBF number %s when its rounded integer needs %i bytes', function (value, width) {
661
+ var collection = {
662
+ type: 'FeatureCollection',
663
+ features: [{
664
+ type: 'Feature',
665
+ geometry: {
666
+ type: 'Point',
667
+ coordinates: [0, 0]
668
+ },
669
+ properties: {
670
+ value: value
671
+ }
672
+ }]
673
+ };
674
+ expect(function () {
675
+ return writeShapefile(collection);
676
+ }).toThrow("DBF numeric field \"value\" requires ".concat(width, " bytes at zero decimal places; ") + 'dBASE III numeric fields support at most 19.');
677
+ });
678
+ test('keeps mixed finite and non-finite values in a DBF text field', function () {
679
+ var values = [1, Number.NaN, Number.POSITIVE_INFINITY, Number.NEGATIVE_INFINITY, null];
680
+ var collection = {
681
+ type: 'FeatureCollection',
682
+ features: values.map(function (value, index) {
683
+ return {
684
+ type: 'Feature',
685
+ geometry: {
686
+ type: 'Point',
687
+ coordinates: [index, index]
688
+ },
689
+ properties: {
690
+ value: value
691
+ }
692
+ };
693
+ })
694
+ };
695
+ var _writeShapefile4 = writeShapefile(collection),
696
+ dbf = _writeShapefile4.dbf;
697
+ var view = new DataView(dbf.buffer, dbf.byteOffset, dbf.byteLength);
698
+ var headerLength = view.getUint16(8, true);
699
+ var recordLength = view.getUint16(10, true);
700
+ var fieldLength = dbf[32 + 16];
701
+ var decoder = new TextDecoder();
702
+ var cells = values.map(function (_, index) {
703
+ var start = headerLength + index * recordLength + 1;
704
+ return decoder.decode(dbf.subarray(start, start + fieldLength)).trim();
705
+ });
706
+ expect(String.fromCharCode(dbf[32 + 11])).toBe('C');
707
+ expect(cells).toEqual(['1', 'NaN', 'Infinity', '-Infinity', '']);
708
+ });
709
+ test('writes geoparquet string columns the importer can read', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee7() {
182
710
  var _arrowTable$getChild, _arrowTable$getChild2, _schema$fields$find, _schema$fields$find2;
183
711
  var geoparquet, specifier, imported, api, wasmTable, arrowTable, schema;
184
- return _regeneratorRuntime.wrap(function _callee3$(_context3) {
185
- while (1) switch (_context3.prev = _context3.next) {
712
+ return _regeneratorRuntime.wrap(function _callee7$(_context7) {
713
+ while (1) switch (_context7.prev = _context7.next) {
186
714
  case 0:
187
- _context3.next = 2;
715
+ _context7.next = 2;
188
716
  return encodeDatasetExport({
189
717
  data: container(),
190
718
  fields: fields,
@@ -193,15 +721,15 @@ describe('dataset export', function () {
193
721
  layerName: 'places'
194
722
  });
195
723
  case 2:
196
- geoparquet = _context3.sent;
724
+ geoparquet = _context7.sent;
197
725
  specifier = 'parquet-wasm/node';
198
- _context3.next = 6;
726
+ _context7.next = 6;
199
727
  return import(specifier);
200
728
  case 6:
201
- imported = _context3.sent;
729
+ imported = _context7.sent;
202
730
  api = imported.readParquet ? imported : imported["default"];
203
731
  if (api !== null && api !== void 0 && api.readParquet) {
204
- _context3.next = 10;
732
+ _context7.next = 10;
205
733
  break;
206
734
  }
207
735
  throw new Error('parquet-wasm failed to load');
@@ -219,17 +747,96 @@ describe('dataset export', function () {
219
747
  })) === null || _schema$fields$find2 === void 0 ? void 0 : _schema$fields$find2.type).toBe('utf8');
220
748
  case 17:
221
749
  case "end":
222
- return _context3.stop();
750
+ return _context7.stop();
751
+ }
752
+ }, _callee7);
753
+ })));
754
+ test('writes typed integer fields without reclassifying integer-valued real fields', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee8() {
755
+ var _count$length, _arrowTable$getChild3, _arrowTable$getChild4, _arrowTable$getChild5;
756
+ var typedFields, typedRows, geoparquet, specifier, imported, api, wasmTable, arrowTable, count;
757
+ return _regeneratorRuntime.wrap(function _callee8$(_context8) {
758
+ while (1) switch (_context8.prev = _context8.next) {
759
+ case 0:
760
+ typedFields = [{
761
+ name: 'count',
762
+ type: ALL_FIELD_TYPES.integer
763
+ }, {
764
+ name: 'measurement',
765
+ type: ALL_FIELD_TYPES.real
766
+ }, {
767
+ name: 'unsafe_count',
768
+ type: ALL_FIELD_TYPES.integer
769
+ }, {
770
+ name: 'out_of_range_count',
771
+ type: ALL_FIELD_TYPES.integer
772
+ }, {
773
+ name: 'lat',
774
+ type: ALL_FIELD_TYPES.real
775
+ }, {
776
+ name: 'lng',
777
+ type: ALL_FIELD_TYPES.real
778
+ }];
779
+ 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]];
780
+ _context8.next = 4;
781
+ return encodeDatasetExport({
782
+ data: createDataContainer(typedRows),
783
+ fields: typedFields,
784
+ fieldPairs: [{
785
+ defaultName: 'point',
786
+ pair: {
787
+ lat: {
788
+ fieldIdx: 4,
789
+ value: 'lat'
790
+ },
791
+ lng: {
792
+ fieldIdx: 5,
793
+ value: 'lng'
794
+ }
795
+ },
796
+ suffix: ['lat', 'lng']
797
+ }],
798
+ dataType: EXPORT_DATA_TYPE.GEOPARQUET,
799
+ layerName: 'typed-numbers'
800
+ });
801
+ case 4:
802
+ geoparquet = _context8.sent;
803
+ specifier = 'parquet-wasm/node';
804
+ _context8.next = 8;
805
+ return import(specifier);
806
+ case 8:
807
+ imported = _context8.sent;
808
+ api = imported.readParquet ? imported : imported["default"];
809
+ if (api !== null && api !== void 0 && api.readParquet) {
810
+ _context8.next = 12;
811
+ break;
812
+ }
813
+ throw new Error('parquet-wasm failed to load');
814
+ case 12:
815
+ wasmTable = api.readParquet(new Uint8Array(geoparquet.data));
816
+ arrowTable = tableFromIPC(wasmTable.intoIPCStream());
817
+ count = arrowTable.getChild('count');
818
+ expect(String(count === null || count === void 0 ? void 0 : count.type)).toBe('Int64');
819
+ expect(Array.from({
820
+ length: (_count$length = count === null || count === void 0 ? void 0 : count.length) !== null && _count$length !== void 0 ? _count$length : 0
821
+ }, function (_, index) {
822
+ return count === null || count === void 0 ? void 0 : count.get(index);
823
+ })).toEqual([1n, null, 2147483648n, BigInt(Number.MAX_SAFE_INTEGER)]);
824
+ expect(String((_arrowTable$getChild3 = arrowTable.getChild('measurement')) === null || _arrowTable$getChild3 === void 0 ? void 0 : _arrowTable$getChild3.type)).toBe('Float64');
825
+ expect(String((_arrowTable$getChild4 = arrowTable.getChild('unsafe_count')) === null || _arrowTable$getChild4 === void 0 ? void 0 : _arrowTable$getChild4.type)).toBe('Float64');
826
+ expect(String((_arrowTable$getChild5 = arrowTable.getChild('out_of_range_count')) === null || _arrowTable$getChild5 === void 0 ? void 0 : _arrowTable$getChild5.type)).toBe('Utf8');
827
+ case 20:
828
+ case "end":
829
+ return _context8.stop();
223
830
  }
224
- }, _callee3);
831
+ }, _callee8);
225
832
  })));
226
833
  test.each(['gpkg_contents', 'gpkg_geometry_columns', 'sqlite_sequence'])('sanitizes the reserved GeoPackage layer name %s', /*#__PURE__*/function () {
227
- var _ref4 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(layerName) {
834
+ var _ref0 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee9(layerName) {
228
835
  var geopackage, SQL, db, contents, exportedTable;
229
- return _regeneratorRuntime.wrap(function _callee4$(_context4) {
230
- while (1) switch (_context4.prev = _context4.next) {
836
+ return _regeneratorRuntime.wrap(function _callee9$(_context9) {
837
+ while (1) switch (_context9.prev = _context9.next) {
231
838
  case 0:
232
- _context4.next = 2;
839
+ _context9.next = 2;
233
840
  return encodeDatasetExport({
234
841
  data: container(),
235
842
  fields: fields,
@@ -238,11 +845,11 @@ describe('dataset export', function () {
238
845
  layerName: layerName
239
846
  });
240
847
  case 2:
241
- geopackage = _context4.sent;
242
- _context4.next = 5;
848
+ geopackage = _context9.sent;
849
+ _context9.next = 5;
243
850
  return loadSqlJs();
244
851
  case 5:
245
- SQL = _context4.sent;
852
+ SQL = _context9.sent;
246
853
  db = new SQL.Database(new Uint8Array(geopackage.data));
247
854
  try {
248
855
  contents = db.exec('SELECT table_name FROM gpkg_contents');
@@ -255,18 +862,18 @@ describe('dataset export', function () {
255
862
  }
256
863
  case 8:
257
864
  case "end":
258
- return _context4.stop();
865
+ return _context9.stop();
259
866
  }
260
- }, _callee4);
867
+ }, _callee9);
261
868
  }));
262
- return function (_x) {
263
- return _ref4.apply(this, arguments);
869
+ return function (_x6) {
870
+ return _ref0.apply(this, arguments);
264
871
  };
265
872
  }());
266
- test('uses a geojson column as feature geometry and drops it from properties', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
873
+ test('uses a geojson column as feature geometry and drops it from properties', /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee0() {
267
874
  var polygon, geoFields, geoRows, collection;
268
- return _regeneratorRuntime.wrap(function _callee5$(_context5) {
269
- while (1) switch (_context5.prev = _context5.next) {
875
+ return _regeneratorRuntime.wrap(function _callee0$(_context0) {
876
+ while (1) switch (_context0.prev = _context0.next) {
270
877
  case 0:
271
878
  polygon = {
272
879
  type: 'Polygon',
@@ -287,9 +894,9 @@ describe('dataset export', function () {
287
894
  });
288
895
  case 6:
289
896
  case "end":
290
- return _context5.stop();
897
+ return _context0.stop();
291
898
  }
292
- }, _callee5);
899
+ }, _callee0);
293
900
  })));
294
901
  });
295
- //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["convertArrowToSchema","ALL_FIELD_TYPES","EXPORT_DATA_TYPE","createDataContainer","tableFromIPC","datasetToFeatureCollection","encodeDatasetExport","loadSqlJs","fields","name","type","string","real","rows","fieldPairs","defaultName","pair","lat","fieldIdx","value","lng","suffix","container","describe","test","collection","hiddenColumns","expect","features","toHaveLength","geometry","toEqual","coordinates","properties","not","toHaveProperty","_asyncToGenerator","_regeneratorRuntime","mark","_callee","shared","geojson","parsed","kml","kmz","shapefile","shapefileBytes","geopackage","SQL","db","exported","columns","columnNames","geoparquet","parquetBytes","wrap","_callee$","_context","prev","next","data","layerName","_objectSpread","dataType","GEOJSON","sent","JSON","parse","String","toBe","secret","toBeUndefined","extension","KML","toContain","KMZ","Buffer","from","includes","SHAPEFILE","GEOPACKAGE","Database","Uint8Array","exec","values","map","row","close","GEOPARQUET","subarray","toString","stop","_callee2","geometryFields","geometryRows","_callee2$","_context2","rejects","toThrow","_callee3","_arrowTable$getChild","_arrowTable$getChild2","_schema$fields$find","_schema$fields$find2","specifier","imported","api","wasmTable","arrowTable","schema","_callee3$","_context3","readParquet","Error","intoIPCStream","getChild","toArray","get","toBeInstanceOf","find","field","each","_ref4","_callee4","contents","exportedTable","_callee4$","_context4","toMatch","concat","_x","apply","arguments","_callee5","polygon","geoFields","geoRows","_callee5$","_context5","label"],"sources":["../../../src/export/vector-export.spec.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {convertArrowToSchema} from '@loaders.gl/schema-utils';\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';\n\nimport {datasetToFeatureCollection, encodeDatasetExport} from './vector-export';\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('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('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.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":[]}
902
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["convertGeometryToWKB","convertWKBToGeometry","convertArrowToSchema","DBFLoader","ALL_FIELD_TYPES","EXPORT_DATA_TYPE","createDataContainer","validateInputData","datasetSchema","VERSIONS","arrow","tableFromIPC","ZipLoader","KeplerTable","arrowSchemaToFields","processArrowTable","processRowObject","datasetToFeatureCollection","encodeDatasetExport","writeShapefile","loadSqlJs","fields","name","type","string","real","rows","fieldPairs","defaultName","pair","lat","fieldIdx","value","lng","suffix","container","describe","test","each","_ref","_asyncToGenerator","_regeneratorRuntime","mark","_callee","viewType","geometry","bytes","padded","shared","geojson","shapefile","files","shp","wrap","_callee$","_context","prev","next","coordinates","Uint8Array","length","fill","set","DataView","buffer","Uint16Array","subarray","ArrayBuffer","data","layerName","_objectSpread","dataType","GEOJSON","sent","expect","JSON","parse","String","features","toEqual","properties","id","SHAPEFILE","getInt32","toBe","map","_","i","getFloat64","stop","_x","apply","arguments","Float64Array","collection","displayName","geoarrow","format","valueAccessor","metadata","Map","_ref2","_callee2","encoding","points","table","column","_table","dataset","saved","loaded","restored","_callee2$","_context2","vectorFromArray","FixedSizeList","Field","Float64","Table","schema","shape","endsWith","concat","join","Buffer","from","toString","Utf8","cols","Error","color","importData","dataContainer","hiddenColumns","feature","not","toHaveProperty","stringify","v1","save","load","updateSchema","_x2","point","undefined","Infinity","_ref3","_callee3","exported","_callee3$","_context3","toBeNull","_x3","_x4","Number","toHaveLength","_callee4","parsed","kml","kmz","shapefileBytes","geopackage","SQL","db","columns","columnNames","geoparquet","parquetBytes","_callee4$","_context4","secret","toBeUndefined","extension","KML","toContain","KMZ","includes","GEOPACKAGE","Database","exec","values","row","close","GEOPARQUET","dimension","altitudes","expectedZ","expectedCoordinates","_ref6","_callee5","_ref5","altitudeFields","altitudeFieldPairs","altitudeRows","z","_callee5$","_context5","altitude","index","_toConsumableArray","blob","slice","_x5","_callee6","geometryFields","geometryRows","_callee6$","_context6","rejects","toThrow","_DBFLoader$parseSync","_writeShapefile","dbf","view","byteOffset","byteLength","headerLength","getUint16","recordLength","fieldLength","decimalCount","decoder","TextDecoder","cells","start","decode","trim","filter","Boolean","every","cell","parseSync","call","_DBFLoader$parseSync2","_writeShapefile2","_writeShapefile3","width","NaN","POSITIVE_INFINITY","NEGATIVE_INFINITY","_writeShapefile4","fromCharCode","_callee7","_arrowTable$getChild","_arrowTable$getChild2","_schema$fields$find","_schema$fields$find2","specifier","imported","api","wasmTable","arrowTable","_callee7$","_context7","readParquet","intoIPCStream","getChild","toArray","get","toBeInstanceOf","find","field","_callee8","_count$length","_arrowTable$getChild3","_arrowTable$getChild4","_arrowTable$getChild5","typedFields","typedRows","count","_callee8$","_context8","integer","MAX_SAFE_INTEGER","Array","BigInt","_ref0","_callee9","contents","exportedTable","_callee9$","_context9","toMatch","_x6","_callee0","polygon","geoFields","geoRows","_callee0$","_context0","label"],"sources":["../../../src/export/vector-export.spec.ts"],"sourcesContent":["/** @jest-environment node */\n\n// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {convertGeometryToWKB, 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, validateInputData} from '@kepler.gl/utils';\nimport {datasetSchema, VERSIONS} from '@kepler.gl/schemas';\nimport * as arrow from 'apache-arrow';\nimport {tableFromIPC} from 'apache-arrow';\nimport {ZipLoader} from '@loaders.gl/zip';\nimport {KeplerTable} from '@kepler.gl/table';\nimport {arrowSchemaToFields, processArrowTable, processRowObject} from '../data-processor';\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.each(['DataView', 'Uint16Array', 'Uint8Array', 'ArrayBuffer'])(\n    'preserves WKB geometry from %s with bounded byte views',\n    async viewType => {\n      const geometry = {\n        type: 'MultiPoint' as const,\n        coordinates: [\n          [-122.4123456789, 37.8123456789],\n          [0, 0],\n          [1, 2]\n        ]\n      };\n      // Three WKB points occupy 72 bytes, so the Uint16Array has no padding inside its view.\n      const bytes = new Uint8Array(convertGeometryToWKB(geometry));\n      const padded = new Uint8Array(bytes.length + 16).fill(255);\n      padded.set(bytes, 8);\n      const value = {\n        DataView: new DataView(padded.buffer, 8, bytes.length),\n        Uint16Array: new Uint16Array(padded.buffer, 8, bytes.length / 2),\n        Uint8Array: padded.subarray(8, 8 + bytes.length),\n        ArrayBuffer: bytes.buffer\n      }[viewType];\n      const shared = {\n        data: createDataContainer([[value, 'p']]),\n        fields: [\n          {name: 'geometry', type: ALL_FIELD_TYPES.geojson},\n          {name: 'id', type: ALL_FIELD_TYPES.string}\n        ] as Field[],\n        layerName: 'views'\n      };\n      const geojson = await encodeDatasetExport({...shared, dataType: EXPORT_DATA_TYPE.GEOJSON});\n      expect(JSON.parse(String(geojson.data)).features).toEqual([\n        {type: 'Feature', geometry, properties: {id: 'p'}}\n      ]);\n\n      const shapefile = await encodeDatasetExport({\n        ...shared,\n        dataType: EXPORT_DATA_TYPE.SHAPEFILE\n      });\n      const files = await ZipLoader.parse(shapefile.data);\n      const shp = new DataView(files['views.shp']);\n      expect(shp.getInt32(108, true)).toBe(8);\n      expect(shp.getInt32(144, true)).toBe(geometry.coordinates.length);\n      expect(\n        geometry.coordinates.map((_, i) => [\n          shp.getFloat64(148 + i * 16, true),\n          shp.getFloat64(156 + i * 16, true)\n        ])\n      ).toEqual(geometry.coordinates);\n    }\n  );\n\n  test('preserves native GeoArrow coordinate views when decoding exports', () => {\n    const coordinates = new Float64Array([999, -122.4123456789, 37.8123456789, 999]);\n    const value = coordinates.subarray(1, 3);\n    const collection = datasetToFeatureCollection(createDataContainer([[value]]), [\n      {\n        name: 'geometry',\n        displayName: 'geometry',\n        type: ALL_FIELD_TYPES.geoarrow,\n        fieldIdx: 0,\n        format: '',\n        valueAccessor: () => value,\n        metadata: new Map([['ARROW:extension:name', 'geoarrow.point']])\n      }\n    ]);\n    expect(collection.features[0].geometry).toEqual({\n      type: 'Point',\n      coordinates: [-122.4123456789, 37.8123456789]\n    });\n  });\n\n  test.each(['WKT', 'hex WKB', 'Arrow WKT', 'native GeoArrow point'])(\n    'preserves imported %s geometry in GeoJSON and shapefile exports',\n    async encoding => {\n      const geometry = {type: 'Point' as const, coordinates: [-122.4123456789, 37.8123456789]};\n      let data;\n      if (encoding === 'native GeoArrow point') {\n        const points = arrow.vectorFromArray(\n          [geometry.coordinates, null],\n          new arrow.FixedSizeList(2, new arrow.Field('xy', new arrow.Float64()))\n        );\n        const table = new arrow.Table({geometry: points});\n        table.schema.fields[0].metadata.set('ARROW:extension:name', 'geoarrow.point');\n        data = processArrowTable({shape: 'arrow-table', data: table} as any);\n      } else {\n        const value = encoding.endsWith('WKT')\n          ? `POINT (${geometry.coordinates.join(' ')})`\n          : Buffer.from(convertGeometryToWKB(geometry)).toString('hex');\n        if (encoding === 'Arrow WKT') {\n          const column = arrow.vectorFromArray([value, null], new arrow.Utf8());\n          const table = new arrow.Table({geometry: column});\n          data = {\n            fields: arrowSchemaToFields(table, {geometry: 'VARCHAR'}),\n            cols: [column],\n            rows: []\n          };\n        } else {\n          data = processRowObject([{geometry: value}, {geometry: null}]);\n        }\n      }\n      if (!data) throw new Error('Geometry import failed');\n      const dataset = new KeplerTable({color: [1, 2, 3]});\n      await dataset.importData({data});\n      const shared = {\n        data: dataset.dataContainer,\n        fields: dataset.fields,\n        hiddenColumns: ['geometry'],\n        layerName: 'geometry'\n      };\n      const geojson = await encodeDatasetExport({...shared, dataType: EXPORT_DATA_TYPE.GEOJSON});\n      const collection = JSON.parse(String(geojson.data));\n      expect(collection.features.map(feature => feature.geometry)).toEqual([geometry, null]);\n      expect(collection.features[0].properties).not.toHaveProperty('geometry');\n\n      const saved = JSON.parse(JSON.stringify(datasetSchema[VERSIONS.v1].save(dataset)));\n      const loaded = validateInputData(datasetSchema[VERSIONS.v1].load(saved).data);\n      if (!loaded) throw new Error('Saved geometry validation failed');\n      const restored = new KeplerTable({color: [1, 2, 3]}).updateSchema(loaded);\n      expect(datasetToFeatureCollection(restored.dataContainer, restored.fields)).toEqual(\n        collection\n      );\n\n      const shapefile = await encodeDatasetExport({\n        ...shared,\n        dataType: EXPORT_DATA_TYPE.SHAPEFILE\n      });\n      const files = await ZipLoader.parse(shapefile.data);\n      const shp = new DataView(files['geometry.shp']);\n      expect(shp.getInt32(0)).toBe(9994);\n      expect(shp.getInt32(108, true)).toBe(1);\n      expect([shp.getFloat64(112, true), shp.getFloat64(120, true)]).toEqual(geometry.coordinates);\n      expect(shp.getInt32(136, true)).toBe(0);\n    }\n  );\n\n  test.each([[[1, 2]], [['1', '2']], ['[1,2]']])(\n    'preserves numeric point coordinates from %j',\n    value => {\n      const collection = datasetToFeatureCollection(createDataContainer([[value]]), [\n        {name: 'point', type: ALL_FIELD_TYPES.point} as Field\n      ]);\n      expect(collection.features[0].geometry).toEqual({type: 'Point', coordinates: [1, 2]});\n    }\n  );\n\n  test.each([\n    [null, null],\n    ['', ''],\n    ['  ', '\\t'],\n    [null, 10],\n    [10, undefined],\n    ['invalid', 10],\n    [Infinity, 10],\n    [false, true]\n  ])('exports missing or invalid coordinates [%s, %s] as null geometry', async (lat, lng) => {\n    const exported = await encodeDatasetExport({\n      data: createDataContainer([['missing', 'secret', lat, lng]]),\n      fields,\n      fieldPairs,\n      dataType: EXPORT_DATA_TYPE.GEOJSON,\n      layerName: 'missing'\n    });\n    expect(JSON.parse(String(exported.data)).features[0].geometry).toBeNull();\n  });\n\n  test.each([\n    [0, 0],\n    ['0', '0'],\n    [' 37.8 ', '-122.4']\n  ])('preserves valid coordinates [%s, %s]', (lat, lng) => {\n    const collection = datasetToFeatureCollection(\n      createDataContainer([['valid', 'secret', lat, lng]]),\n      fields,\n      {fieldPairs}\n    );\n    expect(collection.features[0].geometry).toEqual({\n      type: 'Point',\n      coordinates: [Number(lng), Number(lat)]\n    });\n  });\n\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 = [...fields, {name: 'altitude', type: ALL_FIELD_TYPES.real}] 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":[]}