@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,708 @@
1
+ "use strict";
2
+
3
+ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
4
+ Object.defineProperty(exports, "__esModule", {
5
+ value: true
6
+ });
7
+ exports.writeShapefile = writeShapefile;
8
+ var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
9
+ var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
10
+ var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
11
+ function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
12
+ function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
13
+ function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
14
+ // SPDX-License-Identifier: MIT
15
+ // Copyright contributors to the kepler.gl project
16
+
17
+ // Adapted from GeoLibre (https://github.com/opengeos/GeoLibre), MIT License.
18
+
19
+ /**
20
+ * Write a GeoJSON FeatureCollection to an ESRI Shapefile dataset (the .shp,
21
+ * .shx, .dbf, .prj, and .cpg parts) entirely in the browser.
22
+ *
23
+ * DuckDB-WASM and Pyodide's bundled GDAL cannot write GDAL vector formats in the
24
+ * browser, so the binary parts are assembled directly. The dataset is WGS84
25
+ * (EPSG:4326). All non-null geometries must share one shape family
26
+ * (point/line/polygon). Null geometries are written as the Shapefile "Null"
27
+ * shape so the record count still lines up with the .dbf.
28
+ */
29
+
30
+ var SHAPE_NULL = 0;
31
+ var SHAPE_POINT = 1;
32
+ var SHAPE_POLYLINE = 3;
33
+ var SHAPE_POLYGON = 5;
34
+ var SHAPE_MULTIPOINT = 8;
35
+ var WGS84_PRJ = 'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",' + '6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],' + 'UNIT["Degree",0.0174532925199433]]';
36
+ function familyOf(geometry) {
37
+ switch (geometry.type) {
38
+ case 'Point':
39
+ case 'MultiPoint':
40
+ return 'point';
41
+ case 'LineString':
42
+ case 'MultiLineString':
43
+ return 'line';
44
+ case 'Polygon':
45
+ case 'MultiPolygon':
46
+ return 'polygon';
47
+ default:
48
+ return null;
49
+ }
50
+ }
51
+
52
+ /** Pick the single Shapefile shape type for the whole file. */
53
+ function fileShapeType(features) {
54
+ var family = null;
55
+ var hasMultiPoint = false;
56
+ var _iterator = _createForOfIteratorHelper(features),
57
+ _step;
58
+ try {
59
+ for (_iterator.s(); !(_step = _iterator.n()).done;) {
60
+ var feature = _step.value;
61
+ if (!feature.geometry) continue;
62
+ var geomFamily = familyOf(feature.geometry);
63
+ if (!geomFamily) {
64
+ throw new Error("Shapefile export does not support ".concat(feature.geometry.type, " geometries."));
65
+ }
66
+ if (family !== null && family !== geomFamily) {
67
+ throw new Error('Shapefile export requires all geometries to have the same shape family.');
68
+ }
69
+ if (family === null) family = geomFamily;
70
+ if (feature.geometry.type === 'MultiPoint') hasMultiPoint = true;
71
+ }
72
+ } catch (err) {
73
+ _iterator.e(err);
74
+ } finally {
75
+ _iterator.f();
76
+ }
77
+ if (family === null) {
78
+ throw new Error('The layer has no supported geometries to export.');
79
+ }
80
+ if (family === 'point') {
81
+ return {
82
+ type: hasMultiPoint ? SHAPE_MULTIPOINT : SHAPE_POINT,
83
+ family: family
84
+ };
85
+ }
86
+ return {
87
+ type: family === 'line' ? SHAPE_POLYLINE : SHAPE_POLYGON,
88
+ family: family
89
+ };
90
+ }
91
+
92
+ /** Signed area of a ring; positive is counter-clockwise (screen coords, y up). */
93
+ function ringSignedArea(ring) {
94
+ var area = 0;
95
+ for (var i = 0; i < ring.length - 1; i += 1) {
96
+ var _ring$i = (0, _slicedToArray2["default"])(ring[i], 2),
97
+ x1 = _ring$i[0],
98
+ y1 = _ring$i[1];
99
+ var _ring = (0, _slicedToArray2["default"])(ring[i + 1], 2),
100
+ x2 = _ring[0],
101
+ y2 = _ring[1];
102
+ area += Number(x1) * Number(y2) - Number(x2) * Number(y1);
103
+ }
104
+ return area / 2;
105
+ }
106
+
107
+ /** Return a ring oriented clockwise (`wantClockwise`) or counter-clockwise.
108
+ * Shapefile polygons require clockwise outer rings and counter-clockwise holes. */
109
+ function orientRing(ring, wantClockwise) {
110
+ var isClockwise = ringSignedArea(ring) < 0;
111
+ return isClockwise === wantClockwise ? ring : (0, _toConsumableArray2["default"])(ring).reverse();
112
+ }
113
+
114
+ /** Flatten a geometry into Shapefile "parts" (rings/lines) of positions, with
115
+ * polygon rings reoriented for the Shapefile convention. */
116
+ function geometryParts(geometry, family) {
117
+ if (family === 'line') {
118
+ if (geometry.type === 'LineString') return [geometry.coordinates];
119
+ if (geometry.type === 'MultiLineString') return geometry.coordinates;
120
+ return [];
121
+ }
122
+ // polygon
123
+ var polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.type === 'MultiPolygon' ? geometry.coordinates : [];
124
+ var parts = [];
125
+ var _iterator2 = _createForOfIteratorHelper(polygons),
126
+ _step2;
127
+ try {
128
+ for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
129
+ var rings = _step2.value;
130
+ rings.forEach(function (ring, index) {
131
+ // First ring of each polygon is the outer ring (clockwise); the rest are
132
+ // holes (counter-clockwise).
133
+ parts.push(orientRing(ring, index === 0));
134
+ });
135
+ }
136
+ } catch (err) {
137
+ _iterator2.e(err);
138
+ } finally {
139
+ _iterator2.f();
140
+ }
141
+ return parts;
142
+ }
143
+ function pointsOf(geometry) {
144
+ if (geometry.type === 'Point') return [geometry.coordinates];
145
+ if (geometry.type === 'MultiPoint') return geometry.coordinates;
146
+ return [];
147
+ }
148
+ function emptyBox() {
149
+ return {
150
+ minX: Infinity,
151
+ minY: Infinity,
152
+ maxX: -Infinity,
153
+ maxY: -Infinity
154
+ };
155
+ }
156
+ function extend(box, x, y) {
157
+ if (Number.isFinite(x)) {
158
+ box.minX = Math.min(box.minX, x);
159
+ box.maxX = Math.max(box.maxX, x);
160
+ }
161
+ if (Number.isFinite(y)) {
162
+ box.minY = Math.min(box.minY, y);
163
+ box.maxY = Math.max(box.maxY, y);
164
+ }
165
+ }
166
+ function safeBox(box) {
167
+ return Number.isFinite(box.minX) ? box : {
168
+ minX: 0,
169
+ minY: 0,
170
+ maxX: 0,
171
+ maxY: 0
172
+ };
173
+ }
174
+
175
+ /** Encode one geometry's Shapefile record content (without the 8-byte record
176
+ * header). Returns the content bytes and accumulates into the file bbox. */
177
+ function encodeShape(geometry, shapeType, family, fileBox) {
178
+ if (!geometry || familyOf(geometry) !== family) {
179
+ // Null shape: just the int32 little-endian shape type 0.
180
+ var nullShape = new Uint8Array(4);
181
+ new DataView(nullShape.buffer).setInt32(0, SHAPE_NULL, true);
182
+ return nullShape;
183
+ }
184
+ if (shapeType === SHAPE_POINT) {
185
+ var _pointsOf$;
186
+ var _ref = (_pointsOf$ = pointsOf(geometry)[0]) !== null && _pointsOf$ !== void 0 ? _pointsOf$ : [0, 0],
187
+ _ref2 = (0, _slicedToArray2["default"])(_ref, 2),
188
+ x = _ref2[0],
189
+ y = _ref2[1];
190
+ extend(fileBox, Number(x), Number(y));
191
+ var _content = new Uint8Array(20);
192
+ var _view = new DataView(_content.buffer);
193
+ _view.setInt32(0, SHAPE_POINT, true);
194
+ _view.setFloat64(4, Number(x), true);
195
+ _view.setFloat64(12, Number(y), true);
196
+ return _content;
197
+ }
198
+ if (shapeType === SHAPE_MULTIPOINT) {
199
+ var points = pointsOf(geometry);
200
+ var _box = emptyBox();
201
+ var _iterator3 = _createForOfIteratorHelper(points),
202
+ _step3;
203
+ try {
204
+ for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
205
+ var _step3$value = (0, _slicedToArray2["default"])(_step3.value, 2),
206
+ _x = _step3$value[0],
207
+ _y = _step3$value[1];
208
+ extend(_box, Number(_x), Number(_y));
209
+ }
210
+ } catch (err) {
211
+ _iterator3.e(err);
212
+ } finally {
213
+ _iterator3.f();
214
+ }
215
+ var _drawn = safeBox(_box);
216
+ extend(fileBox, _drawn.minX, _drawn.minY);
217
+ extend(fileBox, _drawn.maxX, _drawn.maxY);
218
+ var _content2 = new Uint8Array(4 + 32 + 4 + points.length * 16);
219
+ var _view2 = new DataView(_content2.buffer);
220
+ _view2.setInt32(0, SHAPE_MULTIPOINT, true);
221
+ _view2.setFloat64(4, _drawn.minX, true);
222
+ _view2.setFloat64(12, _drawn.minY, true);
223
+ _view2.setFloat64(20, _drawn.maxX, true);
224
+ _view2.setFloat64(28, _drawn.maxY, true);
225
+ _view2.setInt32(36, points.length, true);
226
+ var _offset = 40;
227
+ var _iterator4 = _createForOfIteratorHelper(points),
228
+ _step4;
229
+ try {
230
+ for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
231
+ var _step4$value = (0, _slicedToArray2["default"])(_step4.value, 2),
232
+ _x2 = _step4$value[0],
233
+ _y2 = _step4$value[1];
234
+ _view2.setFloat64(_offset, Number(_x2), true);
235
+ _view2.setFloat64(_offset + 8, Number(_y2), true);
236
+ _offset += 16;
237
+ }
238
+ } catch (err) {
239
+ _iterator4.e(err);
240
+ } finally {
241
+ _iterator4.f();
242
+ }
243
+ return _content2;
244
+ }
245
+
246
+ // PolyLine (3) or Polygon (5): identical record layout.
247
+ var parts = geometryParts(geometry, family);
248
+ var numParts = parts.length;
249
+ var flatPoints = parts.flat();
250
+ var box = emptyBox();
251
+ var _iterator5 = _createForOfIteratorHelper(flatPoints),
252
+ _step5;
253
+ try {
254
+ for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
255
+ var _step5$value = (0, _slicedToArray2["default"])(_step5.value, 2),
256
+ _x3 = _step5$value[0],
257
+ _y3 = _step5$value[1];
258
+ extend(box, Number(_x3), Number(_y3));
259
+ }
260
+ } catch (err) {
261
+ _iterator5.e(err);
262
+ } finally {
263
+ _iterator5.f();
264
+ }
265
+ var drawn = safeBox(box);
266
+ extend(fileBox, drawn.minX, drawn.minY);
267
+ extend(fileBox, drawn.maxX, drawn.maxY);
268
+ var content = new Uint8Array(4 + 32 + 4 + 4 + numParts * 4 + flatPoints.length * 16);
269
+ var view = new DataView(content.buffer);
270
+ view.setInt32(0, shapeType, true);
271
+ view.setFloat64(4, drawn.minX, true);
272
+ view.setFloat64(12, drawn.minY, true);
273
+ view.setFloat64(20, drawn.maxX, true);
274
+ view.setFloat64(28, drawn.maxY, true);
275
+ view.setInt32(36, numParts, true);
276
+ view.setInt32(40, flatPoints.length, true);
277
+ var offset = 44;
278
+ var runningIndex = 0;
279
+ var _iterator6 = _createForOfIteratorHelper(parts),
280
+ _step6;
281
+ try {
282
+ for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
283
+ var part = _step6.value;
284
+ view.setInt32(offset, runningIndex, true);
285
+ offset += 4;
286
+ runningIndex += part.length;
287
+ }
288
+ } catch (err) {
289
+ _iterator6.e(err);
290
+ } finally {
291
+ _iterator6.f();
292
+ }
293
+ var _iterator7 = _createForOfIteratorHelper(flatPoints),
294
+ _step7;
295
+ try {
296
+ for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
297
+ var _step7$value = (0, _slicedToArray2["default"])(_step7.value, 2),
298
+ _x4 = _step7$value[0],
299
+ _y4 = _step7$value[1];
300
+ view.setFloat64(offset, Number(_x4), true);
301
+ view.setFloat64(offset + 8, Number(_y4), true);
302
+ offset += 16;
303
+ }
304
+ } catch (err) {
305
+ _iterator7.e(err);
306
+ } finally {
307
+ _iterator7.f();
308
+ }
309
+ return content;
310
+ }
311
+
312
+ /** Write the 100-byte .shp/.shx header. `fileWords` is the file length in
313
+ * 16-bit words; `box` the dataset bounding box. */
314
+ function writeMainHeader(target, shapeType, fileWords, box) {
315
+ var view = new DataView(target.buffer, target.byteOffset, 100);
316
+ view.setInt32(0, 9994, false); // file code (big-endian)
317
+ view.setInt32(24, fileWords, false); // file length in words (big-endian)
318
+ view.setInt32(28, 1000, true); // version (little-endian)
319
+ view.setInt32(32, shapeType, true);
320
+ var drawn = safeBox(box);
321
+ view.setFloat64(36, drawn.minX, true);
322
+ view.setFloat64(44, drawn.minY, true);
323
+ view.setFloat64(52, drawn.maxX, true);
324
+ view.setFloat64(60, drawn.maxY, true);
325
+ // Z and M ranges remain zero (2D output).
326
+ }
327
+
328
+ // ----- DBF (attribute table) -----
329
+
330
+ var TEXT_ENCODER = new TextEncoder();
331
+ // This writer emits a dBASE III table (version 0x03), whose numeric fields
332
+ // support at most 19 total bytes and 15 digits after the decimal point.
333
+ var DBF_NUMERIC_MAX_WIDTH = 19;
334
+ var DBF_NUMERIC_MAX_DECIMALS = 15;
335
+
336
+ /** Encode `text` to UTF-8, truncated to at most `maxBytes` without splitting a
337
+ * multi-byte code point (so non-ASCII attribute values stay valid). */
338
+ function encodeUtf8Truncated(text, maxBytes) {
339
+ var full = TEXT_ENCODER.encode(text);
340
+ if (full.length <= maxBytes) return full;
341
+ var length = 0;
342
+ var _iterator8 = _createForOfIteratorHelper(text),
343
+ _step8;
344
+ try {
345
+ for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
346
+ var _char = _step8.value;
347
+ var size = TEXT_ENCODER.encode(_char).length;
348
+ if (length + size > maxBytes) break;
349
+ length += size;
350
+ }
351
+ } catch (err) {
352
+ _iterator8.e(err);
353
+ } finally {
354
+ _iterator8.f();
355
+ }
356
+ return full.subarray(0, length);
357
+ }
358
+ function dbfFieldName(key, taken) {
359
+ // DBF field names are at most 10 characters; truncate and de-duplicate.
360
+ var base = key.replace(/[^0-9A-Za-z_]/g, '_').slice(0, 10) || 'field';
361
+ if (!taken.has(base.toUpperCase())) {
362
+ taken.add(base.toUpperCase());
363
+ return base;
364
+ }
365
+ for (var i = 1; i < 1000; i += 1) {
366
+ var suffix = String(i);
367
+ var candidate = "".concat(base.slice(0, 10 - suffix.length)).concat(suffix);
368
+ if (!taken.has(candidate.toUpperCase())) {
369
+ taken.add(candidate.toUpperCase());
370
+ return candidate;
371
+ }
372
+ }
373
+ // Falling through means >999 fields share one 10-char prefix; returning a
374
+ // name already in `taken` would write a duplicate DBF column. Fail loudly
375
+ // instead of silently corrupting the file.
376
+ throw new Error("Cannot generate a unique DBF field name for \"".concat(key, "\" (>999 collisions)."));
377
+ }
378
+
379
+ /** DBF numeric fields only allow digits, a sign, and a decimal point. */
380
+ function decimalText(value) {
381
+ var text = String(value);
382
+ var match = /^(-?)(\d+)(?:\.(\d+))?e([+-]?\d+)$/i.exec(text);
383
+ if (!match) return text;
384
+ var _match = (0, _slicedToArray2["default"])(match, 5),
385
+ sign = _match[1],
386
+ integer = _match[2],
387
+ _match$ = _match[3],
388
+ fraction = _match$ === void 0 ? '' : _match$,
389
+ rawExponent = _match[4];
390
+ var digits = "".concat(integer).concat(fraction);
391
+ var decimalIndex = integer.length + Number(rawExponent);
392
+ if (decimalIndex <= 0) {
393
+ return "".concat(sign, "0.").concat('0'.repeat(-decimalIndex)).concat(digits);
394
+ }
395
+ if (decimalIndex >= digits.length) {
396
+ return "".concat(sign).concat(digits).concat('0'.repeat(decimalIndex - digits.length));
397
+ }
398
+ return "".concat(sign).concat(digits.slice(0, decimalIndex), ".").concat(digits.slice(decimalIndex));
399
+ }
400
+ function decimalPlaces(text) {
401
+ var dot = text.indexOf('.');
402
+ if (dot < 0) return 0;
403
+ return text.length - dot - 1;
404
+ }
405
+ function formatDbfNumber(value, decimals) {
406
+ // Number#toFixed provides the rounding policy and fixed notation below 1e21.
407
+ // Larger values cannot fit a dBASE III numeric field even at zero decimals,
408
+ // but expanding them here lets field planning report their actual width.
409
+ var text = Math.abs(value) < 1e21 ? value.toFixed(decimals) : "".concat(decimalText(value)).concat(decimals > 0 ? ".".concat('0'.repeat(decimals)) : '');
410
+ // Do not spend a sign byte on a value that rounded to zero.
411
+ return /^-0(?:\.0+)?$/.test(text) ? text.slice(1) : text;
412
+ }
413
+ function planField(key, name, values) {
414
+ var sawNumber = false;
415
+ var sawNonNumber = false;
416
+ var sawBoolean = false;
417
+ var sawNonBoolean = false;
418
+ var _iterator9 = _createForOfIteratorHelper(values),
419
+ _step9;
420
+ try {
421
+ for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
422
+ var _value2 = _step9.value;
423
+ if (_value2 == null) continue;
424
+ if (typeof _value2 === 'boolean') {
425
+ sawBoolean = true;
426
+ } else {
427
+ sawNonBoolean = true;
428
+ }
429
+ if (typeof _value2 === 'number' && Number.isFinite(_value2)) {
430
+ sawNumber = true;
431
+ } else {
432
+ sawNonNumber = true;
433
+ }
434
+ }
435
+ } catch (err) {
436
+ _iterator9.e(err);
437
+ } finally {
438
+ _iterator9.f();
439
+ }
440
+ if (sawBoolean && !sawNonBoolean) {
441
+ return {
442
+ key: key,
443
+ name: name,
444
+ type: 'L',
445
+ length: 1,
446
+ decimals: 0
447
+ };
448
+ }
449
+ if (sawNumber && !sawNonNumber) {
450
+ var requestedDecimals = 0;
451
+ var _iterator0 = _createForOfIteratorHelper(values),
452
+ _step0;
453
+ try {
454
+ for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
455
+ var _value = _step0.value;
456
+ if (typeof _value === 'number' && Number.isFinite(_value)) {
457
+ requestedDecimals = Math.max(requestedDecimals, decimalPlaces(decimalText(_value)));
458
+ }
459
+ }
460
+
461
+ // Use the highest common precision that fits every rounded value. Measuring
462
+ // the formatted values on each pass accounts for signs and rounding carry.
463
+ } catch (err) {
464
+ _iterator0.e(err);
465
+ } finally {
466
+ _iterator0.f();
467
+ }
468
+ for (var decimals = Math.min(requestedDecimals, DBF_NUMERIC_MAX_DECIMALS); decimals >= 0; decimals -= 1) {
469
+ var _length = 1;
470
+ var _iterator1 = _createForOfIteratorHelper(values),
471
+ _step1;
472
+ try {
473
+ for (_iterator1.s(); !(_step1 = _iterator1.n()).done;) {
474
+ var value = _step1.value;
475
+ if (typeof value !== 'number' || !Number.isFinite(value)) continue;
476
+ _length = Math.max(_length, formatDbfNumber(value, decimals).length);
477
+ }
478
+ } catch (err) {
479
+ _iterator1.e(err);
480
+ } finally {
481
+ _iterator1.f();
482
+ }
483
+ if (_length <= DBF_NUMERIC_MAX_WIDTH) {
484
+ return {
485
+ key: key,
486
+ name: name,
487
+ type: 'N',
488
+ length: _length,
489
+ decimals: decimals
490
+ };
491
+ }
492
+ if (decimals === 0) {
493
+ throw new Error("DBF numeric field \"".concat(key, "\" requires ").concat(_length, " bytes at zero decimal places; ") + "dBASE III numeric fields support at most ".concat(DBF_NUMERIC_MAX_WIDTH, "."));
494
+ }
495
+ }
496
+ }
497
+
498
+ // Fall back to text for everything else (strings, mixed types, objects).
499
+ var length = 1;
500
+ var _iterator10 = _createForOfIteratorHelper(values),
501
+ _step10;
502
+ try {
503
+ for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
504
+ var _value3 = _step10.value;
505
+ if (_value3 == null) continue;
506
+ var text = (0, _typeof2["default"])(_value3) === 'object' ? JSON.stringify(_value3) : String(_value3);
507
+ length = Math.max(length, TEXT_ENCODER.encode(text).length);
508
+ }
509
+ } catch (err) {
510
+ _iterator10.e(err);
511
+ } finally {
512
+ _iterator10.f();
513
+ }
514
+ return {
515
+ key: key,
516
+ name: name,
517
+ type: 'C',
518
+ length: Math.min(length, 254),
519
+ decimals: 0
520
+ };
521
+ }
522
+ function encodeDbfValue(value, field) {
523
+ var cell = new Uint8Array(field.length).fill(0x20); // space-padded
524
+ if (value == null) return cell;
525
+ if (field.type === 'L') {
526
+ cell[0] = value ? 0x54 : 0x46; // 'T' / 'F'
527
+ return cell;
528
+ }
529
+ if (field.type === 'N') {
530
+ if (typeof value !== 'number' || !Number.isFinite(value)) return cell;
531
+ var _text = formatDbfNumber(value, field.decimals);
532
+ if (_text.length > field.length) {
533
+ throw new Error("DBF numeric value for \"".concat(field.key, "\" exceeds its planned field width."));
534
+ }
535
+ // Numbers are right-justified in DBF.
536
+ var bytes = TEXT_ENCODER.encode(_text);
537
+ cell.set(bytes, field.length - bytes.length);
538
+ return cell;
539
+ }
540
+
541
+ // Text: left-justified, truncated to the field byte length on a code-point
542
+ // boundary so multi-byte characters are never cut mid-sequence.
543
+ var text = (0, _typeof2["default"])(value) === 'object' ? JSON.stringify(value) : String(value);
544
+ cell.set(encodeUtf8Truncated(text, field.length), 0);
545
+ return cell;
546
+ }
547
+ function buildDbf(features, fields) {
548
+ var recordLength = 1 + fields.reduce(function (total, field) {
549
+ return total + field.length;
550
+ }, 0);
551
+ var headerLength = 32 + fields.length * 32 + 1;
552
+ // Both are serialized as uint16; too many or too-wide attributes would
553
+ // overflow and silently corrupt the .dbf, so fail fast instead.
554
+ if (recordLength > 0xffff || headerLength > 0xffff) {
555
+ throw new Error('Too many or too-wide attributes for the DBF format limits.');
556
+ }
557
+ var total = headerLength + features.length * recordLength + 1; // +1 EOF
558
+ var buffer = new Uint8Array(total);
559
+ var view = new DataView(buffer.buffer);
560
+ buffer[0] = 0x03; // dBASE III without memo
561
+ var now = new Date();
562
+ buffer[1] = now.getFullYear() - 1900;
563
+ buffer[2] = now.getMonth() + 1;
564
+ buffer[3] = now.getDate();
565
+ view.setUint32(4, features.length, true);
566
+ view.setUint16(8, headerLength, true);
567
+ view.setUint16(10, recordLength, true);
568
+ var offset = 32;
569
+ var _iterator11 = _createForOfIteratorHelper(fields),
570
+ _step11;
571
+ try {
572
+ for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
573
+ var field = _step11.value;
574
+ var nameBytes = TEXT_ENCODER.encode(field.name).subarray(0, 11);
575
+ buffer.set(nameBytes, offset); // remaining name bytes stay 0 (null-padded)
576
+ buffer[offset + 11] = field.type.charCodeAt(0);
577
+ buffer[offset + 16] = field.length;
578
+ buffer[offset + 17] = field.decimals;
579
+ offset += 32;
580
+ }
581
+ } catch (err) {
582
+ _iterator11.e(err);
583
+ } finally {
584
+ _iterator11.f();
585
+ }
586
+ buffer[offset] = 0x0d; // field descriptor terminator
587
+ offset += 1;
588
+ var _iterator12 = _createForOfIteratorHelper(features),
589
+ _step12;
590
+ try {
591
+ for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
592
+ var feature = _step12.value;
593
+ buffer[offset] = 0x20; // record not deleted
594
+ offset += 1;
595
+ var _iterator13 = _createForOfIteratorHelper(fields),
596
+ _step13;
597
+ try {
598
+ for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
599
+ var _feature$properties;
600
+ var _field = _step13.value;
601
+ var cell = encodeDbfValue((_feature$properties = feature.properties) === null || _feature$properties === void 0 ? void 0 : _feature$properties[_field.key], _field);
602
+ buffer.set(cell, offset);
603
+ offset += _field.length;
604
+ }
605
+ } catch (err) {
606
+ _iterator13.e(err);
607
+ } finally {
608
+ _iterator13.f();
609
+ }
610
+ }
611
+ } catch (err) {
612
+ _iterator12.e(err);
613
+ } finally {
614
+ _iterator12.f();
615
+ }
616
+ buffer[offset] = 0x1a; // end-of-file marker
617
+ return buffer;
618
+ }
619
+
620
+ /**
621
+ * Assemble the parts of an ESRI Shapefile from a FeatureCollection.
622
+ *
623
+ * Args:
624
+ * geojson: Features to write (assumed WGS84).
625
+ *
626
+ * Returns:
627
+ * The .shp/.shx/.dbf/.prj/.cpg byte buffers (the caller names and zips them).
628
+ */
629
+ function writeShapefile(geojson) {
630
+ var _geojson$features;
631
+ var features = (_geojson$features = geojson.features) !== null && _geojson$features !== void 0 ? _geojson$features : [];
632
+ if (features.length === 0) {
633
+ throw new Error('The layer has no features to export.');
634
+ }
635
+ var _fileShapeType = fileShapeType(features),
636
+ shapeType = _fileShapeType.type,
637
+ family = _fileShapeType.family;
638
+ var fileBox = emptyBox();
639
+ var contents = features.map(function (feature) {
640
+ return encodeShape(feature.geometry, shapeType, family, fileBox);
641
+ });
642
+
643
+ // .shp: 100-byte header + per-record (8-byte header + content).
644
+ var shpSize = 100 + contents.reduce(function (total, content) {
645
+ return total + 8 + content.length;
646
+ }, 0);
647
+ var shp = new Uint8Array(shpSize);
648
+ var shpView = new DataView(shp.buffer);
649
+ var shxSize = 100 + contents.length * 8;
650
+ var shx = new Uint8Array(shxSize);
651
+ var shxView = new DataView(shx.buffer);
652
+ writeMainHeader(shp, shapeType, shpSize / 2, fileBox);
653
+ writeMainHeader(shx, shapeType, shxSize / 2, fileBox);
654
+ var shpOffset = 100;
655
+ var shxOffset = 100;
656
+ contents.forEach(function (content, index) {
657
+ var contentWords = content.length / 2;
658
+ var recordOffsetWords = shpOffset / 2;
659
+ // Record header (big-endian): 1-based record number + content length.
660
+ shpView.setInt32(shpOffset, index + 1, false);
661
+ shpView.setInt32(shpOffset + 4, contentWords, false);
662
+ shp.set(content, shpOffset + 8);
663
+ shpOffset += 8 + content.length;
664
+ // .shx entry (big-endian): record offset + content length, both in words.
665
+ shxView.setInt32(shxOffset, recordOffsetWords, false);
666
+ shxView.setInt32(shxOffset + 4, contentWords, false);
667
+ shxOffset += 8;
668
+ });
669
+
670
+ // DBF fields from the union of property keys across all features.
671
+ var keys = [];
672
+ var seen = new Set();
673
+ var _iterator14 = _createForOfIteratorHelper(features),
674
+ _step14;
675
+ try {
676
+ for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {
677
+ var feature = _step14.value;
678
+ for (var _i = 0, _Object$keys = Object.keys((_feature$properties3 = feature.properties) !== null && _feature$properties3 !== void 0 ? _feature$properties3 : {}); _i < _Object$keys.length; _i++) {
679
+ var _feature$properties3;
680
+ var key = _Object$keys[_i];
681
+ if (!seen.has(key)) {
682
+ seen.add(key);
683
+ keys.push(key);
684
+ }
685
+ }
686
+ }
687
+ } catch (err) {
688
+ _iterator14.e(err);
689
+ } finally {
690
+ _iterator14.f();
691
+ }
692
+ var takenNames = new Set();
693
+ var fields = keys.map(function (key) {
694
+ return planField(key, dbfFieldName(key, takenNames), features.map(function (feature) {
695
+ var _feature$properties2;
696
+ return (_feature$properties2 = feature.properties) === null || _feature$properties2 === void 0 ? void 0 : _feature$properties2[key];
697
+ }));
698
+ });
699
+ var dbf = buildDbf(features, fields);
700
+ return {
701
+ shp: shp,
702
+ shx: shx,
703
+ dbf: dbf,
704
+ prj: TEXT_ENCODER.encode(WGS84_PRJ),
705
+ cpg: TEXT_ENCODER.encode('UTF-8')
706
+ };
707
+ }
708
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["SHAPE_NULL","SHAPE_POINT","SHAPE_POLYLINE","SHAPE_POLYGON","SHAPE_MULTIPOINT","WGS84_PRJ","familyOf","geometry","type","fileShapeType","features","family","hasMultiPoint","_iterator","_createForOfIteratorHelper","_step","s","n","done","feature","value","geomFamily","Error","concat","err","e","f","ringSignedArea","ring","area","i","length","_ring$i","_slicedToArray2","x1","y1","_ring","x2","y2","Number","orientRing","wantClockwise","isClockwise","_toConsumableArray2","reverse","geometryParts","coordinates","polygons","parts","_iterator2","_step2","rings","forEach","index","push","pointsOf","emptyBox","minX","Infinity","minY","maxX","maxY","extend","box","x","y","isFinite","Math","min","max","safeBox","encodeShape","shapeType","fileBox","nullShape","Uint8Array","DataView","buffer","setInt32","_pointsOf$","_ref","_ref2","content","view","setFloat64","points","_iterator3","_step3","_step3$value","drawn","offset","_iterator4","_step4","_step4$value","numParts","flatPoints","flat","_iterator5","_step5","_step5$value","runningIndex","_iterator6","_step6","part","_iterator7","_step7","_step7$value","writeMainHeader","target","fileWords","byteOffset","TEXT_ENCODER","TextEncoder","DBF_NUMERIC_MAX_WIDTH","DBF_NUMERIC_MAX_DECIMALS","encodeUtf8Truncated","text","maxBytes","full","encode","_iterator8","_step8","char","size","subarray","dbfFieldName","key","taken","base","replace","slice","has","toUpperCase","add","suffix","String","candidate","decimalText","match","exec","_match","sign","integer","_match$","fraction","rawExponent","digits","decimalIndex","repeat","decimalPlaces","dot","indexOf","formatDbfNumber","decimals","abs","toFixed","test","planField","name","values","sawNumber","sawNonNumber","sawBoolean","sawNonBoolean","_iterator9","_step9","requestedDecimals","_iterator0","_step0","_iterator1","_step1","_iterator10","_step10","_typeof2","JSON","stringify","encodeDbfValue","field","cell","fill","bytes","set","buildDbf","fields","recordLength","reduce","total","headerLength","now","Date","getFullYear","getMonth","getDate","setUint32","setUint16","_iterator11","_step11","nameBytes","charCodeAt","_iterator12","_step12","_iterator13","_step13","_feature$properties","properties","writeShapefile","geojson","_geojson$features","_fileShapeType","contents","map","shpSize","shp","shpView","shxSize","shx","shxView","shpOffset","shxOffset","contentWords","recordOffsetWords","keys","seen","Set","_iterator14","_step14","_i","_Object$keys","Object","_feature$properties3","takenNames","_feature$properties2","dbf","prj","cpg"],"sources":["../../../src/export/shapefile-writer.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\n// Adapted from GeoLibre (https://github.com/opengeos/GeoLibre), MIT License.\n\nimport type {Feature, FeatureCollection, Geometry, Position} from 'geojson';\n\n/**\n * Write a GeoJSON FeatureCollection to an ESRI Shapefile dataset (the .shp,\n * .shx, .dbf, .prj, and .cpg parts) entirely in the browser.\n *\n * DuckDB-WASM and Pyodide's bundled GDAL cannot write GDAL vector formats in the\n * browser, so the binary parts are assembled directly. The dataset is WGS84\n * (EPSG:4326). All non-null geometries must share one shape family\n * (point/line/polygon). Null geometries are written as the Shapefile \"Null\"\n * shape so the record count still lines up with the .dbf.\n */\n\nexport interface ShapefileParts {\n  shp: Uint8Array;\n  shx: Uint8Array;\n  dbf: Uint8Array;\n  prj: Uint8Array;\n  cpg: Uint8Array;\n}\n\nconst SHAPE_NULL = 0;\nconst SHAPE_POINT = 1;\nconst SHAPE_POLYLINE = 3;\nconst SHAPE_POLYGON = 5;\nconst SHAPE_MULTIPOINT = 8;\n\nconst WGS84_PRJ =\n  'GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",' +\n  '6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],' +\n  'UNIT[\"Degree\",0.0174532925199433]]';\n\ntype Family = 'point' | 'line' | 'polygon';\n\nfunction familyOf(geometry: Geometry): Family | null {\n  switch (geometry.type) {\n    case 'Point':\n    case 'MultiPoint':\n      return 'point';\n    case 'LineString':\n    case 'MultiLineString':\n      return 'line';\n    case 'Polygon':\n    case 'MultiPolygon':\n      return 'polygon';\n    default:\n      return null;\n  }\n}\n\n/** Pick the single Shapefile shape type for the whole file. */\nfunction fileShapeType(features: Feature[]): {type: number; family: Family} {\n  let family: Family | null = null;\n  let hasMultiPoint = false;\n  for (const feature of features) {\n    if (!feature.geometry) continue;\n    const geomFamily = familyOf(feature.geometry);\n    if (!geomFamily) {\n      throw new Error(`Shapefile export does not support ${feature.geometry.type} geometries.`);\n    }\n    if (family !== null && family !== geomFamily) {\n      throw new Error('Shapefile export requires all geometries to have the same shape family.');\n    }\n    if (family === null) family = geomFamily;\n    if (feature.geometry.type === 'MultiPoint') hasMultiPoint = true;\n  }\n  if (family === null) {\n    throw new Error('The layer has no supported geometries to export.');\n  }\n  if (family === 'point') {\n    return {type: hasMultiPoint ? SHAPE_MULTIPOINT : SHAPE_POINT, family};\n  }\n  return {type: family === 'line' ? SHAPE_POLYLINE : SHAPE_POLYGON, family};\n}\n\n/** Signed area of a ring; positive is counter-clockwise (screen coords, y up). */\nfunction ringSignedArea(ring: Position[]): number {\n  let area = 0;\n  for (let i = 0; i < ring.length - 1; i += 1) {\n    const [x1, y1] = ring[i];\n    const [x2, y2] = ring[i + 1];\n    area += Number(x1) * Number(y2) - Number(x2) * Number(y1);\n  }\n  return area / 2;\n}\n\n/** Return a ring oriented clockwise (`wantClockwise`) or counter-clockwise.\n * Shapefile polygons require clockwise outer rings and counter-clockwise holes. */\nfunction orientRing(ring: Position[], wantClockwise: boolean): Position[] {\n  const isClockwise = ringSignedArea(ring) < 0;\n  return isClockwise === wantClockwise ? ring : [...ring].reverse();\n}\n\n/** Flatten a geometry into Shapefile \"parts\" (rings/lines) of positions, with\n * polygon rings reoriented for the Shapefile convention. */\nfunction geometryParts(geometry: Geometry, family: Family): Position[][] {\n  if (family === 'line') {\n    if (geometry.type === 'LineString') return [geometry.coordinates];\n    if (geometry.type === 'MultiLineString') return geometry.coordinates;\n    return [];\n  }\n  // polygon\n  const polygons =\n    geometry.type === 'Polygon'\n      ? [geometry.coordinates]\n      : geometry.type === 'MultiPolygon'\n      ? geometry.coordinates\n      : [];\n  const parts: Position[][] = [];\n  for (const rings of polygons) {\n    rings.forEach((ring, index) => {\n      // First ring of each polygon is the outer ring (clockwise); the rest are\n      // holes (counter-clockwise).\n      parts.push(orientRing(ring, index === 0));\n    });\n  }\n  return parts;\n}\n\nfunction pointsOf(geometry: Geometry): Position[] {\n  if (geometry.type === 'Point') return [geometry.coordinates];\n  if (geometry.type === 'MultiPoint') return geometry.coordinates;\n  return [];\n}\n\ninterface Box {\n  minX: number;\n  minY: number;\n  maxX: number;\n  maxY: number;\n}\n\nfunction emptyBox(): Box {\n  return {minX: Infinity, minY: Infinity, maxX: -Infinity, maxY: -Infinity};\n}\n\nfunction extend(box: Box, x: number, y: number): void {\n  if (Number.isFinite(x)) {\n    box.minX = Math.min(box.minX, x);\n    box.maxX = Math.max(box.maxX, x);\n  }\n  if (Number.isFinite(y)) {\n    box.minY = Math.min(box.minY, y);\n    box.maxY = Math.max(box.maxY, y);\n  }\n}\n\nfunction safeBox(box: Box): Box {\n  return Number.isFinite(box.minX) ? box : {minX: 0, minY: 0, maxX: 0, maxY: 0};\n}\n\n/** Encode one geometry's Shapefile record content (without the 8-byte record\n * header). Returns the content bytes and accumulates into the file bbox. */\nfunction encodeShape(\n  geometry: Geometry | null,\n  shapeType: number,\n  family: Family,\n  fileBox: Box\n): Uint8Array {\n  if (!geometry || familyOf(geometry) !== family) {\n    // Null shape: just the int32 little-endian shape type 0.\n    const nullShape = new Uint8Array(4);\n    new DataView(nullShape.buffer).setInt32(0, SHAPE_NULL, true);\n    return nullShape;\n  }\n\n  if (shapeType === SHAPE_POINT) {\n    const [x, y] = pointsOf(geometry)[0] ?? [0, 0];\n    extend(fileBox, Number(x), Number(y));\n    const content = new Uint8Array(20);\n    const view = new DataView(content.buffer);\n    view.setInt32(0, SHAPE_POINT, true);\n    view.setFloat64(4, Number(x), true);\n    view.setFloat64(12, Number(y), true);\n    return content;\n  }\n\n  if (shapeType === SHAPE_MULTIPOINT) {\n    const points = pointsOf(geometry);\n    const box = emptyBox();\n    for (const [x, y] of points) extend(box, Number(x), Number(y));\n    const drawn = safeBox(box);\n    extend(fileBox, drawn.minX, drawn.minY);\n    extend(fileBox, drawn.maxX, drawn.maxY);\n    const content = new Uint8Array(4 + 32 + 4 + points.length * 16);\n    const view = new DataView(content.buffer);\n    view.setInt32(0, SHAPE_MULTIPOINT, true);\n    view.setFloat64(4, drawn.minX, true);\n    view.setFloat64(12, drawn.minY, true);\n    view.setFloat64(20, drawn.maxX, true);\n    view.setFloat64(28, drawn.maxY, true);\n    view.setInt32(36, points.length, true);\n    let offset = 40;\n    for (const [x, y] of points) {\n      view.setFloat64(offset, Number(x), true);\n      view.setFloat64(offset + 8, Number(y), true);\n      offset += 16;\n    }\n    return content;\n  }\n\n  // PolyLine (3) or Polygon (5): identical record layout.\n  const parts = geometryParts(geometry, family);\n  const numParts = parts.length;\n  const flatPoints: Position[] = parts.flat();\n  const box = emptyBox();\n  for (const [x, y] of flatPoints) extend(box, Number(x), Number(y));\n  const drawn = safeBox(box);\n  extend(fileBox, drawn.minX, drawn.minY);\n  extend(fileBox, drawn.maxX, drawn.maxY);\n\n  const content = new Uint8Array(4 + 32 + 4 + 4 + numParts * 4 + flatPoints.length * 16);\n  const view = new DataView(content.buffer);\n  view.setInt32(0, shapeType, true);\n  view.setFloat64(4, drawn.minX, true);\n  view.setFloat64(12, drawn.minY, true);\n  view.setFloat64(20, drawn.maxX, true);\n  view.setFloat64(28, drawn.maxY, true);\n  view.setInt32(36, numParts, true);\n  view.setInt32(40, flatPoints.length, true);\n  let offset = 44;\n  let runningIndex = 0;\n  for (const part of parts) {\n    view.setInt32(offset, runningIndex, true);\n    offset += 4;\n    runningIndex += part.length;\n  }\n  for (const [x, y] of flatPoints) {\n    view.setFloat64(offset, Number(x), true);\n    view.setFloat64(offset + 8, Number(y), true);\n    offset += 16;\n  }\n  return content;\n}\n\n/** Write the 100-byte .shp/.shx header. `fileWords` is the file length in\n * 16-bit words; `box` the dataset bounding box. */\nfunction writeMainHeader(target: Uint8Array, shapeType: number, fileWords: number, box: Box): void {\n  const view = new DataView(target.buffer, target.byteOffset, 100);\n  view.setInt32(0, 9994, false); // file code (big-endian)\n  view.setInt32(24, fileWords, false); // file length in words (big-endian)\n  view.setInt32(28, 1000, true); // version (little-endian)\n  view.setInt32(32, shapeType, true);\n  const drawn = safeBox(box);\n  view.setFloat64(36, drawn.minX, true);\n  view.setFloat64(44, drawn.minY, true);\n  view.setFloat64(52, drawn.maxX, true);\n  view.setFloat64(60, drawn.maxY, true);\n  // Z and M ranges remain zero (2D output).\n}\n\n// ----- DBF (attribute table) -----\n\ntype DbfFieldType = 'C' | 'N' | 'L';\n\ninterface DbfField {\n  key: string;\n  name: string;\n  type: DbfFieldType;\n  length: number;\n  decimals: number;\n}\n\nconst TEXT_ENCODER = new TextEncoder();\n// This writer emits a dBASE III table (version 0x03), whose numeric fields\n// support at most 19 total bytes and 15 digits after the decimal point.\nconst DBF_NUMERIC_MAX_WIDTH = 19;\nconst DBF_NUMERIC_MAX_DECIMALS = 15;\n\n/** Encode `text` to UTF-8, truncated to at most `maxBytes` without splitting a\n * multi-byte code point (so non-ASCII attribute values stay valid). */\nfunction encodeUtf8Truncated(text: string, maxBytes: number): Uint8Array {\n  const full = TEXT_ENCODER.encode(text);\n  if (full.length <= maxBytes) return full;\n  let length = 0;\n  for (const char of text) {\n    const size = TEXT_ENCODER.encode(char).length;\n    if (length + size > maxBytes) break;\n    length += size;\n  }\n  return full.subarray(0, length);\n}\n\nfunction dbfFieldName(key: string, taken: Set<string>): string {\n  // DBF field names are at most 10 characters; truncate and de-duplicate.\n  const base = key.replace(/[^0-9A-Za-z_]/g, '_').slice(0, 10) || 'field';\n  if (!taken.has(base.toUpperCase())) {\n    taken.add(base.toUpperCase());\n    return base;\n  }\n  for (let i = 1; i < 1000; i += 1) {\n    const suffix = String(i);\n    const candidate = `${base.slice(0, 10 - suffix.length)}${suffix}`;\n    if (!taken.has(candidate.toUpperCase())) {\n      taken.add(candidate.toUpperCase());\n      return candidate;\n    }\n  }\n  // Falling through means >999 fields share one 10-char prefix; returning a\n  // name already in `taken` would write a duplicate DBF column. Fail loudly\n  // instead of silently corrupting the file.\n  throw new Error(`Cannot generate a unique DBF field name for \"${key}\" (>999 collisions).`);\n}\n\n/** DBF numeric fields only allow digits, a sign, and a decimal point. */\nfunction decimalText(value: number): string {\n  const text = String(value);\n  const match = /^(-?)(\\d+)(?:\\.(\\d+))?e([+-]?\\d+)$/i.exec(text);\n  if (!match) return text;\n\n  const [, sign, integer, fraction = '', rawExponent] = match;\n  const digits = `${integer}${fraction}`;\n  const decimalIndex = integer.length + Number(rawExponent);\n  if (decimalIndex <= 0) {\n    return `${sign}0.${'0'.repeat(-decimalIndex)}${digits}`;\n  }\n  if (decimalIndex >= digits.length) {\n    return `${sign}${digits}${'0'.repeat(decimalIndex - digits.length)}`;\n  }\n  return `${sign}${digits.slice(0, decimalIndex)}.${digits.slice(decimalIndex)}`;\n}\n\nfunction decimalPlaces(text: string): number {\n  const dot = text.indexOf('.');\n  if (dot < 0) return 0;\n  return text.length - dot - 1;\n}\n\nfunction formatDbfNumber(value: number, decimals: number): string {\n  // Number#toFixed provides the rounding policy and fixed notation below 1e21.\n  // Larger values cannot fit a dBASE III numeric field even at zero decimals,\n  // but expanding them here lets field planning report their actual width.\n  const text =\n    Math.abs(value) < 1e21\n      ? value.toFixed(decimals)\n      : `${decimalText(value)}${decimals > 0 ? `.${'0'.repeat(decimals)}` : ''}`;\n  // Do not spend a sign byte on a value that rounded to zero.\n  return /^-0(?:\\.0+)?$/.test(text) ? text.slice(1) : text;\n}\n\nfunction planField(key: string, name: string, values: unknown[]): DbfField {\n  let sawNumber = false;\n  let sawNonNumber = false;\n  let sawBoolean = false;\n  let sawNonBoolean = false;\n  for (const value of values) {\n    if (value == null) continue;\n    if (typeof value === 'boolean') {\n      sawBoolean = true;\n    } else {\n      sawNonBoolean = true;\n    }\n    if (typeof value === 'number' && Number.isFinite(value)) {\n      sawNumber = true;\n    } else {\n      sawNonNumber = true;\n    }\n  }\n\n  if (sawBoolean && !sawNonBoolean) {\n    return {key, name, type: 'L', length: 1, decimals: 0};\n  }\n\n  if (sawNumber && !sawNonNumber) {\n    let requestedDecimals = 0;\n    for (const value of values) {\n      if (typeof value === 'number' && Number.isFinite(value)) {\n        requestedDecimals = Math.max(requestedDecimals, decimalPlaces(decimalText(value)));\n      }\n    }\n\n    // Use the highest common precision that fits every rounded value. Measuring\n    // the formatted values on each pass accounts for signs and rounding carry.\n    for (\n      let decimals = Math.min(requestedDecimals, DBF_NUMERIC_MAX_DECIMALS);\n      decimals >= 0;\n      decimals -= 1\n    ) {\n      let length = 1;\n      for (const value of values) {\n        if (typeof value !== 'number' || !Number.isFinite(value)) continue;\n        length = Math.max(length, formatDbfNumber(value, decimals).length);\n      }\n      if (length <= DBF_NUMERIC_MAX_WIDTH) {\n        return {key, name, type: 'N', length, decimals};\n      }\n      if (decimals === 0) {\n        throw new Error(\n          `DBF numeric field \"${key}\" requires ${length} bytes at zero decimal places; ` +\n            `dBASE III numeric fields support at most ${DBF_NUMERIC_MAX_WIDTH}.`\n        );\n      }\n    }\n  }\n\n  // Fall back to text for everything else (strings, mixed types, objects).\n  let length = 1;\n  for (const value of values) {\n    if (value == null) continue;\n    const text = typeof value === 'object' ? JSON.stringify(value) : String(value);\n    length = Math.max(length, TEXT_ENCODER.encode(text).length);\n  }\n  return {key, name, type: 'C', length: Math.min(length, 254), decimals: 0};\n}\n\nfunction encodeDbfValue(value: unknown, field: DbfField): Uint8Array {\n  const cell = new Uint8Array(field.length).fill(0x20); // space-padded\n  if (value == null) return cell;\n\n  if (field.type === 'L') {\n    cell[0] = value ? 0x54 : 0x46; // 'T' / 'F'\n    return cell;\n  }\n\n  if (field.type === 'N') {\n    if (typeof value !== 'number' || !Number.isFinite(value)) return cell;\n    const text = formatDbfNumber(value, field.decimals);\n    if (text.length > field.length) {\n      throw new Error(`DBF numeric value for \"${field.key}\" exceeds its planned field width.`);\n    }\n    // Numbers are right-justified in DBF.\n    const bytes = TEXT_ENCODER.encode(text);\n    cell.set(bytes, field.length - bytes.length);\n    return cell;\n  }\n\n  // Text: left-justified, truncated to the field byte length on a code-point\n  // boundary so multi-byte characters are never cut mid-sequence.\n  const text = typeof value === 'object' ? JSON.stringify(value) : String(value);\n  cell.set(encodeUtf8Truncated(text, field.length), 0);\n  return cell;\n}\n\nfunction buildDbf(features: Feature[], fields: DbfField[]): Uint8Array {\n  const recordLength = 1 + fields.reduce((total, field) => total + field.length, 0);\n  const headerLength = 32 + fields.length * 32 + 1;\n  // Both are serialized as uint16; too many or too-wide attributes would\n  // overflow and silently corrupt the .dbf, so fail fast instead.\n  if (recordLength > 0xffff || headerLength > 0xffff) {\n    throw new Error('Too many or too-wide attributes for the DBF format limits.');\n  }\n  const total = headerLength + features.length * recordLength + 1; // +1 EOF\n  const buffer = new Uint8Array(total);\n  const view = new DataView(buffer.buffer);\n\n  buffer[0] = 0x03; // dBASE III without memo\n  const now = new Date();\n  buffer[1] = now.getFullYear() - 1900;\n  buffer[2] = now.getMonth() + 1;\n  buffer[3] = now.getDate();\n  view.setUint32(4, features.length, true);\n  view.setUint16(8, headerLength, true);\n  view.setUint16(10, recordLength, true);\n\n  let offset = 32;\n  for (const field of fields) {\n    const nameBytes = TEXT_ENCODER.encode(field.name).subarray(0, 11);\n    buffer.set(nameBytes, offset); // remaining name bytes stay 0 (null-padded)\n    buffer[offset + 11] = field.type.charCodeAt(0);\n    buffer[offset + 16] = field.length;\n    buffer[offset + 17] = field.decimals;\n    offset += 32;\n  }\n  buffer[offset] = 0x0d; // field descriptor terminator\n  offset += 1;\n\n  for (const feature of features) {\n    buffer[offset] = 0x20; // record not deleted\n    offset += 1;\n    for (const field of fields) {\n      const cell = encodeDbfValue(feature.properties?.[field.key], field);\n      buffer.set(cell, offset);\n      offset += field.length;\n    }\n  }\n  buffer[offset] = 0x1a; // end-of-file marker\n  return buffer;\n}\n\n/**\n * Assemble the parts of an ESRI Shapefile from a FeatureCollection.\n *\n * Args:\n *   geojson: Features to write (assumed WGS84).\n *\n * Returns:\n *   The .shp/.shx/.dbf/.prj/.cpg byte buffers (the caller names and zips them).\n */\nexport function writeShapefile(geojson: FeatureCollection): ShapefileParts {\n  const features = geojson.features ?? [];\n  if (features.length === 0) {\n    throw new Error('The layer has no features to export.');\n  }\n  const {type: shapeType, family} = fileShapeType(features);\n\n  const fileBox = emptyBox();\n  const contents = features.map(feature =>\n    encodeShape(feature.geometry, shapeType, family, fileBox)\n  );\n\n  // .shp: 100-byte header + per-record (8-byte header + content).\n  const shpSize = 100 + contents.reduce((total, content) => total + 8 + content.length, 0);\n  const shp = new Uint8Array(shpSize);\n  const shpView = new DataView(shp.buffer);\n  const shxSize = 100 + contents.length * 8;\n  const shx = new Uint8Array(shxSize);\n  const shxView = new DataView(shx.buffer);\n\n  writeMainHeader(shp, shapeType, shpSize / 2, fileBox);\n  writeMainHeader(shx, shapeType, shxSize / 2, fileBox);\n\n  let shpOffset = 100;\n  let shxOffset = 100;\n  contents.forEach((content, index) => {\n    const contentWords = content.length / 2;\n    const recordOffsetWords = shpOffset / 2;\n    // Record header (big-endian): 1-based record number + content length.\n    shpView.setInt32(shpOffset, index + 1, false);\n    shpView.setInt32(shpOffset + 4, contentWords, false);\n    shp.set(content, shpOffset + 8);\n    shpOffset += 8 + content.length;\n    // .shx entry (big-endian): record offset + content length, both in words.\n    shxView.setInt32(shxOffset, recordOffsetWords, false);\n    shxView.setInt32(shxOffset + 4, contentWords, false);\n    shxOffset += 8;\n  });\n\n  // DBF fields from the union of property keys across all features.\n  const keys: string[] = [];\n  const seen = new Set<string>();\n  for (const feature of features) {\n    for (const key of Object.keys(feature.properties ?? {})) {\n      if (!seen.has(key)) {\n        seen.add(key);\n        keys.push(key);\n      }\n    }\n  }\n  const takenNames = new Set<string>();\n  const fields = keys.map(key =>\n    planField(\n      key,\n      dbfFieldName(key, takenNames),\n      features.map(feature => feature.properties?.[key])\n    )\n  );\n  const dbf = buildDbf(features, fields);\n\n  return {\n    shp,\n    shx,\n    dbf,\n    prj: TEXT_ENCODER.encode(WGS84_PRJ),\n    cpg: TEXT_ENCODER.encode('UTF-8')\n  };\n}\n"],"mappings":"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","ignoreList":[]}