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