@loaders.gl/core 3.2.0-alpha.1 → 3.2.0-alpha.4

package/dist/dist.min.js

@@ -268,7 +268,7 @@
           this.worker = isBrowser2 ? this._createBrowserWorker() : this._createNodeWorker();
         }
         static isSupported() {
-          return typeof Worker !== "undefined" && isBrowser2;
+          return typeof Worker !== "undefined" && isBrowser2 || typeof Worker2 !== void 0;
         }
         destroy() {
           this.onMessage = NOOP;
@@ -385,9 +385,9 @@
             this.onDebug = props.onDebug;
           }
         }
-        async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        async startJob(name, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
           const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+            this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
             return this;
           });
           this._startQueuedJob();
@@ -516,7 +516,36 @@
     }
   });
 
+  // ../worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts
+  function removeNontransferableOptions(object) {
+    return JSON.parse(stringifyJSON(object));
+  }
+  function stringifyJSON(v) {
+    const cache3 = new Set();
+    return JSON.stringify(v, (key, value) => {
+      if (typeof value === "object" && value !== null) {
+        if (cache3.has(value)) {
+          try {
+            return JSON.parse(JSON.stringify(value));
+          } catch (err) {
+            return void 0;
+          }
+        }
+        cache3.add(value);
+      }
+      return value;
+    });
+  }
+  var init_remove_nontransferable_options = __esm({
+    "../worker-utils/src/lib/worker-utils/remove-nontransferable-options.ts"() {
+    }
+  });
+
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
+  }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
     const workerFile = `${worker.id}-worker.js`;
@@ -538,11 +567,64 @@
     assert2(url);
     return url;
   }
-  var NPM_TAG;
+  var NPM_TAG, VERSION2;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
+      init_version();
       NPM_TAG = "beta";
+      VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const { source } = options;
+    const workerPoolProps = { name, source };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
+    }
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const transferableOptions = removeNontransferableOptions(options);
+    job.postMessage("process", { input: data, options: transferableOptions });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          if (!context.process) {
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+            return;
+          }
+          const result = await context.process(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
+    }
+  }
+  var init_process_on_worker = __esm({
+    "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
+      init_worker_farm();
+      init_remove_nontransferable_options();
+      init_get_worker_url();
     }
   });
 
@@ -568,6 +650,7 @@
       init_assert2();
       init_globals2();
       init_worker_farm();
+      init_process_on_worker();
       init_get_worker_url();
       init_validate_worker_version();
     }
@@ -589,15 +672,17 @@
     const workerFarm = WorkerFarm.getWorkerFarm(options);
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
-    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
+    context = JSON.parse(JSON.stringify(context || {}));
+    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
-      options
+      options,
+      context
     });
     const result = await job.result;
     return await result.result;
   }
-  async function onMessage(parseOnMainThread, job, type, payload) {
+  async function onMessage2(parseOnMainThread, job, type, payload) {
     switch (type) {
       case "done":
         job.done(payload);
@@ -626,6 +711,23 @@
     }
   });
 
+  // ../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts
+  function canEncodeWithWorker(writer, options) {
+    if (!WorkerFarm.isSupported()) {
+      return false;
+    }
+    if (!isBrowser && !options?._nodeWorkers) {
+      return false;
+    }
+    return writer.worker && options?.worker;
+  }
+  var init_encode_with_worker = __esm({
+    "../loader-utils/src/lib/worker-loader-utils/encode-with-worker.ts"() {
+      init_src();
+      init_globals();
+    }
+  });
+
   // (disabled):../loader-utils/src/lib/node/buffer
   var init_buffer = __esm({
     "(disabled):../loader-utils/src/lib/node/buffer"() {
@@ -1147,15 +1249,15 @@
   function parseTextSync(text) {
     return JSON.parse(text);
   }
-  var VERSION2, JSONLoader;
+  var VERSION3, JSONLoader;
   var init_json_loader = __esm({
     "../loader-utils/src/json-loader.ts"() {
-      VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       JSONLoader = {
         name: "JSON",
         id: "json",
         module: "json",
-        version: VERSION2,
+        version: VERSION3,
         extensions: ["json", "geojson"],
         mimeTypes: ["application/json"],
         category: "json",
@@ -1213,6 +1315,7 @@
       init_assert();
       init_globals();
       init_parse_with_worker();
+      init_encode_with_worker();
       init_array_buffer_utils();
       init_text_iterators();
       init_async_iteration();
@@ -1369,7 +1472,7 @@
         text += ` ${await response.text()}`;
       }
       message += text;
-      message = message.length > 60 ? `${message.slice(60)}...` : message;
+      message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
     } catch (error) {
     }
     return message;
@@ -1545,12 +1648,12 @@
   });
 
   // ../../node_modules/probe.gl/dist/esm/utils/globals.js
-  var VERSION3, isBrowser4;
+  var VERSION4, isBrowser4;
   var init_globals4 = __esm({
     "../../node_modules/probe.gl/dist/esm/utils/globals.js"() {
       init_is_browser();
       init_globals3();
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
@@ -1872,7 +1975,7 @@
           id: ""
         }) {
           this.id = id;
-          this.VERSION = VERSION3;
+          this.VERSION = VERSION4;
           this._startTs = getHiResTimestamp2();
           this._deltaTs = getHiResTimestamp2();
           this.LOG_THROTTLE_TIMEOUT = 0;
@@ -2068,7 +2171,7 @@
           return noop;
         }
       };
-      Log.VERSION = VERSION3;
+      Log.VERSION = VERSION4;
     }
   });
 
@@ -2324,12 +2427,10 @@
     }
   });
 
-  // src/lib/api/set-loader-options.ts
-  function setLoaderOptions(options) {
-    setGlobalOptions(options);
-  }
-  var init_set_loader_options = __esm({
-    "src/lib/api/set-loader-options.ts"() {
+  // src/lib/api/loader-options.ts
+  var init_loader_options = __esm({
+    "src/lib/api/loader-options.ts"() {
+      init_option_utils();
       init_option_utils();
     }
   });
@@ -2452,11 +2553,11 @@
   });
 
   // ../../node_modules/@probe.gl/env/dist/esm/utils/globals.js
-  var VERSION4, isBrowser6;
+  var VERSION5, isBrowser6;
   var init_globals6 = __esm({
     "../../node_modules/@probe.gl/env/dist/esm/utils/globals.js"() {
       init_is_browser2();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser6 = isBrowser5();
     }
   });
@@ -2803,7 +2904,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION4);
+          _defineProperty(this, "VERSION", VERSION5);
           _defineProperty(this, "_startTs", getHiResTimestamp4());
           _defineProperty(this, "_deltaTs", getHiResTimestamp4());
           _defineProperty(this, "_storage", void 0);
@@ -3009,7 +3110,7 @@
           return noop2;
         }
       };
-      _defineProperty(Log2, "VERSION", VERSION4);
+      _defineProperty(Log2, "VERSION", VERSION5);
     }
   });
 
@@ -3505,6 +3606,12 @@
   }
   async function parseWithLoader(loader, data, options, context) {
     validateWorkerVersion(loader);
+    if (isResponse(data)) {
+      const response = data;
+      const { ok, redirected, status, statusText, type, url } = response;
+      const headers = Object.fromEntries(response.headers.entries());
+      context.response = { headers, ok, redirected, status, statusText, type, url };
+    }
     data = await getArrayBufferOrStringFromData(data, loader, options);
     if (loader.parseTextSync && typeof data === "string") {
       options.dataType = "text";
@@ -3527,6 +3634,7 @@
       init_src();
       init_src2();
       init_normalize_loader();
+      init_is_type();
       init_option_utils();
       init_get_data();
       init_loader_context();
@@ -3717,6 +3825,11 @@
 
   // src/lib/api/encode.ts
   async function encode(data, writer, options) {
+    const globalOptions = getGlobalLoaderOptions();
+    options = { ...globalOptions, ...options };
+    if (canEncodeWithWorker(writer, options)) {
+      return await processOnWorker(writer, data, options);
+    }
     if (writer.encode) {
       return await writer.encode(data, options);
     }
@@ -3785,10 +3898,13 @@
   }
   var init_encode = __esm({
     "src/lib/api/encode.ts"() {
+      init_src2();
+      init_src();
       init_src2();
       init_src2();
       init_write_file();
       init_fetch_file();
+      init_loader_options();
     }
   });
 
@@ -3839,15 +3955,21 @@
   });
 
   // src/null-loader.ts
-  var VERSION5, NullWorkerLoader, NullLoader;
+  function parseSync2(arrayBuffer, options, context) {
+    if (!options.null.echoParameters)
+      return null;
+    context = context && JSON.parse(JSON.stringify(context));
+    return { arrayBuffer, options, context };
+  }
+  var VERSION6, NullWorkerLoader, NullLoader;
   var init_null_loader = __esm({
     "src/null-loader.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       NullWorkerLoader = {
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION6,
         worker: true,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
@@ -3860,19 +3982,21 @@
         name: "Null loader",
         id: "null",
         module: "core",
-        version: VERSION5,
+        version: VERSION6,
         mimeTypes: ["application/x.empty"],
         extensions: ["null"],
-        parse: async (arrayBuffer) => arrayBuffer,
-        parseSync: (arrayBuffer) => arrayBuffer,
-        parseInBatches: async function* generator(asyncIterator) {
+        parse: async (arrayBuffer, options, context) => parseSync2(arrayBuffer, options, context),
+        parseSync: parseSync2,
+        parseInBatches: async function* generator(asyncIterator, options, context) {
           for await (const batch of asyncIterator) {
-            yield batch;
+            yield parseSync2(batch, options, context);
           }
         },
         tests: [() => false],
         options: {
-          null: {}
+          null: {
+            echoParameters: false
+          }
         }
       };
     }
@@ -4031,6 +4155,7 @@
     encodeURLtoURL: () => encodeURLtoURL,
     fetchFile: () => fetchFile,
     forEach: () => forEach,
+    getLoaderOptions: () => getGlobalLoaderOptions,
     getPathPrefix: () => getPathPrefix,
     global: () => global_,
     isAsyncIterable: () => isAsyncIterable,
@@ -4063,7 +4188,7 @@
     selectLoader: () => selectLoader,
     selectLoaderSync: () => selectLoaderSync,
     self: () => self_,
-    setLoaderOptions: () => setLoaderOptions,
+    setLoaderOptions: () => setGlobalOptions,
     setPathPrefix: () => setPathPrefix,
     window: () => window_,
     writeFile: () => writeFile,
@@ -4075,7 +4200,7 @@
       init_read_array_buffer();
       init_read_file();
       init_write_file();
-      init_set_loader_options();
+      init_loader_options();
       init_register_loaders();
       init_select_loader();
       init_parse();

package/dist/es5/index.js

@@ -38,7 +38,13 @@ Object.defineProperty(exports, "writeFileSync", {
 Object.defineProperty(exports, "setLoaderOptions", {
   enumerable: true,
   get: function get() {
-    return _setLoaderOptions.setLoaderOptions;
+    return _loaderOptions.setLoaderOptions;
+  }
+});
+Object.defineProperty(exports, "getLoaderOptions", {
+  enumerable: true,
+  get: function get() {
+    return _loaderOptions.getLoaderOptions;
   }
 });
 Object.defineProperty(exports, "registerLoaders", {
@@ -338,7 +344,7 @@ var _readFile = require("./lib/fetch/read-file");
 
 var _writeFile = require("./lib/fetch/write-file");
 
-var _setLoaderOptions = require("./lib/api/set-loader-options");
+var _loaderOptions = require("./lib/api/loader-options");
 
 var _registerLoaders = require("./lib/api/register-loaders");
 

package/dist/es5/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions} from './lib/api/set-loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"file":"index.js"}
+{"version":3,"sources":["../../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAEA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AAGA;;AAIA;;AACA;;AAGA;;AAIA;;AACA;;AAqBA","sourcesContent":["// FILE READING AND WRITING\nexport {fetchFile} from './lib/fetch/fetch-file';\n\nexport {readArrayBuffer} from './lib/fetch/read-array-buffer';\nexport {readFileSync} from './lib/fetch/read-file';\nexport {writeFile, writeFileSync} from './lib/fetch/write-file';\n\n// CONFIGURATION\nexport {setLoaderOptions, getLoaderOptions} from './lib/api/loader-options';\nexport {registerLoaders} from './lib/api/register-loaders';\nexport {selectLoader, selectLoaderSync} from './lib/api/select-loader';\n\n// LOADING (READING + PARSING)\nexport {parse} from './lib/api/parse';\nexport {parseSync} from './lib/api/parse-sync';\nexport {parseInBatches} from './lib/api/parse-in-batches';\n\nexport {load} from './lib/api/load';\nexport {loadInBatches} from './lib/api/load-in-batches';\n\n// ENCODING (ENCODING AND WRITING)\nexport {encode, encodeSync, encodeInBatches, encodeText, encodeURLtoURL} from './lib/api/encode';\nexport {save, saveSync} from './lib/api/save';\n\n// CORE UTILS SHARED WITH LOADERS (RE-EXPORTED FROM LOADER-UTILS)\nexport {setPathPrefix, getPathPrefix, resolvePath} from '@loaders.gl/loader-utils';\nexport {RequestScheduler} from '@loaders.gl/loader-utils';\n\n// ITERATOR UTILS\nexport {makeIterator} from './iterators/make-iterator/make-iterator';\nexport {makeStream} from './iterators/make-stream/make-node-stream';\n\n// CORE LOADERS\nexport {NullWorkerLoader, NullLoader} from './null-loader';\nexport {JSONLoader} from '@loaders.gl/loader-utils';\n\n// EXPERIMENTAL\nexport {default as _fetchProgress} from './lib/progress/fetch-progress';\nexport {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';\n\n// FOR TESTING\nexport {_unregisterLoaders} from './lib/api/register-loaders';\n\n//\n// TODO - MOVE TO LOADER-UTILS AND DEPRECATE IN CORE?\n//\n\nexport {isBrowser, isWorker, self, window, global, document} from '@loaders.gl/loader-utils';\nexport {assert} from '@loaders.gl/loader-utils';\nexport {forEach, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';\n\nexport {\n  makeTextDecoderIterator,\n  makeTextEncoderIterator,\n  makeLineIterator,\n  makeNumberedLineIterator\n} from '@loaders.gl/loader-utils';\n\n// \"JAVASCRIPT\" UTILS - move to loader-utils?\nexport {\n  isPureObject,\n  isPromise,\n  isIterable,\n  isAsyncIterable,\n  isIterator,\n  isResponse,\n  isReadableStream,\n  isWritableStream\n} from './javascript-utils/is-type';\n"],"file":"index.js"}