@kepler.gl/processors 3.3.0-alpha.2 → 3.3.0-alpha.20

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 (50) hide show
  1. package/dist/cjs/data-processor.js +719 -0
  2. package/dist/cjs/export/dataset-to-geojson.js +138 -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/vector-export.js +187 -0
  9. package/dist/cjs/file-handler.js +997 -0
  10. package/dist/cjs/index.js +114 -0
  11. package/dist/cjs/kepler-csv-loader.js +163 -0
  12. package/dist/cjs/loader-registry.js +542 -0
  13. package/dist/cjs/remote-file.js +675 -0
  14. package/dist/cjs/shapefile-files.js +281 -0
  15. package/dist/cjs/types.js +6 -0
  16. package/dist/data-processor.d.ts +30 -16
  17. package/dist/esm/data-processor.js +700 -0
  18. package/dist/esm/export/dataset-to-geojson.js +132 -0
  19. package/dist/esm/export/geopackage-writer.js +381 -0
  20. package/dist/esm/export/geoparquet-writer.js +336 -0
  21. package/dist/esm/export/kml-writer.js +341 -0
  22. package/dist/esm/export/shapefile-writer.js +701 -0
  23. package/dist/esm/export/sql-js.js +80 -0
  24. package/dist/esm/export/vector-export.js +176 -0
  25. package/dist/esm/file-handler.js +972 -0
  26. package/dist/esm/index.js +12 -0
  27. package/dist/esm/kepler-csv-loader.js +152 -0
  28. package/dist/esm/loader-registry.js +510 -0
  29. package/dist/esm/remote-file.js +664 -0
  30. package/dist/esm/shapefile-files.js +264 -0
  31. package/dist/esm/types.js +3 -0
  32. package/dist/export/dataset-to-geojson.d.ts +12 -0
  33. package/dist/export/geopackage-writer.d.ts +28 -0
  34. package/dist/export/geoparquet-writer.d.ts +7 -0
  35. package/dist/export/kml-writer.d.ts +13 -0
  36. package/dist/export/shapefile-writer.d.ts +28 -0
  37. package/dist/export/sql-js.d.ts +8 -0
  38. package/dist/export/vector-export.d.ts +22 -0
  39. package/dist/file-handler.d.ts +55 -8
  40. package/dist/index.d.ts +6 -0
  41. package/dist/kepler-csv-loader.d.ts +12 -0
  42. package/dist/loader-registry.d.ts +29 -0
  43. package/dist/remote-file.d.ts +79 -0
  44. package/dist/shapefile-files.d.ts +39 -0
  45. package/dist/types.d.ts +13 -0
  46. package/package.json +35 -17
  47. package/dist/data-processor.js +0 -637
  48. package/dist/file-handler.js +0 -409
  49. package/dist/index.js +0 -39
  50. package/dist/types.js +0 -6
@@ -0,0 +1,664 @@
1
+ import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
2
+ import _typeof from "@babel/runtime/helpers/esm/typeof";
3
+ import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
4
+ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
5
+ import _regeneratorRuntime from "@babel/runtime/regenerator";
6
+ 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; }
7
+ 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; }
8
+ function _asyncIterator(r) { var n, t, o, e = 2; for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) { if (t && null != (n = r[t])) return n.call(r); if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r)); t = "@@asyncIterator", o = "@@iterator"; } throw new TypeError("Object is not async iterable"); }
9
+ function AsyncFromSyncIterator(r) { function AsyncFromSyncIteratorContinuation(r) { if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object.")); var n = r.done; return Promise.resolve(r.value).then(function (r) { return { value: r, done: n }; }); } return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) { this.s = r, this.n = r.next; }, AsyncFromSyncIterator.prototype = { s: null, n: null, next: function next() { return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments)); }, "return": function _return(r) { var n = this.s["return"]; return void 0 === n ? Promise.resolve({ value: r, done: !0 }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); }, "throw": function _throw(r) { var n = this.s["return"]; return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments)); } }, new AsyncFromSyncIterator(r); }
10
+ // SPDX-License-Identifier: MIT
11
+ // Copyright contributors to the kepler.gl project
12
+
13
+ import { parseUri } from '@kepler.gl/common-utils';
14
+ import { DATASET_FORMATS, DatasetType, MIME_TO_REMOTE_FILE_EXTENSION, REMOTE_FILE_EXTENSIONS, REMOTE_FILE_MIME_TYPES } from '@kepler.gl/constants';
15
+ import { generateHashIdFromString } from '@kepler.gl/utils';
16
+ import { getPersistedRemoteFormat, processFileData, readFileInBatches } from './file-handler';
17
+ import { KeplerCSVLoader } from './kepler-csv-loader';
18
+ function getPathFileName(url) {
19
+ try {
20
+ var parsed = new URL(url);
21
+ var segments = parsed.pathname.split('/').filter(Boolean);
22
+ var last = segments.length ? decodeURIComponent(segments[segments.length - 1]) : '';
23
+ return last.split('?')[0];
24
+ } catch (_unused) {
25
+ var _parseUri = parseUri(url),
26
+ file = _parseUri.file;
27
+ return decodeURIComponent(String(file || '')).split('?')[0];
28
+ }
29
+ }
30
+ export function getExtensionFromUrl(url) {
31
+ var file = getPathFileName(url);
32
+ var match = file.match(/\.([a-z0-9]+)$/i);
33
+ return match ? match[1].toLowerCase() : '';
34
+ }
35
+ export function getMimeTypeForFormat(format) {
36
+ if (!format || format === 'auto') {
37
+ return undefined;
38
+ }
39
+ return REMOTE_FILE_MIME_TYPES[format];
40
+ }
41
+ export function isRemoteDatasetUrl(url) {
42
+ try {
43
+ var _URL = new URL(url),
44
+ protocol = _URL.protocol;
45
+ return protocol === 'http:' || protocol === 'https:';
46
+ } catch (_unused2) {
47
+ return false;
48
+ }
49
+ }
50
+
51
+ /**
52
+ * Build a filename loaders.gl can use to pick a parser.
53
+ * Prefers an explicit format, then the URL path extension, then Content-Type.
54
+ */
55
+ export function getFileNameForRemoteUrl(url, format, mimeType) {
56
+ var base = getPathFileName(url) || 'dataset';
57
+ var formatExt = format && format !== 'auto' ? REMOTE_FILE_EXTENSIONS[format] : undefined;
58
+ var urlExt = getExtensionFromUrl(url);
59
+ var mimeExt = mimeType ? MIME_TO_REMOTE_FILE_EXTENSION[mimeType.split(';')[0].trim().toLowerCase()] : undefined;
60
+ var ext = formatExt || urlExt || mimeExt;
61
+ if (!ext) {
62
+ return base;
63
+ }
64
+ if (/\.[a-z0-9]+$/i.test(base)) {
65
+ if (formatExt && !base.toLowerCase().endsWith(".".concat(formatExt))) {
66
+ return "".concat(base.replace(/\.[^.]+$/, ''), ".").concat(formatExt);
67
+ }
68
+ return base;
69
+ }
70
+ return "".concat(base, ".").concat(ext);
71
+ }
72
+
73
+ /**
74
+ * Fetch a remote dataset URL. Uses conditional headers for same-origin requests
75
+ * (or outside a browser) so unchanged files can skip a re-parse.
76
+ */
77
+ export function fetchRemoteFile(_x) {
78
+ return _fetchRemoteFile.apply(this, arguments);
79
+ }
80
+
81
+ /**
82
+ * A remote URL to hold until Add Data. Rows stay empty so adding it runs the
83
+ * externally hosted download instead of parsing a file in the modal.
84
+ */
85
+ function _fetchRemoteFile() {
86
+ _fetchRemoteFile = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
87
+ var options,
88
+ format,
89
+ onProgress,
90
+ etag,
91
+ lastModified,
92
+ bypassCache,
93
+ headers,
94
+ isCrossOrigin,
95
+ response,
96
+ _response$body,
97
+ _response$body$cancel,
98
+ status,
99
+ blob,
100
+ headerType,
101
+ mimeType,
102
+ fileName,
103
+ file,
104
+ responseEtag,
105
+ responseLastModified,
106
+ _args = arguments;
107
+ return _regeneratorRuntime.wrap(function _callee$(_context) {
108
+ while (1) switch (_context.prev = _context.next) {
109
+ case 0:
110
+ options = _args.length > 1 && _args[1] !== undefined ? _args[1] : {};
111
+ format = options.format, onProgress = options.onProgress, etag = options.etag, lastModified = options.lastModified, bypassCache = options.bypassCache;
112
+ if (isRemoteDatasetUrl(url)) {
113
+ _context.next = 4;
114
+ break;
115
+ }
116
+ throw new Error('Remote dataset URL must use http or https');
117
+ case 4:
118
+ headers = {}; // Conditional headers trigger CORS preflights, which simple file servers may
119
+ // not support even when they allow cross-origin GET requests.
120
+ isCrossOrigin = typeof location !== 'undefined' && new URL(url).origin !== location.origin;
121
+ if (etag && !isCrossOrigin) {
122
+ headers['If-None-Match'] = etag;
123
+ }
124
+ if (lastModified && !isCrossOrigin) {
125
+ headers['If-Modified-Since'] = lastModified;
126
+ }
127
+ _context.next = 10;
128
+ return fetch(url, _objectSpread(_objectSpread({}, bypassCache ? {
129
+ cache: 'no-store'
130
+ } : {}), Object.keys(headers).length ? {
131
+ headers: headers
132
+ } : {}));
133
+ case 10:
134
+ response = _context.sent;
135
+ if (!(response.status === 304)) {
136
+ _context.next = 13;
137
+ break;
138
+ }
139
+ return _context.abrupt("return", {
140
+ file: null,
141
+ notModified: true,
142
+ etag: response.headers.get('etag') || etag || undefined,
143
+ lastModified: response.headers.get('last-modified') || lastModified || undefined
144
+ });
145
+ case 13:
146
+ if (response.ok) {
147
+ _context.next = 17;
148
+ break;
149
+ }
150
+ // Don't put the response body in the error: 404 HTML pages would dump into the UI.
151
+ (_response$body = response.body) === null || _response$body === void 0 || (_response$body$cancel = _response$body.cancel) === null || _response$body$cancel === void 0 || _response$body$cancel.call(_response$body)["catch"](function () {
152
+ return undefined;
153
+ });
154
+ status = response.statusText ? "".concat(response.status, " ").concat(response.statusText) : String(response.status);
155
+ throw new Error("Failed to fetch ".concat(url, " (").concat(status, ")"));
156
+ case 17:
157
+ _context.next = 19;
158
+ return readResponseBlob(response, onProgress);
159
+ case 19:
160
+ blob = _context.sent;
161
+ headerType = response.headers.get('content-type') || blob.type || '';
162
+ mimeType = getMimeTypeForFormat(format) || headerType.split(';')[0].trim();
163
+ fileName = getFileNameForRemoteUrl(url, format, mimeType);
164
+ file = new File([blob], fileName, mimeType ? {
165
+ type: mimeType
166
+ } : undefined);
167
+ file.keplerSourceUrl = url;
168
+ if (format && format !== 'auto') {
169
+ file.keplerFormat = format;
170
+ }
171
+ responseEtag = response.headers.get('etag') || undefined;
172
+ responseLastModified = response.headers.get('last-modified') || undefined;
173
+ if (responseEtag) {
174
+ file.keplerEtag = responseEtag;
175
+ }
176
+ if (responseLastModified) {
177
+ file.keplerLastModified = responseLastModified;
178
+ }
179
+ return _context.abrupt("return", {
180
+ file: file,
181
+ notModified: false,
182
+ etag: responseEtag,
183
+ lastModified: responseLastModified,
184
+ size: file.size
185
+ });
186
+ case 31:
187
+ case "end":
188
+ return _context.stop();
189
+ }
190
+ }, _callee);
191
+ }));
192
+ return _fetchRemoteFile.apply(this, arguments);
193
+ }
194
+ export function remoteDatasetFromUrl(url, format) {
195
+ if (!isRemoteDatasetUrl(url)) {
196
+ throw new Error('Remote dataset URL must use http or https');
197
+ }
198
+ var label = getFileNameForRemoteUrl(url, format);
199
+ var sourceFormat = getPersistedRemoteFormat(format && format !== 'auto' ? format : undefined, label);
200
+ return {
201
+ data: {
202
+ fields: [],
203
+ rows: []
204
+ },
205
+ info: {
206
+ id: generateHashIdFromString(url),
207
+ label: label,
208
+ format: DATASET_FORMATS.row,
209
+ type: DatasetType.EXTERNALLY_HOSTED
210
+ },
211
+ metadata: _objectSpread({
212
+ source: url
213
+ }, sourceFormat ? {
214
+ sourceFormat: sourceFormat
215
+ } : {})
216
+ };
217
+ }
218
+
219
+ /**
220
+ * Fetch a remote dataset URL and wrap it as a File the existing loadFiles pipeline can parse.
221
+ * Sets File.type from an explicit format or the response Content-Type so extensionless
222
+ * URLs (SAS keys) still select the right loader.
223
+ */
224
+ export function fetchRemoteFileAsKeplerFile(_x2, _x3, _x4) {
225
+ return _fetchRemoteFileAsKeplerFile.apply(this, arguments);
226
+ }
227
+
228
+ /** Two frames are enough for the processing indicator to paint. */
229
+ function _fetchRemoteFileAsKeplerFile() {
230
+ _fetchRemoteFileAsKeplerFile = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee2(url, format, onProgress) {
231
+ var result;
232
+ return _regeneratorRuntime.wrap(function _callee2$(_context2) {
233
+ while (1) switch (_context2.prev = _context2.next) {
234
+ case 0:
235
+ _context2.next = 2;
236
+ return fetchRemoteFile(url, {
237
+ format: format,
238
+ onProgress: onProgress
239
+ });
240
+ case 2:
241
+ result = _context2.sent;
242
+ if (result.file) {
243
+ _context2.next = 5;
244
+ break;
245
+ }
246
+ throw new Error("Failed to fetch ".concat(url, " (304 Not Modified)"));
247
+ case 5:
248
+ return _context2.abrupt("return", result.file);
249
+ case 6:
250
+ case "end":
251
+ return _context2.stop();
252
+ }
253
+ }, _callee2);
254
+ }));
255
+ return _fetchRemoteFileAsKeplerFile.apply(this, arguments);
256
+ }
257
+ var PAINT_WAIT_MS = 100;
258
+ function waitForNextPaint() {
259
+ // Hidden tabs suspend requestAnimationFrame. A download that finishes in the
260
+ // background would otherwise wait until the user comes back, and there is
261
+ // nothing to paint there.
262
+ if (typeof requestAnimationFrame !== 'function' || typeof document !== 'undefined' && document.hidden) {
263
+ return Promise.resolve();
264
+ }
265
+ return new Promise(function (resolve) {
266
+ var settled = false;
267
+ var frames = [];
268
+ var finish = function finish() {
269
+ if (settled) {
270
+ return;
271
+ }
272
+ settled = true;
273
+ clearTimeout(timer);
274
+ if (typeof cancelAnimationFrame === 'function') {
275
+ frames.forEach(function (id) {
276
+ return cancelAnimationFrame(id);
277
+ });
278
+ }
279
+ resolve();
280
+ };
281
+ // The tab can be hidden after this wait starts. Don't sit on frames that will never run.
282
+ var timer = setTimeout(finish, PAINT_WAIT_MS);
283
+ frames.push(requestAnimationFrame(function () {
284
+ if (!settled) {
285
+ frames.push(requestAnimationFrame(finish));
286
+ }
287
+ }));
288
+ });
289
+ }
290
+ function readResponseBlob(_x5, _x6) {
291
+ return _readResponseBlob.apply(this, arguments);
292
+ }
293
+ function _readResponseBlob() {
294
+ _readResponseBlob = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee3(response, onProgress) {
295
+ var contentLength, total, PROGRESS_INTERVAL_MS, lastEmitAt, lastEmittedPercent, emit, blob, reader, chunks, loaded, _yield$reader$read, done, value;
296
+ return _regeneratorRuntime.wrap(function _callee3$(_context3) {
297
+ while (1) switch (_context3.prev = _context3.next) {
298
+ case 0:
299
+ contentLength = Number(response.headers.get('content-length'));
300
+ total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : undefined;
301
+ PROGRESS_INTERVAL_MS = 80;
302
+ lastEmitAt = 0;
303
+ lastEmittedPercent = -1;
304
+ emit = function emit(loaded) {
305
+ var complete = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
306
+ var percent = complete ? 1 : total ? Math.min(1, loaded / total) : 0;
307
+ var rounded = Math.round(percent * 100);
308
+ var now = typeof performance !== 'undefined' ? performance.now() : Date.now();
309
+ if (!complete && loaded !== 0 && rounded === lastEmittedPercent && now - lastEmitAt < PROGRESS_INTERVAL_MS) {
310
+ return;
311
+ }
312
+ lastEmitAt = now;
313
+ lastEmittedPercent = rounded;
314
+ onProgress === null || onProgress === void 0 || onProgress({
315
+ loaded: loaded,
316
+ total: total,
317
+ percent: percent
318
+ });
319
+ };
320
+ if (response.body) {
321
+ _context3.next = 12;
322
+ break;
323
+ }
324
+ _context3.next = 9;
325
+ return response.blob();
326
+ case 9:
327
+ blob = _context3.sent;
328
+ emit(blob.size, true);
329
+ return _context3.abrupt("return", blob);
330
+ case 12:
331
+ reader = response.body.getReader();
332
+ chunks = [];
333
+ loaded = 0;
334
+ emit(0);
335
+ case 16:
336
+ if (!true) {
337
+ _context3.next = 29;
338
+ break;
339
+ }
340
+ _context3.next = 19;
341
+ return reader.read();
342
+ case 19:
343
+ _yield$reader$read = _context3.sent;
344
+ done = _yield$reader$read.done;
345
+ value = _yield$reader$read.value;
346
+ if (!done) {
347
+ _context3.next = 24;
348
+ break;
349
+ }
350
+ return _context3.abrupt("break", 29);
351
+ case 24:
352
+ chunks.push(value);
353
+ loaded += value.byteLength;
354
+ emit(loaded);
355
+ _context3.next = 16;
356
+ break;
357
+ case 29:
358
+ emit(loaded, true);
359
+ return _context3.abrupt("return", new Blob(chunks));
360
+ case 31:
361
+ case "end":
362
+ return _context3.stop();
363
+ }
364
+ }, _callee3);
365
+ }));
366
+ return _readResponseBlob.apply(this, arguments);
367
+ }
368
+ function isTabularProcessorResult(data) {
369
+ return Boolean(data && _typeof(data) === 'object' && Array.isArray(data === null || data === void 0 ? void 0 : data.fields) && Array.isArray(data === null || data === void 0 ? void 0 : data.rows));
370
+ }
371
+ function matchesCsvHeader(_x7, _x8) {
372
+ return _matchesCsvHeader.apply(this, arguments);
373
+ }
374
+ /**
375
+ * Fetch, parse, and process a remote file into Kepler dataset data.
376
+ * Used when reloading an `externally-hosted` dataset from a saved map config
377
+ * and when refreshing a live remote dataset.
378
+ */
379
+ function _matchesCsvHeader() {
380
+ _matchesCsvHeader = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee4(text, fields) {
381
+ var escape, blankLines, matchesRecord, rows, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, batch, header, names;
382
+ return _regeneratorRuntime.wrap(function _callee4$(_context4) {
383
+ while (1) switch (_context4.prev = _context4.next) {
384
+ case 0:
385
+ escape = function escape(value) {
386
+ return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
387
+ };
388
+ blankLines = '(?:[ \\t]*[\\r\\n])*'; // Keep exact quote validation: the CSV parser accepts some malformed records.
389
+ matchesRecord = function matchesRecord(header, strict) {
390
+ return [',', '\t', ';', '|'].some(function (delimiter) {
391
+ var record = header.map(function (name) {
392
+ var quoted = escape("\"".concat(name.replace(/"/g, '""'), "\""));
393
+ var needsQuotes = /["\r\n]/.test(name) || (strict ? /[,\t;|]/.test(name) : name.includes(delimiter));
394
+ return needsQuotes ? quoted : "(?:".concat(escape(name), "|").concat(quoted, ")");
395
+ }).join(escape(delimiter));
396
+ return new RegExp("^\\uFEFF?".concat(blankLines).concat(record).concat(blankLines, "$")).test(text);
397
+ });
398
+ }; // Quoted names remain unambiguous even when the loader guesses another delimiter.
399
+ if (!(fields.some(function (name) {
400
+ return name.trim();
401
+ }) && matchesRecord(fields, true))) {
402
+ _context4.next = 5;
403
+ break;
404
+ }
405
+ return _context4.abrupt("return", true);
406
+ case 5:
407
+ if (!(fields.length === 1)) {
408
+ _context4.next = 7;
409
+ break;
410
+ }
411
+ return _context4.abrupt("return", false);
412
+ case 7:
413
+ // Reuse the same streaming parser as import, exposing the header as a row.
414
+ rows = [];
415
+ _iteratorAbruptCompletion = false;
416
+ _didIteratorError = false;
417
+ _context4.prev = 10;
418
+ _iterator = _asyncIterator(KeplerCSVLoader.parseInBatches([new TextEncoder().encode(text)], {
419
+ csv: {
420
+ shape: 'array-row-table',
421
+ // @ts-expect-error loaders.gl accepts false but its type only declares 'auto'.
422
+ header: false
423
+ }
424
+ }));
425
+ case 12:
426
+ _context4.next = 14;
427
+ return _iterator.next();
428
+ case 14:
429
+ if (!(_iteratorAbruptCompletion = !(_step = _context4.sent).done)) {
430
+ _context4.next = 20;
431
+ break;
432
+ }
433
+ batch = _step.value;
434
+ rows.push.apply(rows, _toConsumableArray(batch.data));
435
+ case 17:
436
+ _iteratorAbruptCompletion = false;
437
+ _context4.next = 12;
438
+ break;
439
+ case 20:
440
+ _context4.next = 26;
441
+ break;
442
+ case 22:
443
+ _context4.prev = 22;
444
+ _context4.t0 = _context4["catch"](10);
445
+ _didIteratorError = true;
446
+ _iteratorError = _context4.t0;
447
+ case 26:
448
+ _context4.prev = 26;
449
+ _context4.prev = 27;
450
+ if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
451
+ _context4.next = 31;
452
+ break;
453
+ }
454
+ _context4.next = 31;
455
+ return _iterator["return"]();
456
+ case 31:
457
+ _context4.prev = 31;
458
+ if (!_didIteratorError) {
459
+ _context4.next = 34;
460
+ break;
461
+ }
462
+ throw _iteratorError;
463
+ case 34:
464
+ return _context4.finish(31);
465
+ case 35:
466
+ return _context4.finish(26);
467
+ case 36:
468
+ if (!(rows.length !== 1)) {
469
+ _context4.next = 38;
470
+ break;
471
+ }
472
+ return _context4.abrupt("return", false);
473
+ case 38:
474
+ header = rows[0]; // processRowObject uses Object.keys, which sorts integer-named columns.
475
+ names = Object.keys(Object.fromEntries(header.map(function (name) {
476
+ return [name, null];
477
+ })));
478
+ return _context4.abrupt("return", header.length === fields.length && names.length === fields.length && names.every(function (name, i) {
479
+ return name === fields[i];
480
+ }) && matchesRecord(header, false));
481
+ case 41:
482
+ case "end":
483
+ return _context4.stop();
484
+ }
485
+ }, _callee4, null, [[10, 22, 26, 36], [27,, 31, 35]]);
486
+ }));
487
+ return _matchesCsvHeader.apply(this, arguments);
488
+ }
489
+ export function loadExternallyHostedDataset(_x9) {
490
+ return _loadExternallyHostedDataset.apply(this, arguments);
491
+ }
492
+ function _loadExternallyHostedDataset() {
493
+ _loadExternallyHostedDataset = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime.mark(function _callee5(metadata) {
494
+ var _fetched$size, _metadata$csvHeader, _processed;
495
+ var source, format, etag, lastModified, size, bypassCache, onProgress, fetched, batches, content, _iteratorAbruptCompletion2, _didIteratorError2, _iteratorError2, _iterator2, _step2, batch, processed, data;
496
+ return _regeneratorRuntime.wrap(function _callee5$(_context5) {
497
+ while (1) switch (_context5.prev = _context5.next) {
498
+ case 0:
499
+ source = metadata.source, format = metadata.format, etag = metadata.etag, lastModified = metadata.lastModified, size = metadata.size, bypassCache = metadata.bypassCache, onProgress = metadata.onProgress;
500
+ _context5.next = 3;
501
+ return fetchRemoteFile(source, {
502
+ format: format,
503
+ etag: etag,
504
+ lastModified: lastModified,
505
+ bypassCache: bypassCache,
506
+ onProgress: onProgress
507
+ });
508
+ case 3:
509
+ fetched = _context5.sent;
510
+ if (!(fetched.notModified || !fetched.file)) {
511
+ _context5.next = 6;
512
+ break;
513
+ }
514
+ return _context5.abrupt("return", {
515
+ data: null,
516
+ notModified: true,
517
+ etag: fetched.etag,
518
+ lastModified: fetched.lastModified,
519
+ size: size
520
+ });
521
+ case 6:
522
+ onProgress === null || onProgress === void 0 || onProgress(_objectSpread(_objectSpread({
523
+ loaded: (_fetched$size = fetched.size) !== null && _fetched$size !== void 0 ? _fetched$size : fetched.file.size
524
+ }, typeof fetched.size === 'number' ? {
525
+ total: fetched.size
526
+ } : {}), {}, {
527
+ percent: 1,
528
+ phase: 'processing'
529
+ }));
530
+ // Let the loading indicator paint a processing state before parse blocks the tab.
531
+ _context5.next = 9;
532
+ return waitForNextPaint();
533
+ case 9:
534
+ _context5.next = 11;
535
+ return readFileInBatches({
536
+ file: fetched.file,
537
+ fileCache: [],
538
+ loaders: [],
539
+ loadOptions: {}
540
+ });
541
+ case 11:
542
+ batches = _context5.sent;
543
+ _iteratorAbruptCompletion2 = false;
544
+ _didIteratorError2 = false;
545
+ _context5.prev = 14;
546
+ _iterator2 = _asyncIterator(batches);
547
+ case 16:
548
+ _context5.next = 18;
549
+ return _iterator2.next();
550
+ case 18:
551
+ if (!(_iteratorAbruptCompletion2 = !(_step2 = _context5.sent).done)) {
552
+ _context5.next = 24;
553
+ break;
554
+ }
555
+ batch = _step2.value;
556
+ content = batch;
557
+ case 21:
558
+ _iteratorAbruptCompletion2 = false;
559
+ _context5.next = 16;
560
+ break;
561
+ case 24:
562
+ _context5.next = 30;
563
+ break;
564
+ case 26:
565
+ _context5.prev = 26;
566
+ _context5.t0 = _context5["catch"](14);
567
+ _didIteratorError2 = true;
568
+ _iteratorError2 = _context5.t0;
569
+ case 30:
570
+ _context5.prev = 30;
571
+ _context5.prev = 31;
572
+ if (!(_iteratorAbruptCompletion2 && _iterator2["return"] != null)) {
573
+ _context5.next = 35;
574
+ break;
575
+ }
576
+ _context5.next = 35;
577
+ return _iterator2["return"]();
578
+ case 35:
579
+ _context5.prev = 35;
580
+ if (!_didIteratorError2) {
581
+ _context5.next = 38;
582
+ break;
583
+ }
584
+ throw _iteratorError2;
585
+ case 38:
586
+ return _context5.finish(35);
587
+ case 39:
588
+ return _context5.finish(30);
589
+ case 40:
590
+ _context5.t1 = (_metadata$csvHeader = metadata.csvHeader) !== null && _metadata$csvHeader !== void 0 && _metadata$csvHeader.length && KeplerCSVLoader.extensions.some(function (extension) {
591
+ return fetched.file.name.toLowerCase().endsWith(".".concat(extension));
592
+ }) && (!content || Array.isArray(content.data) && !content.data.length);
593
+ if (!_context5.t1) {
594
+ _context5.next = 50;
595
+ break;
596
+ }
597
+ _context5.t2 = matchesCsvHeader;
598
+ _context5.next = 45;
599
+ return fetched.file.text();
600
+ case 45:
601
+ _context5.t3 = _context5.sent;
602
+ _context5.t4 = metadata.csvHeader;
603
+ _context5.next = 49;
604
+ return (0, _context5.t2)(_context5.t3, _context5.t4);
605
+ case 49:
606
+ _context5.t1 = _context5.sent;
607
+ case 50:
608
+ if (!_context5.t1) {
609
+ _context5.next = 52;
610
+ break;
611
+ }
612
+ return _context5.abrupt("return", {
613
+ data: {
614
+ fields: [],
615
+ rows: []
616
+ },
617
+ notModified: false,
618
+ etag: fetched.etag,
619
+ lastModified: fetched.lastModified,
620
+ size: fetched.size
621
+ });
622
+ case 52:
623
+ if (content) {
624
+ _context5.next = 54;
625
+ break;
626
+ }
627
+ throw new Error("No data loaded from ".concat(source));
628
+ case 54:
629
+ _context5.next = 56;
630
+ return processFileData({
631
+ content: _objectSpread(_objectSpread({}, content), {}, {
632
+ fileName: content.fileName,
633
+ sourceUrl: source
634
+ }),
635
+ fileCache: []
636
+ });
637
+ case 56:
638
+ processed = _context5.sent;
639
+ data = (_processed = processed[processed.length - 1]) === null || _processed === void 0 ? void 0 : _processed.data;
640
+ if (isTabularProcessorResult(data)) {
641
+ _context5.next = 60;
642
+ break;
643
+ }
644
+ throw new Error("Remote file is not a dataset: ".concat(source));
645
+ case 60:
646
+ return _context5.abrupt("return", {
647
+ data: data,
648
+ notModified: false,
649
+ etag: fetched.etag,
650
+ lastModified: fetched.lastModified,
651
+ size: fetched.size
652
+ });
653
+ case 61:
654
+ case "end":
655
+ return _context5.stop();
656
+ }
657
+ }, _callee5, null, [[14, 26, 30, 40], [31,, 35, 39]]);
658
+ }));
659
+ return _loadExternallyHostedDataset.apply(this, arguments);
660
+ }
661
+ export function isExternallyHostedFile(file) {
662
+ return Boolean(file.keplerSourceUrl);
663
+ }
664
+ //# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["parseUri","DATASET_FORMATS","DatasetType","MIME_TO_REMOTE_FILE_EXTENSION","REMOTE_FILE_EXTENSIONS","REMOTE_FILE_MIME_TYPES","generateHashIdFromString","getPersistedRemoteFormat","processFileData","readFileInBatches","KeplerCSVLoader","getPathFileName","url","parsed","URL","segments","pathname","split","filter","Boolean","last","length","decodeURIComponent","_unused","_parseUri","file","String","getExtensionFromUrl","match","toLowerCase","getMimeTypeForFormat","format","undefined","isRemoteDatasetUrl","_URL","protocol","_unused2","getFileNameForRemoteUrl","mimeType","base","formatExt","urlExt","mimeExt","trim","ext","test","endsWith","concat","replace","fetchRemoteFile","_x","_fetchRemoteFile","apply","arguments","_asyncToGenerator","_regeneratorRuntime","mark","_callee","options","onProgress","etag","lastModified","bypassCache","headers","isCrossOrigin","response","_response$body","_response$body$cancel","status","blob","headerType","fileName","responseEtag","responseLastModified","_args","wrap","_callee$","_context","prev","next","Error","location","origin","fetch","_objectSpread","cache","Object","keys","sent","abrupt","notModified","get","ok","body","cancel","call","statusText","readResponseBlob","type","File","keplerSourceUrl","keplerFormat","keplerEtag","keplerLastModified","size","stop","remoteDatasetFromUrl","label","sourceFormat","data","fields","rows","info","id","row","EXTERNALLY_HOSTED","metadata","source","fetchRemoteFileAsKeplerFile","_x2","_x3","_x4","_fetchRemoteFileAsKeplerFile","_callee2","result","_callee2$","_context2","PAINT_WAIT_MS","waitForNextPaint","requestAnimationFrame","document","hidden","Promise","resolve","settled","frames","finish","clearTimeout","timer","cancelAnimationFrame","forEach","setTimeout","push","_x5","_x6","_readResponseBlob","_callee3","contentLength","total","PROGRESS_INTERVAL_MS","lastEmitAt","lastEmittedPercent","emit","reader","chunks","loaded","_yield$reader$read","done","value","_callee3$","_context3","Number","isFinite","complete","percent","Math","min","rounded","round","now","performance","Date","getReader","read","byteLength","Blob","isTabularProcessorResult","_typeof","Array","isArray","matchesCsvHeader","_x7","_x8","_matchesCsvHeader","_callee4","text","escape","blankLines","matchesRecord","_iteratorAbruptCompletion","_didIteratorError","_iteratorError","_iterator","_step","batch","header","names","_callee4$","_context4","strict","some","delimiter","record","map","name","quoted","needsQuotes","includes","join","RegExp","_asyncIterator","parseInBatches","TextEncoder","encode","csv","shape","_toConsumableArray","t0","fromEntries","every","i","loadExternallyHostedDataset","_x9","_loadExternallyHostedDataset","_callee5","_fetched$size","_metadata$csvHeader","_processed","fetched","batches","content","_iteratorAbruptCompletion2","_didIteratorError2","_iteratorError2","_iterator2","_step2","processed","_callee5$","_context5","phase","fileCache","loaders","loadOptions","t1","csvHeader","extensions","extension","t2","t3","t4","sourceUrl","isExternallyHostedFile"],"sources":["../../src/remote-file.ts"],"sourcesContent":["// SPDX-License-Identifier: MIT\n// Copyright contributors to the kepler.gl project\n\nimport {parseUri} from '@kepler.gl/common-utils';\nimport {\n  DATASET_FORMATS,\n  DatasetType,\n  MIME_TO_REMOTE_FILE_EXTENSION,\n  REMOTE_FILE_EXTENSIONS,\n  REMOTE_FILE_MIME_TYPES,\n  RemoteFileFormat\n} from '@kepler.gl/constants';\nimport {ProcessorResult} from '@kepler.gl/types';\nimport {generateHashIdFromString} from '@kepler.gl/utils';\n\nimport {\n  getPersistedRemoteFormat,\n  processFileData,\n  ProcessFileDataContent,\n  readFileInBatches\n} from './file-handler';\nimport {FileCacheItem} from './types';\nimport {KeplerCSVLoader} from './kepler-csv-loader';\n\nexport type KeplerRemoteFile = File & {\n  keplerSourceUrl?: string;\n  keplerFormat?: string;\n  keplerRefreshIntervalMs?: number;\n  keplerEtag?: string;\n  keplerLastModified?: string;\n};\n\nexport type RemoteLoadProgress = {\n  loaded: number;\n  total?: number;\n  percent: number;\n  /** Set once the bytes are in memory and parsing is about to block the main thread. */\n  phase?: 'processing';\n};\n\nexport type FetchRemoteFileOptions = {\n  format?: string | null;\n  onProgress?: (progress: RemoteLoadProgress) => void;\n  etag?: string;\n  lastModified?: string;\n  /** Bypass the HTTP cache. Used for poll/reload, not the first remote URL load. */\n  bypassCache?: boolean;\n};\n\nexport type FetchRemoteFileResult = {\n  file: KeplerRemoteFile | null;\n  notModified: boolean;\n  etag?: string;\n  lastModified?: string;\n  size?: number;\n};\n\nexport type LoadExternallyHostedDatasetResult = {\n  data: NonNullable<ProcessorResult> | null;\n  notModified: boolean;\n  etag?: string;\n  lastModified?: string;\n  size?: number;\n};\n\nfunction getPathFileName(url: string): string {\n  try {\n    const parsed = new URL(url);\n    const segments = parsed.pathname.split('/').filter(Boolean);\n    const last = segments.length ? decodeURIComponent(segments[segments.length - 1]) : '';\n    return last.split('?')[0];\n  } catch {\n    const {file} = parseUri(url);\n    return decodeURIComponent(String(file || '')).split('?')[0];\n  }\n}\n\nexport function getExtensionFromUrl(url: string): string {\n  const file = getPathFileName(url);\n  const match = file.match(/\\.([a-z0-9]+)$/i);\n  return match ? match[1].toLowerCase() : '';\n}\n\nexport function getMimeTypeForFormat(format?: string | null): string | undefined {\n  if (!format || format === 'auto') {\n    return undefined;\n  }\n  return REMOTE_FILE_MIME_TYPES[format as Exclude<RemoteFileFormat, 'auto'>];\n}\n\nexport function isRemoteDatasetUrl(url: string): boolean {\n  try {\n    const {protocol} = new URL(url);\n    return protocol === 'http:' || protocol === 'https:';\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Build a filename loaders.gl can use to pick a parser.\n * Prefers an explicit format, then the URL path extension, then Content-Type.\n */\nexport function getFileNameForRemoteUrl(\n  url: string,\n  format?: string | null,\n  mimeType?: string | null\n): string {\n  const base = getPathFileName(url) || 'dataset';\n\n  const formatExt =\n    format && format !== 'auto'\n      ? REMOTE_FILE_EXTENSIONS[format as Exclude<RemoteFileFormat, 'auto'>]\n      : undefined;\n  const urlExt = getExtensionFromUrl(url);\n  const mimeExt = mimeType\n    ? MIME_TO_REMOTE_FILE_EXTENSION[mimeType.split(';')[0].trim().toLowerCase()]\n    : undefined;\n  const ext = formatExt || urlExt || mimeExt;\n\n  if (!ext) {\n    return base;\n  }\n\n  if (/\\.[a-z0-9]+$/i.test(base)) {\n    if (formatExt && !base.toLowerCase().endsWith(`.${formatExt}`)) {\n      return `${base.replace(/\\.[^.]+$/, '')}.${formatExt}`;\n    }\n    return base;\n  }\n\n  return `${base}.${ext}`;\n}\n\n/**\n * Fetch a remote dataset URL. Uses conditional headers for same-origin requests\n * (or outside a browser) so unchanged files can skip a re-parse.\n */\nexport async function fetchRemoteFile(\n  url: string,\n  options: FetchRemoteFileOptions = {}\n): Promise<FetchRemoteFileResult> {\n  const {format, onProgress, etag, lastModified, bypassCache} = options;\n  if (!isRemoteDatasetUrl(url)) {\n    throw new Error('Remote dataset URL must use http or https');\n  }\n  const headers: Record<string, string> = {};\n  // Conditional headers trigger CORS preflights, which simple file servers may\n  // not support even when they allow cross-origin GET requests.\n  const isCrossOrigin = typeof location !== 'undefined' && new URL(url).origin !== location.origin;\n  if (etag && !isCrossOrigin) {\n    headers['If-None-Match'] = etag;\n  }\n  if (lastModified && !isCrossOrigin) {\n    headers['If-Modified-Since'] = lastModified;\n  }\n  const response = await fetch(url, {\n    ...(bypassCache ? {cache: 'no-store' as RequestCache} : {}),\n    ...(Object.keys(headers).length ? {headers} : {})\n  });\n  if (response.status === 304) {\n    return {\n      file: null,\n      notModified: true,\n      etag: response.headers.get('etag') || etag || undefined,\n      lastModified: response.headers.get('last-modified') || lastModified || undefined\n    };\n  }\n  if (!response.ok) {\n    // Don't put the response body in the error: 404 HTML pages would dump into the UI.\n    response.body?.cancel?.().catch(() => undefined);\n    const status = response.statusText\n      ? `${response.status} ${response.statusText}`\n      : String(response.status);\n    throw new Error(`Failed to fetch ${url} (${status})`);\n  }\n\n  const blob = await readResponseBlob(response, onProgress);\n  const headerType = response.headers.get('content-type') || blob.type || '';\n  const mimeType = getMimeTypeForFormat(format) || headerType.split(';')[0].trim();\n  const fileName = getFileNameForRemoteUrl(url, format, mimeType);\n  const file = new File(\n    [blob],\n    fileName,\n    mimeType ? {type: mimeType} : undefined\n  ) as KeplerRemoteFile;\n  file.keplerSourceUrl = url;\n  if (format && format !== 'auto') {\n    file.keplerFormat = format;\n  }\n  const responseEtag = response.headers.get('etag') || undefined;\n  const responseLastModified = response.headers.get('last-modified') || undefined;\n  if (responseEtag) {\n    file.keplerEtag = responseEtag;\n  }\n  if (responseLastModified) {\n    file.keplerLastModified = responseLastModified;\n  }\n  return {\n    file,\n    notModified: false,\n    etag: responseEtag,\n    lastModified: responseLastModified,\n    size: file.size\n  };\n}\n\n/**\n * A remote URL to hold until Add Data. Rows stay empty so adding it runs the\n * externally hosted download instead of parsing a file in the modal.\n */\nexport function remoteDatasetFromUrl(url: string, format?: string | null): FileCacheItem {\n  if (!isRemoteDatasetUrl(url)) {\n    throw new Error('Remote dataset URL must use http or https');\n  }\n  const label = getFileNameForRemoteUrl(url, format);\n  const sourceFormat = getPersistedRemoteFormat(\n    format && format !== 'auto' ? format : undefined,\n    label\n  );\n  return {\n    data: {fields: [], rows: []},\n    info: {\n      id: generateHashIdFromString(url),\n      label,\n      format: DATASET_FORMATS.row,\n      type: DatasetType.EXTERNALLY_HOSTED\n    },\n    metadata: {\n      source: url,\n      ...(sourceFormat ? {sourceFormat} : {})\n    }\n  };\n}\n\n/**\n * Fetch a remote dataset URL and wrap it as a File the existing loadFiles pipeline can parse.\n * Sets File.type from an explicit format or the response Content-Type so extensionless\n * URLs (SAS keys) still select the right loader.\n */\nexport async function fetchRemoteFileAsKeplerFile(\n  url: string,\n  format?: string | null,\n  onProgress?: (progress: RemoteLoadProgress) => void\n): Promise<KeplerRemoteFile> {\n  const result = await fetchRemoteFile(url, {format, onProgress});\n  if (!result.file) {\n    throw new Error(`Failed to fetch ${url} (304 Not Modified)`);\n  }\n  return result.file;\n}\n\n/** Two frames are enough for the processing indicator to paint. */\nconst PAINT_WAIT_MS = 100;\n\nfunction waitForNextPaint(): Promise<void> {\n  // Hidden tabs suspend requestAnimationFrame. A download that finishes in the\n  // background would otherwise wait until the user comes back, and there is\n  // nothing to paint there.\n  if (\n    typeof requestAnimationFrame !== 'function' ||\n    (typeof document !== 'undefined' && document.hidden)\n  ) {\n    return Promise.resolve();\n  }\n  return new Promise(resolve => {\n    let settled = false;\n    const frames: number[] = [];\n    const finish = () => {\n      if (settled) {\n        return;\n      }\n      settled = true;\n      clearTimeout(timer);\n      if (typeof cancelAnimationFrame === 'function') {\n        frames.forEach(id => cancelAnimationFrame(id));\n      }\n      resolve();\n    };\n    // The tab can be hidden after this wait starts. Don't sit on frames that will never run.\n    const timer = setTimeout(finish, PAINT_WAIT_MS);\n    frames.push(\n      requestAnimationFrame(() => {\n        if (!settled) {\n          frames.push(requestAnimationFrame(finish));\n        }\n      })\n    );\n  });\n}\n\nasync function readResponseBlob(\n  response: Response,\n  onProgress?: (progress: RemoteLoadProgress) => void\n): Promise<Blob> {\n  const contentLength = Number(response.headers.get('content-length'));\n  const total = Number.isFinite(contentLength) && contentLength > 0 ? contentLength : undefined;\n\n  const PROGRESS_INTERVAL_MS = 80;\n  let lastEmitAt = 0;\n  let lastEmittedPercent = -1;\n  const emit = (loaded: number, complete = false) => {\n    const percent = complete ? 1 : total ? Math.min(1, loaded / total) : 0;\n    const rounded = Math.round(percent * 100);\n    const now = typeof performance !== 'undefined' ? performance.now() : Date.now();\n    if (\n      !complete &&\n      loaded !== 0 &&\n      rounded === lastEmittedPercent &&\n      now - lastEmitAt < PROGRESS_INTERVAL_MS\n    ) {\n      return;\n    }\n    lastEmitAt = now;\n    lastEmittedPercent = rounded;\n    onProgress?.({\n      loaded,\n      total,\n      percent\n    });\n  };\n\n  if (!response.body) {\n    const blob = await response.blob();\n    emit(blob.size, true);\n    return blob;\n  }\n\n  const reader = response.body.getReader();\n  const chunks: Uint8Array[] = [];\n  let loaded = 0;\n  emit(0);\n\n  while (true) {\n    const {done, value} = await reader.read();\n    if (done) {\n      break;\n    }\n    chunks.push(value);\n    loaded += value.byteLength;\n    emit(loaded);\n  }\n\n  emit(loaded, true);\n  return new Blob(chunks);\n}\n\nfunction isTabularProcessorResult(data: unknown): data is NonNullable<ProcessorResult> {\n  return Boolean(\n    data &&\n      typeof data === 'object' &&\n      Array.isArray((data as ProcessorResult)?.fields) &&\n      Array.isArray((data as ProcessorResult)?.rows)\n  );\n}\n\nasync function matchesCsvHeader(text: string, fields: string[]): Promise<boolean> {\n  const escape = (value: string) => value.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  const blankLines = '(?:[ \\\\t]*[\\\\r\\\\n])*';\n  // Keep exact quote validation: the CSV parser accepts some malformed records.\n  const matchesRecord = (header: string[], strict: boolean) =>\n    [',', '\\t', ';', '|'].some(delimiter => {\n      const record = header\n        .map(name => {\n          const quoted = escape(`\"${name.replace(/\"/g, '\"\"')}\"`);\n          const needsQuotes =\n            /[\"\\r\\n]/.test(name) || (strict ? /[,\\t;|]/.test(name) : name.includes(delimiter));\n          return needsQuotes ? quoted : `(?:${escape(name)}|${quoted})`;\n        })\n        .join(escape(delimiter));\n      return new RegExp(`^\\\\uFEFF?${blankLines}${record}${blankLines}$`).test(text);\n    });\n  // Quoted names remain unambiguous even when the loader guesses another delimiter.\n  if (fields.some(name => name.trim()) && matchesRecord(fields, true)) return true;\n  // A lone bare name containing delimiters has no separator to disambiguate it.\n  if (fields.length === 1) return false;\n\n  // Reuse the same streaming parser as import, exposing the header as a row.\n  const rows: string[][] = [];\n  for await (const batch of KeplerCSVLoader.parseInBatches!([new TextEncoder().encode(text)], {\n    csv: {\n      shape: 'array-row-table',\n      // @ts-expect-error loaders.gl accepts false but its type only declares 'auto'.\n      header: false\n    }\n  })) {\n    rows.push(...batch.data);\n  }\n  if (rows.length !== 1) return false;\n  const header = rows[0];\n  // processRowObject uses Object.keys, which sorts integer-named columns.\n  const names = Object.keys(Object.fromEntries(header.map(name => [name, null])));\n  return (\n    header.length === fields.length &&\n    names.length === fields.length &&\n    names.every((name, i) => name === fields[i]) &&\n    matchesRecord(header, false)\n  );\n}\n\n/**\n * Fetch, parse, and process a remote file into Kepler dataset data.\n * Used when reloading an `externally-hosted` dataset from a saved map config\n * and when refreshing a live remote dataset.\n */\nexport async function loadExternallyHostedDataset(metadata: {\n  source: string;\n  format?: string;\n  size?: number;\n  etag?: string;\n  lastModified?: string;\n  bypassCache?: boolean;\n  onProgress?: (progress: RemoteLoadProgress) => void;\n  /** Established CSV columns, supplied only when refreshing an existing table. */\n  csvHeader?: string[];\n}): Promise<LoadExternallyHostedDatasetResult> {\n  const {source, format, etag, lastModified, size, bypassCache, onProgress} = metadata;\n  const fetched = await fetchRemoteFile(source, {\n    format,\n    etag,\n    lastModified,\n    bypassCache,\n    onProgress\n  });\n  if (fetched.notModified || !fetched.file) {\n    return {\n      data: null,\n      notModified: true,\n      etag: fetched.etag,\n      lastModified: fetched.lastModified,\n      size\n    };\n  }\n\n  onProgress?.({\n    loaded: fetched.size ?? fetched.file.size,\n    ...(typeof fetched.size === 'number' ? {total: fetched.size} : {}),\n    percent: 1,\n    phase: 'processing'\n  });\n  // Let the loading indicator paint a processing state before parse blocks the tab.\n  await waitForNextPaint();\n\n  const batches = await readFileInBatches({\n    file: fetched.file,\n    fileCache: [],\n    loaders: [],\n    loadOptions: {}\n  });\n\n  let content: ProcessFileDataContent | undefined;\n  for await (const batch of batches) {\n    content = batch as ProcessFileDataContent;\n  }\n  // CSVLoader emits no data batch for a header-only file. Keep its populated\n  // parsing path intact; recognize only a header matching this existing table.\n  if (\n    metadata.csvHeader?.length &&\n    KeplerCSVLoader.extensions.some(extension =>\n      fetched.file!.name.toLowerCase().endsWith(`.${extension}`)\n    ) &&\n    (!content || (Array.isArray(content.data) && !content.data.length)) &&\n    (await matchesCsvHeader(await fetched.file.text(), metadata.csvHeader))\n  ) {\n    return {\n      data: {fields: [], rows: []},\n      notModified: false,\n      etag: fetched.etag,\n      lastModified: fetched.lastModified,\n      size: fetched.size\n    };\n  }\n  if (!content) {\n    throw new Error(`No data loaded from ${source}`);\n  }\n\n  const processed = await processFileData({\n    content: {\n      ...content,\n      fileName: content.fileName,\n      sourceUrl: source\n    },\n    fileCache: []\n  });\n  const data = processed[processed.length - 1]?.data;\n  if (!isTabularProcessorResult(data)) {\n    throw new Error(`Remote file is not a dataset: ${source}`);\n  }\n  return {\n    data,\n    notModified: false,\n    etag: fetched.etag,\n    lastModified: fetched.lastModified,\n    size: fetched.size\n  };\n}\n\nexport function isExternallyHostedFile(file: File): file is KeplerRemoteFile {\n  return Boolean((file as KeplerRemoteFile).keplerSourceUrl);\n}\n"],"mappings":"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","ignoreList":[]}