@kepler.gl/processors 3.3.0-alpha.2 → 3.3.0-alpha.21
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/cjs/data-processor.js +674 -0
- package/dist/cjs/data-processor.js.map +1 -0
- package/dist/cjs/export/dataset-to-geojson.js +138 -0
- package/dist/cjs/export/dataset-to-geojson.js.map +1 -0
- package/dist/cjs/export/geopackage-writer.js +385 -0
- package/dist/cjs/export/geopackage-writer.js.map +1 -0
- package/dist/cjs/export/geoparquet-writer.js +351 -0
- package/dist/cjs/export/geoparquet-writer.js.map +1 -0
- package/dist/cjs/export/kml-writer.js +347 -0
- package/dist/cjs/export/kml-writer.js.map +1 -0
- package/dist/cjs/export/shapefile-writer.js +708 -0
- package/dist/cjs/export/shapefile-writer.js.map +1 -0
- package/dist/cjs/export/sql-js.js +95 -0
- package/dist/cjs/export/sql-js.js.map +1 -0
- package/dist/cjs/export/vector-export.js +187 -0
- package/dist/cjs/export/vector-export.js.map +1 -0
- package/dist/cjs/file-handler.js +997 -0
- package/dist/cjs/file-handler.js.map +1 -0
- package/dist/cjs/index.js +114 -0
- package/dist/cjs/index.js.map +1 -0
- package/dist/cjs/kepler-csv-loader.js +163 -0
- package/dist/cjs/kepler-csv-loader.js.map +1 -0
- package/dist/cjs/loader-registry.js +542 -0
- package/dist/cjs/loader-registry.js.map +1 -0
- package/dist/cjs/remote-file.js +675 -0
- package/dist/cjs/remote-file.js.map +1 -0
- package/dist/cjs/shapefile-files.js +281 -0
- package/dist/cjs/shapefile-files.js.map +1 -0
- package/dist/cjs/types.js +6 -0
- package/dist/cjs/types.js.map +1 -0
- package/dist/data-processor.d.ts +30 -16
- package/dist/esm/data-processor.js +655 -0
- package/dist/esm/data-processor.js.map +1 -0
- package/dist/esm/export/dataset-to-geojson.js +132 -0
- package/dist/esm/export/dataset-to-geojson.js.map +1 -0
- package/dist/esm/export/geopackage-writer.js +381 -0
- package/dist/esm/export/geopackage-writer.js.map +1 -0
- package/dist/esm/export/geoparquet-writer.js +336 -0
- package/dist/esm/export/geoparquet-writer.js.map +1 -0
- package/dist/esm/export/kml-writer.js +341 -0
- package/dist/esm/export/kml-writer.js.map +1 -0
- package/dist/esm/export/shapefile-writer.js +701 -0
- package/dist/esm/export/shapefile-writer.js.map +1 -0
- package/dist/esm/export/sql-js.js +80 -0
- package/dist/esm/export/sql-js.js.map +1 -0
- package/dist/esm/export/vector-export.js +176 -0
- package/dist/esm/export/vector-export.js.map +1 -0
- package/dist/esm/file-handler.js +972 -0
- package/dist/esm/file-handler.js.map +1 -0
- package/dist/esm/index.js +12 -0
- package/dist/esm/index.js.map +1 -0
- package/dist/esm/kepler-csv-loader.js +152 -0
- package/dist/esm/kepler-csv-loader.js.map +1 -0
- package/dist/esm/loader-registry.js +510 -0
- package/dist/esm/loader-registry.js.map +1 -0
- package/dist/esm/remote-file.js +664 -0
- package/dist/esm/remote-file.js.map +1 -0
- package/dist/esm/shapefile-files.js +264 -0
- package/dist/esm/shapefile-files.js.map +1 -0
- package/dist/esm/types.js +3 -0
- package/dist/esm/types.js.map +1 -0
- package/dist/export/dataset-to-geojson.d.ts +12 -0
- package/dist/export/geopackage-writer.d.ts +28 -0
- package/dist/export/geoparquet-writer.d.ts +7 -0
- package/dist/export/kml-writer.d.ts +13 -0
- package/dist/export/shapefile-writer.d.ts +28 -0
- package/dist/export/sql-js.d.ts +8 -0
- package/dist/export/vector-export.d.ts +22 -0
- package/dist/file-handler.d.ts +55 -8
- package/dist/index.d.ts +6 -0
- package/dist/kepler-csv-loader.d.ts +12 -0
- package/dist/loader-registry.d.ts +29 -0
- package/dist/remote-file.d.ts +79 -0
- package/dist/shapefile-files.d.ts +39 -0
- package/dist/types.d.ts +13 -0
- package/package.json +44 -26
- package/dist/data-processor.js +0 -637
- package/dist/file-handler.js +0 -409
- package/dist/index.js +0 -39
- package/dist/types.js +0 -6
|
@@ -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=shapefile-writer.js.map
|