@loaders.gl/scientific 5.0.0-beta.1 → 5.0.0-beta.2

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 (79) hide show
  1. package/README.md +5 -2
  2. package/dist/index.cjs +78 -4110
  3. package/dist/index.cjs.map +4 -3
  4. package/dist/index.d.ts +4 -0
  5. package/dist/index.d.ts.map +1 -1
  6. package/dist/index.js +2 -0
  7. package/dist/index.js.map +1 -1
  8. package/dist/lib/parsers/parse-npy.d.ts +15 -0
  9. package/dist/lib/parsers/parse-npy.d.ts.map +1 -0
  10. package/dist/lib/parsers/parse-npy.js +81 -0
  11. package/dist/lib/parsers/parse-npy.js.map +1 -0
  12. package/dist/netcdf/bundled.cjs +1 -2
  13. package/dist/netcdf/index.cjs +1 -2
  14. package/dist/netcdf/index.cjs.map +2 -2
  15. package/dist/netcdf/netcdf-loader-with-parser.cjs +1 -2
  16. package/dist/netcdf/netcdf-loader-with-parser.js +1 -1
  17. package/dist/netcdf/netcdf-loader-with-parser.js.map +1 -1
  18. package/dist/netcdf/netcdf-loader.cjs +5 -4
  19. package/dist/netcdf/netcdf-loader.cjs.map +7 -0
  20. package/dist/netcdf/netcdf-loader.js +1 -1
  21. package/dist/netcdf/netcdf-source-loader-types.js +1 -1
  22. package/dist/netcdf/netcdf-source-loader.js +1 -1
  23. package/dist/netcdf/unbundled.cjs +1 -2
  24. package/dist/netcdf.min.js +3 -3
  25. package/dist/npy-format.d.ts +12 -0
  26. package/dist/npy-format.d.ts.map +1 -0
  27. package/dist/npy-format.js +15 -0
  28. package/dist/npy-format.js.map +1 -0
  29. package/dist/npy-loader-types.cjs +80 -0
  30. package/dist/npy-loader-types.cjs.map +7 -0
  31. package/dist/npy-loader-types.d.ts +73 -0
  32. package/dist/npy-loader-types.d.ts.map +1 -0
  33. package/dist/npy-loader-types.js +34 -0
  34. package/dist/npy-loader-types.js.map +1 -0
  35. package/dist/npy-loader.cjs +273 -0
  36. package/dist/npy-loader.cjs.map +6 -0
  37. package/dist/npy-loader.d.ts +27 -0
  38. package/dist/npy-loader.d.ts.map +1 -0
  39. package/dist/npy-loader.js +15 -0
  40. package/dist/npy-loader.js.map +1 -0
  41. package/dist/npy-worker.d.ts +2 -0
  42. package/dist/npy-worker.d.ts.map +1 -0
  43. package/dist/npy-worker.js +750 -0
  44. package/dist/npy-worker.js.map +1 -0
  45. package/dist/vtk/index.cjs +4 -4118
  46. package/dist/vtk/index.cjs.map +2 -2
  47. package/dist/vtk/vtk-xml.js +4 -4
  48. package/dist/vtk/vtk-xml.js.map +1 -1
  49. package/dist/workers/npy-worker.d.ts +2 -0
  50. package/dist/workers/npy-worker.d.ts.map +1 -0
  51. package/dist/workers/npy-worker.js +7 -0
  52. package/dist/workers/npy-worker.js.map +1 -0
  53. package/dist/zarr/geo-zarr-source-loader.d.ts.map +1 -1
  54. package/dist/zarr/geo-zarr-source-loader.js +162 -43
  55. package/dist/zarr/geo-zarr-source-loader.js.map +1 -1
  56. package/dist/zarr/index.cjs +194 -43
  57. package/dist/zarr/index.cjs.map +2 -2
  58. package/dist/zarr/lib/spatial-multiscales.d.ts +13 -2
  59. package/dist/zarr/lib/spatial-multiscales.d.ts.map +1 -1
  60. package/dist/zarr/lib/spatial-multiscales.js +94 -8
  61. package/dist/zarr/lib/spatial-multiscales.js.map +1 -1
  62. package/dist/zarr/ome-zarr-source-loader.js +1 -1
  63. package/dist/zarr/zarr-loader-types.cjs +161 -0
  64. package/dist/zarr/zarr-loader-types.cjs.map +7 -0
  65. package/dist/zarr/zarr-loader-types.js +1 -1
  66. package/dist/zarr.dev.js +194 -43
  67. package/dist/zarr.min.js +40 -40
  68. package/package.json +42 -7
  69. package/src/index.ts +5 -0
  70. package/src/lib/parsers/parse-npy.ts +123 -0
  71. package/src/netcdf/netcdf-loader-with-parser.ts +1 -1
  72. package/src/npy-format.ts +17 -0
  73. package/src/npy-loader-types.ts +50 -0
  74. package/src/npy-loader.ts +21 -0
  75. package/src/npy-worker.ts +6 -0
  76. package/src/vtk/vtk-xml.ts +4 -4
  77. package/src/workers/npy-worker.ts +8 -0
  78. package/src/zarr/geo-zarr-source-loader.ts +195 -44
  79. package/src/zarr/lib/spatial-multiscales.ts +104 -8
@@ -0,0 +1,750 @@
1
+ "use strict";
2
+ (() => {
3
+ var __defProp = Object.defineProperty;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __esm = (fn, res, err) => function __init() {
6
+ if (err) throw err[0];
7
+ try {
8
+ return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
9
+ } catch (e) {
10
+ throw err = [e], e;
11
+ }
12
+ };
13
+ var __export = (target, all) => {
14
+ for (var name in all)
15
+ __defProp(target, name, { get: all[name], enumerable: true });
16
+ };
17
+
18
+ // src/lib/parsers/parse-npy.ts
19
+ function parseNPY(arrayBuffer, options) {
20
+ const view = new DataView(arrayBuffer);
21
+ const { header, headerEndOffset } = parseHeader(view);
22
+ const numpyType = header.descr;
23
+ const ArrayType = DTYPES[numpyType.slice(1, 3)];
24
+ if (!ArrayType) {
25
+ throw new Error(`Unimplemented type ${numpyType}`);
26
+ }
27
+ const nArrayElements = header.shape?.reduce((a2, b2) => a2 * b2);
28
+ const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
29
+ if (arrayBuffer.byteLength < headerEndOffset + arrayByteLength) {
30
+ throw new Error("Buffer overflow");
31
+ }
32
+ const data = new ArrayType(arrayBuffer.slice(headerEndOffset, headerEndOffset + arrayByteLength));
33
+ if (numpyType[0] === ">" && LITTLE_ENDIAN_OS || numpyType[0] === "<" && !LITTLE_ENDIAN_OS) {
34
+ throw new Error("Incorrect endianness");
35
+ }
36
+ return {
37
+ data,
38
+ header
39
+ };
40
+ }
41
+ function parseHeader(view) {
42
+ const majorVersion = view.getUint8(6);
43
+ let offset = 8;
44
+ let headerLength;
45
+ if (majorVersion >= 2) {
46
+ headerLength = view.getUint32(offset, true);
47
+ offset += 4;
48
+ } else {
49
+ headerLength = view.getUint16(offset, true);
50
+ offset += 2;
51
+ }
52
+ const encoding = majorVersion <= 2 ? "latin1" : "utf-8";
53
+ const decoder = new TextDecoder(encoding);
54
+ const headerArray = new Uint8Array(view.buffer, offset, headerLength);
55
+ const headerText = decoder.decode(headerArray);
56
+ offset += headerLength;
57
+ const header = JSON.parse(
58
+ headerText.replace(/'/g, '"').replace("False", "false").replace("(", "[").replace(/,*\),*/g, "]")
59
+ );
60
+ return { header, headerEndOffset: offset };
61
+ }
62
+ var a, b, isLittleEndian, LITTLE_ENDIAN_OS, DTYPES;
63
+ var init_parse_npy = __esm({
64
+ "src/lib/parsers/parse-npy.ts"() {
65
+ "use strict";
66
+ a = new Uint32Array([305419896]);
67
+ b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
68
+ isLittleEndian = !(b[0] === 18);
69
+ LITTLE_ENDIAN_OS = isLittleEndian;
70
+ DTYPES = {
71
+ u1: Uint8Array,
72
+ i1: Int8Array,
73
+ u2: Uint16Array,
74
+ i2: Int16Array,
75
+ u4: Uint32Array,
76
+ i4: Int32Array,
77
+ f4: Float32Array,
78
+ f8: Float64Array
79
+ };
80
+ }
81
+ });
82
+
83
+ // src/npy-format.ts
84
+ var NPYFormat;
85
+ var init_npy_format = __esm({
86
+ "src/npy-format.ts"() {
87
+ "use strict";
88
+ NPYFormat = {
89
+ name: "NPY",
90
+ id: "npy",
91
+ module: "scientific",
92
+ encoding: "binary",
93
+ format: "npy",
94
+ extensions: ["npy"],
95
+ mimeTypes: [],
96
+ binary: true
97
+ };
98
+ }
99
+ });
100
+
101
+ // src/npy-loader-types.ts
102
+ async function preload() {
103
+ const { NPYLoaderWithParser: NPYLoaderWithParser2 } = await Promise.resolve().then(() => (init_npy_loader(), npy_loader_exports));
104
+ return NPYLoaderWithParser2;
105
+ }
106
+ var VERSION, NPY_MAGIC_NUMBER, NPYLoader;
107
+ var init_npy_loader_types = __esm({
108
+ "src/npy-loader-types.ts"() {
109
+ "use strict";
110
+ init_npy_format();
111
+ VERSION = true ? "5.0.0-beta.2" : "latest";
112
+ NPY_MAGIC_NUMBER = new Uint8Array([147, 78, 85, 77, 80, 89]);
113
+ NPYLoader = {
114
+ ...NPYFormat,
115
+ dataType: null,
116
+ batchType: null,
117
+ name: "NPY",
118
+ id: "npy",
119
+ module: "scientific",
120
+ version: VERSION,
121
+ worker: true,
122
+ extensions: ["npy"],
123
+ mimeTypes: [],
124
+ tests: [NPY_MAGIC_NUMBER.buffer],
125
+ options: {
126
+ npy: {}
127
+ },
128
+ preload
129
+ };
130
+ }
131
+ });
132
+
133
+ // src/npy-loader.ts
134
+ var npy_loader_exports = {};
135
+ __export(npy_loader_exports, {
136
+ NPYLoaderWithParser: () => NPYLoaderWithParser
137
+ });
138
+ var _preload, metadata, NPYLoaderWithParser;
139
+ var init_npy_loader = __esm({
140
+ "src/npy-loader.ts"() {
141
+ "use strict";
142
+ init_parse_npy();
143
+ init_npy_loader_types();
144
+ ({ preload: _preload, ...metadata } = NPYLoader);
145
+ NPYLoaderWithParser = {
146
+ ...metadata,
147
+ parseSync: parseNPY,
148
+ parse: async (arrayBuffer, options) => parseNPY(arrayBuffer, options)
149
+ };
150
+ }
151
+ });
152
+
153
+ // src/workers/npy-worker.ts
154
+ init_npy_loader();
155
+
156
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/node/worker_threads-browser.js
157
+ var parentPort = null;
158
+
159
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-utils/get-transfer-list.js
160
+ function getTransferList(object, recursive = true, transfers) {
161
+ const transfersSet = transfers || /* @__PURE__ */ new Set();
162
+ const seen = /* @__PURE__ */ new Set();
163
+ function visit(value) {
164
+ if (!value || typeof value !== "object" || seen.has(value))
165
+ return;
166
+ seen.add(value);
167
+ if (isTransferable(value))
168
+ transfersSet.add(value);
169
+ else if (ArrayBuffer.isView(value)) {
170
+ if (isTransferable(value.buffer))
171
+ transfersSet.add(value.buffer);
172
+ } else if (recursive && value instanceof Map) {
173
+ for (const [key, item] of value) {
174
+ visit(key);
175
+ visit(item);
176
+ }
177
+ } else if (recursive && value instanceof Set) {
178
+ for (const item of value)
179
+ visit(item);
180
+ } else if (recursive) {
181
+ for (const key of Object.keys(value))
182
+ visit(value[key]);
183
+ }
184
+ }
185
+ visit(object);
186
+ return transfers === void 0 ? Array.from(transfersSet) : [];
187
+ }
188
+ function isTransferable(object) {
189
+ if (!object) {
190
+ return false;
191
+ }
192
+ if (object instanceof ArrayBuffer) {
193
+ return true;
194
+ }
195
+ if (typeof MessagePort !== "undefined" && object instanceof MessagePort) {
196
+ return true;
197
+ }
198
+ if (typeof ImageBitmap !== "undefined" && object instanceof ImageBitmap) {
199
+ return true;
200
+ }
201
+ if (typeof OffscreenCanvas !== "undefined" && object instanceof OffscreenCanvas) {
202
+ return true;
203
+ }
204
+ return false;
205
+ }
206
+
207
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-farm/worker-body.js
208
+ async function getParentPort() {
209
+ return parentPort;
210
+ }
211
+ var onMessageWrapperMap = /* @__PURE__ */ new Map();
212
+ var WorkerBody = class {
213
+ /** Check that we are actually in a worker thread */
214
+ static async inWorkerThread() {
215
+ const workerGlobalScope = globalThis.WorkerGlobalScope;
216
+ return typeof workerGlobalScope === "function" && globalThis instanceof workerGlobalScope || Boolean(await getParentPort());
217
+ }
218
+ /*
219
+ * (type: WorkerMessageType, payload: WorkerMessagePayload) => any
220
+ */
221
+ static set onmessage(onMessage) {
222
+ async function handleMessage(message) {
223
+ const parentPort2 = await getParentPort();
224
+ const { type, payload } = parentPort2 ? message : message.data;
225
+ onMessage(type, payload);
226
+ }
227
+ getParentPort().then((parentPort2) => {
228
+ if (parentPort2) {
229
+ parentPort2.on("message", (message) => {
230
+ handleMessage(message);
231
+ });
232
+ parentPort2.on("exit", () => console.debug("Node worker closing"));
233
+ } else {
234
+ globalThis.onmessage = handleMessage;
235
+ }
236
+ });
237
+ }
238
+ static async addEventListener(onMessage) {
239
+ let onMessageWrapper = onMessageWrapperMap.get(onMessage);
240
+ if (!onMessageWrapper) {
241
+ onMessageWrapper = (message) => {
242
+ const messageData = getWorkerMessageData(message);
243
+ if (!messageData) {
244
+ return;
245
+ }
246
+ onMessage(messageData.type, messageData.payload);
247
+ };
248
+ onMessageWrapperMap.set(onMessage, onMessageWrapper);
249
+ }
250
+ const parentPort2 = await getParentPort();
251
+ if (parentPort2) {
252
+ parentPort2.on("message", onMessageWrapper);
253
+ } else {
254
+ globalThis.addEventListener("message", onMessageWrapper);
255
+ }
256
+ }
257
+ static async removeEventListener(onMessage) {
258
+ const onMessageWrapper = onMessageWrapperMap.get(onMessage);
259
+ onMessageWrapperMap.delete(onMessage);
260
+ if (!onMessageWrapper) {
261
+ return;
262
+ }
263
+ const parentPort2 = await getParentPort();
264
+ if (parentPort2) {
265
+ parentPort2.off("message", onMessageWrapper);
266
+ } else {
267
+ globalThis.removeEventListener("message", onMessageWrapper);
268
+ }
269
+ }
270
+ /**
271
+ * Send a message from a worker to creating thread (main thread)
272
+ * @param type
273
+ * @param payload
274
+ */
275
+ static async postMessage(type, payload) {
276
+ const data = { source: "loaders.gl", type, payload };
277
+ const transferList = getTransferList(payload);
278
+ const parentPort2 = await getParentPort();
279
+ if (parentPort2) {
280
+ parentPort2.postMessage(data, transferList);
281
+ } else {
282
+ globalThis.postMessage(data, transferList);
283
+ }
284
+ }
285
+ };
286
+ function getWorkerMessageData(message) {
287
+ if (!message || typeof message !== "object") {
288
+ return null;
289
+ }
290
+ const messageData = "data" in message && message.type === "message" ? message.data : message;
291
+ return messageData && typeof messageData.source === "string" && messageData.source.startsWith("loaders.gl") ? messageData : null;
292
+ }
293
+
294
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/async-queue/async-queue.js
295
+ var AsyncQueue = class {
296
+ constructor() {
297
+ this._values = [];
298
+ this._settlers = [];
299
+ this._closed = false;
300
+ }
301
+ /** Return an async iterator for this queue */
302
+ [Symbol.asyncIterator]() {
303
+ return this;
304
+ }
305
+ /** Push a new value - the async iterator will yield a promise resolved to this value */
306
+ push(value) {
307
+ return this.enqueue(value);
308
+ }
309
+ /**
310
+ * Push a new value - the async iterator will yield a promise resolved to this value
311
+ * Add an error - the async iterator will yield a promise rejected with this value
312
+ */
313
+ enqueue(value) {
314
+ if (this._closed) {
315
+ throw new Error("Closed");
316
+ }
317
+ if (this._settlers.length > 0) {
318
+ if (this._values.length > 0) {
319
+ throw new Error("Illegal internal state");
320
+ }
321
+ const settler = this._settlers.shift();
322
+ if (value instanceof Error) {
323
+ settler.reject(value);
324
+ } else {
325
+ settler.resolve({ value });
326
+ }
327
+ } else {
328
+ this._values.push(value);
329
+ }
330
+ }
331
+ /** Indicate that we not waiting for more values - The async iterator will be done */
332
+ close() {
333
+ while (this._settlers.length > 0) {
334
+ const settler = this._settlers.shift();
335
+ settler.resolve({ done: true });
336
+ }
337
+ this._closed = true;
338
+ }
339
+ // ITERATOR IMPLEMENTATION
340
+ /** @returns a Promise for an IteratorResult */
341
+ next() {
342
+ if (this._values.length > 0) {
343
+ const value = this._values.shift();
344
+ if (value instanceof Error) {
345
+ return Promise.reject(value);
346
+ }
347
+ return Promise.resolve({ done: false, value });
348
+ }
349
+ if (this._closed) {
350
+ if (this._settlers.length > 0) {
351
+ throw new Error("Illegal internal state");
352
+ }
353
+ return Promise.resolve({ done: true, value: void 0 });
354
+ }
355
+ return new Promise((resolve, reject) => {
356
+ this._settlers.push({ resolve, reject });
357
+ });
358
+ }
359
+ };
360
+
361
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/shared-state.js
362
+ var SharedWorkerState = class {
363
+ constructor(buffer) {
364
+ if (typeof SharedArrayBuffer === "undefined" || !(buffer instanceof SharedArrayBuffer) || buffer.byteLength !== 16)
365
+ throw new Error("Expected a 16-byte shared worker control buffer");
366
+ this.buffer = buffer;
367
+ this.values = new Int32Array(buffer);
368
+ }
369
+ get snapshot() {
370
+ return {
371
+ cancelled: Atomics.load(this.values, 0) !== 0,
372
+ completed: Atomics.load(this.values, 1),
373
+ total: Atomics.load(this.values, 2),
374
+ revision: Atomics.load(this.values, 3)
375
+ };
376
+ }
377
+ cancel() {
378
+ Atomics.store(this.values, 0, 1);
379
+ Atomics.add(this.values, 3, 1);
380
+ Atomics.notify(this.values, 0);
381
+ }
382
+ throwIfCancelled() {
383
+ if (Atomics.load(this.values, 0) !== 0) {
384
+ const error = new Error("Shared worker task was cancelled");
385
+ error.name = "AbortError";
386
+ throw error;
387
+ }
388
+ }
389
+ /** Integer counters for application-defined work; messages still carry phase names and units. */
390
+ setProgress(completed, total = -1) {
391
+ if (!Number.isInteger(completed) || completed < 0 || completed > 2147483647 || !Number.isInteger(total) || total < -1 || total > 2147483647) {
392
+ throw new RangeError("Shared progress requires nonnegative int32 counts (or total -1)");
393
+ }
394
+ Atomics.store(this.values, 1, completed);
395
+ Atomics.store(this.values, 2, total);
396
+ Atomics.add(this.values, 3, 1);
397
+ }
398
+ };
399
+
400
+ // ../../node_modules/@math.gl/core/dist/worker-utils/lib/worker-api/create-worker.js
401
+ var requestId = 0;
402
+ var activeController = null;
403
+ var activeInputBatches = null;
404
+ var activeOutputAcknowledgements = null;
405
+ async function createWorker(process, processInBatches) {
406
+ if (!await WorkerBody.inWorkerThread()) {
407
+ return;
408
+ }
409
+ const context = {
410
+ process: processOnMainThread
411
+ };
412
+ WorkerBody.onmessage = async (type, payload) => {
413
+ if (type === "cancel") {
414
+ activeController?.abort();
415
+ activeInputBatches?.close();
416
+ activeOutputAcknowledgements?.close();
417
+ return;
418
+ }
419
+ const controller = type === "process" || type === "process-in-batches" ? new AbortController() : void 0;
420
+ if (controller)
421
+ activeController = controller;
422
+ const startedAt = performance.now();
423
+ const reporter = type === "process" || type === "process-in-batches" ? createProgressReporter() : void 0;
424
+ let sharedState;
425
+ const throwIfAborted = () => {
426
+ controller?.signal.throwIfAborted();
427
+ sharedState?.throwIfCancelled();
428
+ };
429
+ const jobContext = {
430
+ ...context,
431
+ signal: controller?.signal,
432
+ sharedState,
433
+ throwIfAborted,
434
+ reportProgress: (progress) => {
435
+ if (!controller?.signal.aborted && !sharedState?.snapshot.cancelled)
436
+ reporter?.report(progress);
437
+ }
438
+ };
439
+ try {
440
+ if (controller && payload.options?.["sharedState"]) {
441
+ sharedState = new SharedWorkerState(payload.options["sharedState"]);
442
+ jobContext.sharedState = sharedState;
443
+ }
444
+ switch (type) {
445
+ case "preload":
446
+ WorkerBody.postMessage("done", {});
447
+ break;
448
+ case "process":
449
+ throwIfAborted();
450
+ if (!process) {
451
+ throw new Error("Worker does not support atomic processing");
452
+ }
453
+ const result = await process(payload.input, payload.options || {}, jobContext, payload.context || {});
454
+ throwIfAborted();
455
+ reporter?.finish();
456
+ await WorkerBody.postMessage("done", {
457
+ result,
458
+ executionMs: performance.now() - startedAt
459
+ });
460
+ break;
461
+ case "process-in-batches":
462
+ throwIfAborted();
463
+ if (!processInBatches) {
464
+ throw new Error("Worker does not support batched processing");
465
+ }
466
+ const inputBatches = new AsyncQueue();
467
+ const outputAcknowledgements = new AsyncQueue();
468
+ activeInputBatches = inputBatches;
469
+ activeOutputAcknowledgements = outputAcknowledgements;
470
+ try {
471
+ const resultIterator = processInBatches(createDemandDrivenIterator(inputBatches), payload.options || {}, jobContext, payload.context || {});
472
+ for await (const batch of resultIterator) {
473
+ throwIfAborted();
474
+ await WorkerBody.postMessage("output-batch", { result: batch });
475
+ await outputAcknowledgements.next();
476
+ }
477
+ throwIfAborted();
478
+ reporter?.finish();
479
+ await WorkerBody.postMessage("done", { executionMs: performance.now() - startedAt });
480
+ } finally {
481
+ activeInputBatches = null;
482
+ activeOutputAcknowledgements = null;
483
+ }
484
+ break;
485
+ case "input-batch":
486
+ if (!activeInputBatches) {
487
+ throw new Error("Worker has no active batched processing session");
488
+ }
489
+ activeInputBatches.push(payload.input);
490
+ break;
491
+ case "input-done":
492
+ if (!activeInputBatches) {
493
+ throw new Error("Worker has no active batched processing session");
494
+ }
495
+ activeInputBatches.close();
496
+ break;
497
+ case "output-ack":
498
+ if (!activeOutputAcknowledgements) {
499
+ throw new Error("Worker has no active batched processing session");
500
+ }
501
+ activeOutputAcknowledgements.push(void 0);
502
+ break;
503
+ default:
504
+ }
505
+ } catch (error) {
506
+ reporter?.finish(controller?.signal.aborted || sharedState?.snapshot.cancelled);
507
+ const message = error instanceof Error ? error.message : "";
508
+ await WorkerBody.postMessage("error", {
509
+ error: message,
510
+ errorName: error instanceof Error ? error.name : "Error"
511
+ });
512
+ } finally {
513
+ if (controller && activeController === controller)
514
+ activeController = null;
515
+ }
516
+ };
517
+ await WorkerBody.postMessage("ready", {});
518
+ }
519
+ async function* createDemandDrivenIterator(inputBatches) {
520
+ while (true) {
521
+ await WorkerBody.postMessage("input-request", {});
522
+ const nextBatch = await inputBatches.next();
523
+ if (nextBatch.done) {
524
+ return;
525
+ }
526
+ yield nextBatch.value;
527
+ }
528
+ }
529
+ function processOnMainThread(arrayBuffer, options = {}, jobContext = {}) {
530
+ const signal = activeController?.signal;
531
+ signal?.throwIfAborted();
532
+ return new Promise((resolve, reject) => {
533
+ const id = requestId++;
534
+ const cleanup = () => {
535
+ signal?.removeEventListener("abort", abort);
536
+ void WorkerBody.removeEventListener(onMessage);
537
+ };
538
+ const abort = () => {
539
+ cleanup();
540
+ reject(signal?.reason);
541
+ };
542
+ const onMessage = (type, payload) => {
543
+ if (payload.id !== id)
544
+ return;
545
+ if (type === "done") {
546
+ cleanup();
547
+ resolve(payload.result);
548
+ } else if (type === "error") {
549
+ cleanup();
550
+ reject(payload.error);
551
+ }
552
+ };
553
+ void WorkerBody.addEventListener(onMessage).then(async () => {
554
+ if (signal?.aborted) {
555
+ abort();
556
+ return;
557
+ }
558
+ signal?.addEventListener("abort", abort, { once: true });
559
+ await WorkerBody.postMessage("process", {
560
+ id,
561
+ input: arrayBuffer,
562
+ options,
563
+ context: jobContext
564
+ });
565
+ }).catch((error) => {
566
+ cleanup();
567
+ reject(error);
568
+ });
569
+ });
570
+ }
571
+ function createProgressReporter() {
572
+ let pending;
573
+ let finished = false;
574
+ let scheduled = false;
575
+ const flush = () => {
576
+ scheduled = false;
577
+ if (pending) {
578
+ WorkerBody.postMessage("progress", { progress: pending });
579
+ pending = void 0;
580
+ }
581
+ };
582
+ return {
583
+ /** Records progress while retaining phase transitions. */
584
+ report(progress) {
585
+ if (finished)
586
+ return;
587
+ if (pending && pending.phase !== progress.phase)
588
+ flush();
589
+ pending = { ...progress };
590
+ if (!scheduled) {
591
+ scheduled = true;
592
+ setTimeout(flush, 0);
593
+ }
594
+ },
595
+ /** Flushes final progress and suppresses reports from stale callbacks. */
596
+ finish(discard = false) {
597
+ if (discard)
598
+ pending = void 0;
599
+ flush();
600
+ finished = true;
601
+ }
602
+ };
603
+ }
604
+
605
+ // ../../node_modules/@math.gl/core/dist/worker-utils/index.js
606
+ var import_meta = {};
607
+ var path = typeof __filename === "string" ? __filename.replace(/\\/g, "/") : "";
608
+ var moduleUrl = path ? `file://${path.startsWith("/") ? "" : "/"}${encodeURI(path).replace(/#/g, "%23").replace(/\?/g, "%3F")}` : import_meta.url;
609
+
610
+ // ../core/src/loader-utils/lib/worker-loader-utils/create-loader-worker.ts
611
+ async function createLoaderWorker(loader, selectLoader = () => loader) {
612
+ await createWorker(
613
+ (input, options, workerContext, loaderContext) => processLoaderWorkerData(
614
+ selectLoader(options || {}),
615
+ input,
616
+ options,
617
+ workerContext,
618
+ loaderContext
619
+ ),
620
+ (inputIterator, options, workerContext, loaderContext) => processLoaderWorkerBatches(
621
+ selectLoader(options || {}),
622
+ inputIterator,
623
+ options,
624
+ workerContext,
625
+ loaderContext
626
+ )
627
+ );
628
+ }
629
+ async function processLoaderWorkerData(loader, input, options = {}, workerContext, loaderContext = {}) {
630
+ const result = await parseData({
631
+ loader,
632
+ arrayBuffer: input,
633
+ options,
634
+ context: {
635
+ ...loaderContext,
636
+ reportProgress: workerContext?.reportProgress,
637
+ coreApi: createWorkerCoreApi(),
638
+ _parse: createParseOnMainThread(workerContext?.process)
639
+ }
640
+ });
641
+ return loader.serializeWorkerResult ? loader.serializeWorkerResult(result, options, loaderContext) : result;
642
+ }
643
+ async function* processLoaderWorkerBatches(loader, inputIterator, options = {}, workerContext, loaderContext = {}) {
644
+ if (!loader.parseInBatches) {
645
+ throw new Error(`${loader.id} loader does not support batched parsing`);
646
+ }
647
+ const parserOptions = getWorkerLoaderOptions(loader, options);
648
+ const resultIterator = loader.parseInBatches(inputIterator, parserOptions, {
649
+ ...loaderContext,
650
+ reportProgress: workerContext?.reportProgress,
651
+ coreApi: createWorkerCoreApi(),
652
+ _parse: createParseOnMainThread(workerContext?.process)
653
+ });
654
+ for await (const batch of resultIterator) {
655
+ yield loader.serializeWorkerBatch ? loader.serializeWorkerBatch(batch, options, loaderContext) : batch;
656
+ }
657
+ }
658
+ function createWorkerCoreApi() {
659
+ const unavailable = (methodName) => () => {
660
+ throw new Error(`context.coreApi.${methodName} is unavailable inside worker loaders.`);
661
+ };
662
+ return {
663
+ fetchFile: async (urlOrData, fetchOptions) => await fetch(urlOrData, fetchOptions),
664
+ parseSync: unavailable("parseSync"),
665
+ parse: unavailable("parse"),
666
+ parseFile: unavailable("parseFile"),
667
+ parseInBatches: unavailable("parseInBatches"),
668
+ load: unavailable("load"),
669
+ loadInBatches: unavailable("loadInBatches")
670
+ };
671
+ }
672
+ function createParseOnMainThread(processOnMainThread2) {
673
+ return (arrayBuffer, loaders, options, context) => {
674
+ if (!processOnMainThread2) {
675
+ throw new Error("Worker not set up to parse on main thread");
676
+ }
677
+ const parseArguments = getMainThreadParseArguments(loaders, options, context);
678
+ return processOnMainThread2(arrayBuffer, parseArguments.options, {
679
+ ...parseArguments.context,
680
+ ...Array.isArray(loaders) || loaders && isLoaderObject(loaders) ? {
681
+ _loaderIsArray: Array.isArray(loaders),
682
+ _loaderIds: (Array.isArray(loaders) ? loaders : [loaders]).map((loader) => loader.id)
683
+ } : {}
684
+ });
685
+ };
686
+ }
687
+ function getMainThreadParseArguments(loaders, options, context) {
688
+ if (options) {
689
+ return { options, context: getSerializableLoaderContext(context) };
690
+ }
691
+ if (Array.isArray(loaders) || loaders && isLoaderObject(loaders)) {
692
+ return { options: void 0, context: getSerializableLoaderContext(context) };
693
+ }
694
+ if (loaders && !Array.isArray(loaders)) {
695
+ return { options: loaders };
696
+ }
697
+ return { options: void 0, context: getSerializableLoaderContext(context) };
698
+ }
699
+ function isLoaderObject(value) {
700
+ return "id" in value && "extensions" in value;
701
+ }
702
+ function getSerializableLoaderContext(context) {
703
+ if (!context) {
704
+ return void 0;
705
+ }
706
+ const {
707
+ fetch: fetch2,
708
+ loaders,
709
+ coreApi,
710
+ signal,
711
+ reportProgress,
712
+ _parse,
713
+ _parseSync,
714
+ _parseInBatches,
715
+ ...serializableContext
716
+ } = context;
717
+ return JSON.parse(JSON.stringify(serializableContext));
718
+ }
719
+ async function parseData({
720
+ loader,
721
+ arrayBuffer,
722
+ options,
723
+ context
724
+ }) {
725
+ let data;
726
+ let parser;
727
+ if (loader.parse || loader.parseSync) {
728
+ data = arrayBuffer;
729
+ parser = loader.parse || loader.parseSync;
730
+ } else if (loader.parseTextSync) {
731
+ const textDecoder = new TextDecoder();
732
+ data = textDecoder.decode(arrayBuffer);
733
+ parser = loader.parseTextSync;
734
+ } else {
735
+ throw new Error(`Could not load data with ${loader.name} loader`);
736
+ }
737
+ options = getWorkerLoaderOptions(loader, options);
738
+ return await parser(data, { ...options }, context, loader);
739
+ }
740
+ function getWorkerLoaderOptions(loader, options) {
741
+ return {
742
+ ...options,
743
+ modules: { ...loader.options?.modules, ...options.modules },
744
+ core: { ...options.core, worker: false }
745
+ };
746
+ }
747
+
748
+ // src/workers/npy-worker.ts
749
+ createLoaderWorker(NPYLoaderWithParser);
750
+ })();