@loaders.gl/worker-utils 3.1.3 → 4.0.0-alpha.5

package/dist/lib/process-utils/process-utils.js

@@ -1,35 +1,29 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAvailablePort = void 0;
-const child_process_1 = __importDefault(require("child_process"));
-// Get an available port
-// Works on Unix systems
-function getAvailablePort(defaultPort = 3000) {
-    return new Promise((resolve) => {
-        // Get a list of all ports in use
-        child_process_1.default.exec('lsof -i -P -n | grep LISTEN', (error, stdout) => {
-            if (error) {
-                // likely no permission, e.g. CI
-                resolve(defaultPort);
-                return;
-            }
-            const portsInUse = [];
-            const regex = /:(\d+) \(LISTEN\)/;
-            stdout.split('\n').forEach((line) => {
-                const match = regex.exec(line);
-                if (match) {
-                    portsInUse.push(Number(match[1]));
-                }
-            });
-            let port = defaultPort;
-            while (portsInUse.includes(port)) {
-                port++;
-            }
-            resolve(port);
-        });
+import ChildProcess from 'child_process';
+export function getAvailablePort(defaultPort = 3000) {
+  return new Promise(resolve => {
+    ChildProcess.exec('lsof -i -P -n | grep LISTEN', (error, stdout) => {
+      if (error) {
+        resolve(defaultPort);
+        return;
+      }
+
+      const portsInUse = [];
+      const regex = /:(\d+) \(LISTEN\)/;
+      stdout.split('\n').forEach(line => {
+        const match = regex.exec(line);
+
+        if (match) {
+          portsInUse.push(Number(match[1]));
+        }
+      });
+      let port = defaultPort;
+
+      while (portsInUse.includes(port)) {
+        port++;
+      }
+
+      resolve(port);
     });
+  });
 }
-exports.getAvailablePort = getAvailablePort;
+//# sourceMappingURL=process-utils.js.map

package/dist/lib/process-utils/process-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/process-utils/process-utils.ts"],"names":["ChildProcess","getAvailablePort","defaultPort","Promise","resolve","exec","error","stdout","portsInUse","regex","split","forEach","line","match","push","Number","port","includes"],"mappings":"AAAA,OAAOA,YAAP,MAAyB,eAAzB;AAIA,OAAO,SAASC,gBAAT,CAA0BC,WAAmB,GAAG,IAAhD,EAAuE;AAC5E,SAAO,IAAIC,OAAJ,CAAaC,OAAD,IAAa;AAE9BJ,IAAAA,YAAY,CAACK,IAAb,CAAkB,6BAAlB,EAAiD,CAACC,KAAD,EAAQC,MAAR,KAAmB;AAClE,UAAID,KAAJ,EAAW;AAETF,QAAAA,OAAO,CAACF,WAAD,CAAP;AACA;AACD;;AAED,YAAMM,UAAoB,GAAG,EAA7B;AACA,YAAMC,KAAK,GAAG,mBAAd;AACAF,MAAAA,MAAM,CAACG,KAAP,CAAa,IAAb,EAAmBC,OAAnB,CAA4BC,IAAD,IAAU;AACnC,cAAMC,KAAK,GAAGJ,KAAK,CAACJ,IAAN,CAAWO,IAAX,CAAd;;AACA,YAAIC,KAAJ,EAAW;AACTL,UAAAA,UAAU,CAACM,IAAX,CAAgBC,MAAM,CAACF,KAAK,CAAC,CAAD,CAAN,CAAtB;AACD;AACF,OALD;AAMA,UAAIG,IAAI,GAAGd,WAAX;;AACA,aAAOM,UAAU,CAACS,QAAX,CAAoBD,IAApB,CAAP,EAAkC;AAChCA,QAAAA,IAAI;AACL;;AACDZ,MAAAA,OAAO,CAACY,IAAD,CAAP;AACD,KApBD;AAqBD,GAvBM,CAAP;AAwBD","sourcesContent":["import ChildProcess from 'child_process';\n\n// Get an available port\n// Works on Unix systems\nexport function getAvailablePort(defaultPort: number = 3000): Promise<number> {\n  return new Promise((resolve) => {\n    // Get a list of all ports in use\n    ChildProcess.exec('lsof -i -P -n | grep LISTEN', (error, stdout) => {\n      if (error) {\n        // likely no permission, e.g. CI\n        resolve(defaultPort);\n        return;\n      }\n\n      const portsInUse: number[] = [];\n      const regex = /:(\\d+) \\(LISTEN\\)/;\n      stdout.split('\\n').forEach((line) => {\n        const match = regex.exec(line);\n        if (match) {\n          portsInUse.push(Number(match[1]));\n        }\n      });\n      let port = defaultPort;\n      while (portsInUse.includes(port)) {\n        port++;\n      }\n      resolve(port);\n    });\n  });\n}\n"],"file":"process-utils.js"}

package/dist/lib/worker-api/create-worker.js

@@ -1,92 +1,99 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createWorker = void 0;
-const async_queue_1 = __importDefault(require("../async-queue/async-queue"));
-const worker_body_1 = __importDefault(require("../worker-farm/worker-body"));
-// import {validateWorkerVersion} from './validate-worker-version.js';
-/** Counter for jobs */
+import AsyncQueue from '../async-queue/async-queue';
+import WorkerBody from '../worker-farm/worker-body';
 let requestId = 0;
 let inputBatches;
 let options;
-/**
- * Set up a WebWorkerGlobalScope to talk with the main thread
- */
-function createWorker(process, processInBatches) {
-    // Check that we are actually in a worker thread
-    if (typeof self === 'undefined') {
-        return;
+export function createWorker(process, processInBatches) {
+  if (typeof self === 'undefined') {
+    return;
+  }
+
+  const context = {
+    process: processOnMainThread
+  };
+
+  WorkerBody.onmessage = async (type, payload) => {
+    try {
+      switch (type) {
+        case 'process':
+          if (!process) {
+            throw new Error('Worker does not support atomic processing');
+          }
+
+          const result = await process(payload.input, payload.options || {}, context);
+          WorkerBody.postMessage('done', {
+            result
+          });
+          break;
+
+        case 'process-in-batches':
+          if (!processInBatches) {
+            throw new Error('Worker does not support batched processing');
+          }
+
+          inputBatches = new AsyncQueue();
+          options = payload.options || {};
+          const resultIterator = processInBatches(inputBatches, options, context);
+
+          for await (const batch of resultIterator) {
+            WorkerBody.postMessage('output-batch', {
+              result: batch
+            });
+          }
+
+          WorkerBody.postMessage('done', {});
+          break;
+
+        case 'input-batch':
+          inputBatches.push(payload.input);
+          break;
+
+        case 'input-done':
+          inputBatches.close();
+          break;
+
+        default:
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : '';
+      WorkerBody.postMessage('error', {
+        error: message
+      });
     }
-    const context = {
-        process: processOnMainThread
-    };
-    // eslint-disable-next-line complexity
-    worker_body_1.default.onmessage = async (type, payload) => {
-        try {
-            switch (type) {
-                case 'process':
-                    if (!process) {
-                        throw new Error('Worker does not support atomic processing');
-                    }
-                    const result = await process(payload.input, payload.options || {}, context);
-                    worker_body_1.default.postMessage('done', { result });
-                    break;
-                case 'process-in-batches':
-                    if (!processInBatches) {
-                        throw new Error('Worker does not support batched processing');
-                    }
-                    inputBatches = new async_queue_1.default();
-                    options = payload.options || {};
-                    const resultIterator = processInBatches(inputBatches, options, context);
-                    for await (const batch of resultIterator) {
-                        worker_body_1.default.postMessage('output-batch', { result: batch });
-                    }
-                    worker_body_1.default.postMessage('done', {});
-                    break;
-                case 'input-batch':
-                    inputBatches.push(payload.input);
-                    break;
-                case 'input-done':
-                    inputBatches.close();
-                    break;
-                default:
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : '';
-            worker_body_1.default.postMessage('error', { error: message });
-        }
-    };
+  };
 }
-exports.createWorker = createWorker;
+
 function processOnMainThread(arrayBuffer, options = {}) {
-    return new Promise((resolve, reject) => {
-        const id = requestId++;
-        /**
-         */
-        const onMessage = (type, payload) => {
-            if (payload.id !== id) {
-                // not ours
-                return;
-            }
-            switch (type) {
-                case 'done':
-                    worker_body_1.default.removeEventListener(onMessage);
-                    resolve(payload.result);
-                    break;
-                case 'error':
-                    worker_body_1.default.removeEventListener(onMessage);
-                    reject(payload.error);
-                    break;
-                default:
-                // ignore
-            }
-        };
-        worker_body_1.default.addEventListener(onMessage);
-        // Ask the main thread to decode data
-        const payload = { id, input: arrayBuffer, options };
-        worker_body_1.default.postMessage('process', payload);
-    });
+  return new Promise((resolve, reject) => {
+    const id = requestId++;
+
+    const onMessage = (type, payload) => {
+      if (payload.id !== id) {
+        return;
+      }
+
+      switch (type) {
+        case 'done':
+          WorkerBody.removeEventListener(onMessage);
+          resolve(payload.result);
+          break;
+
+        case 'error':
+          WorkerBody.removeEventListener(onMessage);
+          reject(payload.error);
+          break;
+
+        default:
+      }
+    };
+
+    WorkerBody.addEventListener(onMessage);
+    const payload = {
+      id,
+      input: arrayBuffer,
+      options
+    };
+    WorkerBody.postMessage('process', payload);
+  });
 }
+//# sourceMappingURL=create-worker.js.map

package/dist/lib/worker-api/create-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/worker-api/create-worker.ts"],"names":["AsyncQueue","WorkerBody","requestId","inputBatches","options","createWorker","process","processInBatches","self","context","processOnMainThread","onmessage","type","payload","Error","result","input","postMessage","resultIterator","batch","push","close","error","message","arrayBuffer","Promise","resolve","reject","id","onMessage","removeEventListener","addEventListener"],"mappings":"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","sourcesContent":["import type {\n  WorkerMessageType,\n  WorkerMessagePayload,\n  WorkerContext,\n  Process,\n  ProcessInBatches\n} from '../../types';\nimport AsyncQueue from '../async-queue/async-queue';\nimport WorkerBody from '../worker-farm/worker-body';\n// import {validateWorkerVersion} from './validate-worker-version';\n\n/** Counter for jobs */\nlet requestId = 0;\nlet inputBatches: AsyncQueue<any>;\nlet options: {[key: string]: any};\n\nexport type ProcessOnMainThread = (\n  data: any,\n  options?: {[key: string]: any},\n  context?: WorkerContext\n) => any;\n\n/**\n * Set up a WebWorkerGlobalScope to talk with the main thread\n */\nexport function createWorker(process: Process, processInBatches?: ProcessInBatches): void {\n  // Check that we are actually in a worker thread\n  if (typeof self === 'undefined') {\n    return;\n  }\n\n  const context: WorkerContext = {\n    process: processOnMainThread\n  };\n\n  // eslint-disable-next-line complexity\n  WorkerBody.onmessage = async (type: WorkerMessageType, payload: WorkerMessagePayload) => {\n    try {\n      switch (type) {\n        case 'process':\n          if (!process) {\n            throw new Error('Worker does not support atomic processing');\n          }\n          const result = await process(payload.input, payload.options || {}, context);\n          WorkerBody.postMessage('done', {result});\n          break;\n\n        case 'process-in-batches':\n          if (!processInBatches) {\n            throw new Error('Worker does not support batched processing');\n          }\n          inputBatches = new AsyncQueue<any>();\n          options = payload.options || {};\n          const resultIterator = processInBatches(inputBatches, options, context);\n          for await (const batch of resultIterator) {\n            WorkerBody.postMessage('output-batch', {result: batch});\n          }\n          WorkerBody.postMessage('done', {});\n          break;\n\n        case 'input-batch':\n          inputBatches.push(payload.input);\n          break;\n\n        case 'input-done':\n          inputBatches.close();\n          break;\n\n        default:\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : '';\n      WorkerBody.postMessage('error', {error: message});\n    }\n  };\n}\n\nfunction processOnMainThread(arrayBuffer: ArrayBuffer, options = {}) {\n  return new Promise((resolve, reject) => {\n    const id = requestId++;\n\n    /**\n     */\n    const onMessage = (type: string, payload: WorkerMessagePayload) => {\n      if (payload.id !== id) {\n        // not ours\n        return;\n      }\n\n      switch (type) {\n        case 'done':\n          WorkerBody.removeEventListener(onMessage);\n          resolve(payload.result);\n          break;\n\n        case 'error':\n          WorkerBody.removeEventListener(onMessage);\n          reject(payload.error);\n          break;\n\n        default:\n        // ignore\n      }\n    };\n\n    WorkerBody.addEventListener(onMessage);\n\n    // Ask the main thread to decode data\n    const payload = {id, input: arrayBuffer, options};\n    WorkerBody.postMessage('process', payload);\n  });\n}\n"],"file":"create-worker.js"}

package/dist/lib/worker-api/get-worker-url.js

@@ -1,57 +1,36 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getWorkerURL = exports.getWorkerName = void 0;
-const assert_1 = require("../env-utils/assert");
-const version_1 = require("../env-utils/version");
-const NPM_TAG = 'latest'; // Change to 'latest' on release-branch
-const VERSION = typeof version_1.VERSION !== 'undefined' ? version_1.VERSION : NPM_TAG;
-/**
- * Gets worker object's name (for debugging in Chrome thread inspector window)
- */
-function getWorkerName(worker) {
-    const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : '';
-    return `${worker.name}@${worker.version}${warning}`;
+import { assert } from '../env-utils/assert';
+import { VERSION as __VERSION__ } from '../env-utils/version';
+const NPM_TAG = 'beta';
+const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : NPM_TAG;
+export function getWorkerName(worker) {
+  const warning = worker.version !== VERSION ? " (worker-utils@".concat(VERSION, ")") : '';
+  return "".concat(worker.name, "@").concat(worker.version).concat(warning);
 }
-exports.getWorkerName = getWorkerName;
-/**
- * Generate a worker URL based on worker object and options
- * @returns A URL to one of the following:
- * - a published worker on unpkg CDN
- * - a local test worker
- * - a URL provided by the user in options
- */
-function getWorkerURL(worker, options = {}) {
-    const workerOptions = options[worker.id] || {};
-    const workerFile = `${worker.id}-worker.js`;
-    let url = workerOptions.workerUrl;
-    // HACK: Allow for non-nested workerUrl for the CompressionWorker.
-    // For the compression worker, workerOptions is currently not nested correctly. For most loaders,
-    // you'd have options within an object, i.e. `{mvt: {coordinates: ...}}` but the CompressionWorker
-    // puts options at the top level, not within a `compression` key (its `id`). For this reason, the
-    // above `workerOptions` will always be a string (i.e. `'gzip'`) for the CompressionWorker. To not
-    // break backwards compatibility, we allow the CompressionWorker to have options at the top level.
-    if (!url && worker.id === 'compression') {
-        url = options.workerUrl;
+export function getWorkerURL(worker, options = {}) {
+  const workerOptions = options[worker.id] || {};
+  const workerFile = "".concat(worker.id, "-worker.js");
+  let url = workerOptions.workerUrl;
+
+  if (!url && worker.id === 'compression') {
+    url = options.workerUrl;
+  }
+
+  if (options._workerType === 'test') {
+    url = "modules/".concat(worker.module, "/dist/").concat(workerFile);
+  }
+
+  if (!url) {
+    let version = worker.version;
+
+    if (version === 'latest') {
+      version = NPM_TAG;
     }
-    // If URL is test, generate local loaders.gl url
-    // @ts-ignore _workerType
-    if (options._workerType === 'test') {
-        url = `modules/${worker.module}/dist/${workerFile}`;
-    }
-    // If url override is not provided, generate a URL to published version on npm CDN unpkg.com
-    if (!url) {
-        // GENERATE
-        let version = worker.version;
-        // On master we need to load npm alpha releases published with the `beta` tag
-        if (version === 'latest') {
-            // throw new Error('latest worker version specified');
-            version = NPM_TAG;
-        }
-        const versionTag = version ? `@${version}` : '';
-        url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;
-    }
-    (0, assert_1.assert)(url);
-    // Allow user to override location
-    return url;
+
+    const versionTag = version ? "@".concat(version) : '';
+    url = "https://unpkg.com/@loaders.gl/".concat(worker.module).concat(versionTag, "/dist/").concat(workerFile);
+  }
+
+  assert(url);
+  return url;
 }
-exports.getWorkerURL = getWorkerURL;
+//# sourceMappingURL=get-worker-url.js.map

package/dist/lib/worker-api/get-worker-url.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/worker-api/get-worker-url.ts"],"names":["assert","VERSION","__VERSION__","NPM_TAG","getWorkerName","worker","warning","version","name","getWorkerURL","options","workerOptions","id","workerFile","url","workerUrl","_workerType","module","versionTag"],"mappings":"AACA,SAAQA,MAAR,QAAqB,qBAArB;AACA,SAAQC,OAAO,IAAIC,WAAnB,QAAqC,sBAArC;AAEA,MAAMC,OAAO,GAAG,MAAhB;AACA,MAAMF,OAAO,GAAG,2BAAuB,WAAvB,qBAAmDE,OAAnE;AAKA,OAAO,SAASC,aAAT,CAAuBC,MAAvB,EAAqD;AAC1D,QAAMC,OAAO,GAAGD,MAAM,CAACE,OAAP,KAAmBN,OAAnB,4BAA+CA,OAA/C,SAA4D,EAA5E;AACA,mBAAUI,MAAM,CAACG,IAAjB,cAAyBH,MAAM,CAACE,OAAhC,SAA0CD,OAA1C;AACD;AASD,OAAO,SAASG,YAAT,CAAsBJ,MAAtB,EAA4CK,OAAsB,GAAG,EAArE,EAAiF;AACtF,QAAMC,aAAa,GAAGD,OAAO,CAACL,MAAM,CAACO,EAAR,CAAP,IAAsB,EAA5C;AAEA,QAAMC,UAAU,aAAMR,MAAM,CAACO,EAAb,eAAhB;AAEA,MAAIE,GAAG,GAAGH,aAAa,CAACI,SAAxB;;AAQA,MAAI,CAACD,GAAD,IAAQT,MAAM,CAACO,EAAP,KAAc,aAA1B,EAAyC;AACvCE,IAAAA,GAAG,GAAGJ,OAAO,CAACK,SAAd;AACD;;AAID,MAAIL,OAAO,CAACM,WAAR,KAAwB,MAA5B,EAAoC;AAClCF,IAAAA,GAAG,qBAAcT,MAAM,CAACY,MAArB,mBAAoCJ,UAApC,CAAH;AACD;;AAGD,MAAI,CAACC,GAAL,EAAU;AAER,QAAIP,OAAO,GAAGF,MAAM,CAACE,OAArB;;AAEA,QAAIA,OAAO,KAAK,QAAhB,EAA0B;AAExBA,MAAAA,OAAO,GAAGJ,OAAV;AACD;;AACD,UAAMe,UAAU,GAAGX,OAAO,cAAOA,OAAP,IAAmB,EAA7C;AACAO,IAAAA,GAAG,2CAAoCT,MAAM,CAACY,MAA3C,SAAoDC,UAApD,mBAAuEL,UAAvE,CAAH;AACD;;AAEDb,EAAAA,MAAM,CAACc,GAAD,CAAN;AAGA,SAAOA,GAAP;AACD","sourcesContent":["import type {WorkerObject, WorkerOptions} from '../../types';\nimport {assert} from '../env-utils/assert';\nimport {VERSION as __VERSION__} from '../env-utils/version';\n\nconst NPM_TAG = 'beta'; // Change to 'latest' on release-branch\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : NPM_TAG;\n\n/**\n * Gets worker object's name (for debugging in Chrome thread inspector window)\n */\nexport function getWorkerName(worker: WorkerObject): string {\n  const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : '';\n  return `${worker.name}@${worker.version}${warning}`;\n}\n\n/**\n * Generate a worker URL based on worker object and options\n * @returns A URL to one of the following:\n * - a published worker on unpkg CDN\n * - a local test worker\n * - a URL provided by the user in options\n */\nexport function getWorkerURL(worker: WorkerObject, options: WorkerOptions = {}): string {\n  const workerOptions = options[worker.id] || {};\n\n  const workerFile = `${worker.id}-worker.js`;\n\n  let url = workerOptions.workerUrl;\n\n  // HACK: Allow for non-nested workerUrl for the CompressionWorker.\n  // For the compression worker, workerOptions is currently not nested correctly. For most loaders,\n  // you'd have options within an object, i.e. `{mvt: {coordinates: ...}}` but the CompressionWorker\n  // puts options at the top level, not within a `compression` key (its `id`). For this reason, the\n  // above `workerOptions` will always be a string (i.e. `'gzip'`) for the CompressionWorker. To not\n  // break backwards compatibility, we allow the CompressionWorker to have options at the top level.\n  if (!url && worker.id === 'compression') {\n    url = options.workerUrl;\n  }\n\n  // If URL is test, generate local loaders.gl url\n  // @ts-ignore _workerType\n  if (options._workerType === 'test') {\n    url = `modules/${worker.module}/dist/${workerFile}`;\n  }\n\n  // If url override is not provided, generate a URL to published version on npm CDN unpkg.com\n  if (!url) {\n    // GENERATE\n    let version = worker.version;\n    // On master we need to load npm alpha releases published with the `beta` tag\n    if (version === 'latest') {\n      // throw new Error('latest worker version specified');\n      version = NPM_TAG;\n    }\n    const versionTag = version ? `@${version}` : '';\n    url = `https://unpkg.com/@loaders.gl/${worker.module}${versionTag}/dist/${workerFile}`;\n  }\n\n  assert(url);\n\n  // Allow user to override location\n  return url;\n}\n"],"file":"get-worker-url.js"}

package/dist/lib/worker-api/process-on-worker.js

@@ -1,79 +1,75 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.processOnWorker = exports.canProcessOnWorker = void 0;
-const worker_farm_1 = __importDefault(require("../worker-farm/worker-farm"));
-const remove_nontransferable_options_1 = require("../worker-utils/remove-nontransferable-options");
-const get_worker_url_1 = require("./get-worker-url");
-/**
- * Determines if we can parse with worker
- * @param loader
- * @param data
- * @param options
- */
-function canProcessOnWorker(worker, options) {
-    if (!worker_farm_1.default.isSupported()) {
-        return false;
-    }
-    return worker.worker && options?.worker;
+import WorkerFarm from '../worker-farm/worker-farm';
+import { removeNontransferableOptions } from '../worker-utils/remove-nontransferable-options';
+import { getWorkerURL, getWorkerName } from './get-worker-url';
+export function canProcessOnWorker(worker, options) {
+  if (!WorkerFarm.isSupported()) {
+    return false;
+  }
+
+  return worker.worker && (options === null || options === void 0 ? void 0 : options.worker);
 }
-exports.canProcessOnWorker = canProcessOnWorker;
-/**
- * This function expects that the worker thread sends certain messages,
- * Creating such a worker can be automated if the worker is wrapper by a call to
- * createWorker in @loaders.gl/worker-utils.
- */
-async function processOnWorker(worker, data, options = {}, context = {}) {
-    const name = (0, get_worker_url_1.getWorkerName)(worker);
-    const url = (0, get_worker_url_1.getWorkerURL)(worker, options);
-    const workerFarm = worker_farm_1.default.getWorkerFarm(options);
-    const workerPool = workerFarm.getWorkerPool({ name, url });
-    const jobName = options.jobName || worker.name;
-    const job = await workerPool.startJob(jobName, 
-    // eslint-disable-next-line
-    onMessage.bind(null, context));
-    // Kick off the processing in the worker
-    const transferableOptions = (0, remove_nontransferable_options_1.removeNontransferableOptions)(options);
-    job.postMessage('process', { input: data, options: transferableOptions });
-    const result = await job.result;
-    return result.result;
+export async function processOnWorker(worker, data, options = {}, context = {}) {
+  const name = getWorkerName(worker);
+  const url = getWorkerURL(worker, options);
+  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerPool = workerFarm.getWorkerPool({
+    name,
+    url
+  });
+  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;
 }
-exports.processOnWorker = processOnWorker;
-/**
- * Job completes when we receive the result
- * @param job
- * @param message
- */
+
 async function onMessage(context, job, type, payload) {
-    switch (type) {
-        case 'done':
-            // Worker is done
-            job.done(payload);
-            break;
-        case 'error':
-            // Worker encountered an error
-            job.error(new Error(payload.error));
-            break;
-        case 'process':
-            // Worker is asking for us (main thread) to process something
-            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:
-            // eslint-disable-next-line
-            console.warn(`process-on-worker: unknown message ${type}`);
-    }
+  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 ".concat(type));
+  }
 }
+//# sourceMappingURL=process-on-worker.js.map

package/dist/lib/worker-api/process-on-worker.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/worker-api/process-on-worker.ts"],"names":["WorkerFarm","removeNontransferableOptions","getWorkerURL","getWorkerName","canProcessOnWorker","worker","options","isSupported","processOnWorker","data","context","name","url","workerFarm","getWorkerFarm","workerPool","getWorkerPool","jobName","job","startJob","onMessage","bind","transferableOptions","postMessage","input","result","type","payload","done","error","Error","id","process","message","console","warn"],"mappings":"AAQA,OAAOA,UAAP,MAAuB,4BAAvB;AACA,SAAQC,4BAAR,QAA2C,gDAA3C;AACA,SAAQC,YAAR,EAAsBC,aAAtB,QAA0C,kBAA1C;AAaA,OAAO,SAASC,kBAAT,CAA4BC,MAA5B,EAAkDC,OAAlD,EAA2E;AAChF,MAAI,CAACN,UAAU,CAACO,WAAX,EAAL,EAA+B;AAC7B,WAAO,KAAP;AACD;;AAED,SAAOF,MAAM,CAACA,MAAP,KAAiBC,OAAjB,aAAiBA,OAAjB,uBAAiBA,OAAO,CAAED,MAA1B,CAAP;AACD;AAOD,OAAO,eAAeG,eAAf,CACLH,MADK,EAELI,IAFK,EAGLH,OAA+B,GAAG,EAH7B,EAILI,OAAsB,GAAG,EAJpB,EAKS;AACd,QAAMC,IAAI,GAAGR,aAAa,CAACE,MAAD,CAA1B;AACA,QAAMO,GAAG,GAAGV,YAAY,CAACG,MAAD,EAASC,OAAT,CAAxB;AAEA,QAAMO,UAAU,GAAGb,UAAU,CAACc,aAAX,CAAyBR,OAAzB,CAAnB;AACA,QAAMS,UAAU,GAAGF,UAAU,CAACG,aAAX,CAAyB;AAACL,IAAAA,IAAD;AAAOC,IAAAA;AAAP,GAAzB,CAAnB;AAEA,QAAMK,OAAO,GAAGX,OAAO,CAACW,OAAR,IAAmBZ,MAAM,CAACM,IAA1C;AACA,QAAMO,GAAG,GAAG,MAAMH,UAAU,CAACI,QAAX,CAChBF,OADgB,EAGhBG,SAAS,CAACC,IAAV,CAAe,IAAf,EAAqBX,OAArB,CAHgB,CAAlB;AAOA,QAAMY,mBAAmB,GAAGrB,4BAA4B,CAACK,OAAD,CAAxD;AACAY,EAAAA,GAAG,CAACK,WAAJ,CAAgB,SAAhB,EAA2B;AAACC,IAAAA,KAAK,EAAEf,IAAR;AAAcH,IAAAA,OAAO,EAAEgB;AAAvB,GAA3B;AAEA,QAAMG,MAAM,GAAG,MAAMP,GAAG,CAACO,MAAzB;AACA,SAAOA,MAAM,CAACA,MAAd;AACD;;AAOD,eAAeL,SAAf,CACEV,OADF,EAEEQ,GAFF,EAGEQ,IAHF,EAIEC,OAJF,EAKE;AACA,UAAQD,IAAR;AACE,SAAK,MAAL;AAEER,MAAAA,GAAG,CAACU,IAAJ,CAASD,OAAT;AACA;;AAEF,SAAK,OAAL;AAEET,MAAAA,GAAG,CAACW,KAAJ,CAAU,IAAIC,KAAJ,CAAUH,OAAO,CAACE,KAAlB,CAAV;AACA;;AAEF,SAAK,SAAL;AAEE,YAAM;AAACE,QAAAA,EAAD;AAAKP,QAAAA,KAAL;AAAYlB,QAAAA;AAAZ,UAAuBqB,OAA7B;;AACA,UAAI;AACF,YAAI,CAACjB,OAAO,CAACsB,OAAb,EAAsB;AACpBd,UAAAA,GAAG,CAACK,WAAJ,CAAgB,OAAhB,EAAyB;AAACQ,YAAAA,EAAD;AAAKF,YAAAA,KAAK,EAAE;AAAZ,WAAzB;AACA;AACD;;AACD,cAAMJ,MAAM,GAAG,MAAMf,OAAO,CAACsB,OAAR,CAAgBR,KAAhB,EAAuBlB,OAAvB,CAArB;AACAY,QAAAA,GAAG,CAACK,WAAJ,CAAgB,MAAhB,EAAwB;AAACQ,UAAAA,EAAD;AAAKN,UAAAA;AAAL,SAAxB;AACD,OAPD,CAOE,OAAOI,KAAP,EAAc;AACd,cAAMI,OAAO,GAAGJ,KAAK,YAAYC,KAAjB,GAAyBD,KAAK,CAACI,OAA/B,GAAyC,eAAzD;AACAf,QAAAA,GAAG,CAACK,WAAJ,CAAgB,OAAhB,EAAyB;AAACQ,UAAAA,EAAD;AAAKF,UAAAA,KAAK,EAAEI;AAAZ,SAAzB;AACD;;AACD;;AAEF;AAEEC,MAAAA,OAAO,CAACC,IAAR,8CAAmDT,IAAnD;AA7BJ;AA+BD","sourcesContent":["import type {\n  WorkerObject,\n  WorkerOptions,\n  WorkerContext,\n  WorkerMessageType,\n  WorkerMessagePayload\n} from '../../types';\nimport type WorkerJob from '../worker-farm/worker-job';\nimport WorkerFarm from '../worker-farm/worker-farm';\nimport {removeNontransferableOptions} from '../worker-utils/remove-nontransferable-options';\nimport {getWorkerURL, getWorkerName} from './get-worker-url';\n\ntype ProcessOnWorkerOptions = WorkerOptions & {\n  jobName?: string;\n  [key: string]: any;\n};\n\n/**\n * Determines if we can parse with worker\n * @param loader\n * @param data\n * @param options\n */\nexport function canProcessOnWorker(worker: WorkerObject, options?: WorkerOptions) {\n  if (!WorkerFarm.isSupported()) {\n    return false;\n  }\n\n  return worker.worker && options?.worker;\n}\n\n/**\n * This function expects that the worker thread sends certain messages,\n * Creating such a worker can be automated if the worker is wrapper by a call to\n * createWorker in @loaders.gl/worker-utils.\n */\nexport async function processOnWorker(\n  worker: WorkerObject,\n  data: any,\n  options: ProcessOnWorkerOptions = {},\n  context: WorkerContext = {}\n): Promise<any> {\n  const name = getWorkerName(worker);\n  const url = getWorkerURL(worker, options);\n\n  const workerFarm = WorkerFarm.getWorkerFarm(options);\n  const workerPool = workerFarm.getWorkerPool({name, url});\n\n  const jobName = options.jobName || worker.name;\n  const job = await workerPool.startJob(\n    jobName,\n    // eslint-disable-next-line\n    onMessage.bind(null, context)\n  );\n\n  // Kick off the processing in the worker\n  const transferableOptions = removeNontransferableOptions(options);\n  job.postMessage('process', {input: data, options: transferableOptions});\n\n  const result = await job.result;\n  return result.result;\n}\n\n/**\n * Job completes when we receive the result\n * @param job\n * @param message\n */\nasync function onMessage(\n  context: WorkerContext,\n  job: WorkerJob,\n  type: WorkerMessageType,\n  payload: WorkerMessagePayload\n) {\n  switch (type) {\n    case 'done':\n      // Worker is done\n      job.done(payload);\n      break;\n\n    case 'error':\n      // Worker encountered an error\n      job.error(new Error(payload.error));\n      break;\n\n    case 'process':\n      // Worker is asking for us (main thread) to process something\n      const {id, input, options} = payload;\n      try {\n        if (!context.process) {\n          job.postMessage('error', {id, error: 'Worker not set up to process on main thread'});\n          return;\n        }\n        const result = await context.process(input, options);\n        job.postMessage('done', {id, result});\n      } catch (error) {\n        const message = error instanceof Error ? error.message : 'unknown error';\n        job.postMessage('error', {id, error: message});\n      }\n      break;\n\n    default:\n      // eslint-disable-next-line\n      console.warn(`process-on-worker: unknown message ${type}`);\n  }\n}\n"],"file":"process-on-worker.js"}

package/dist/lib/worker-api/validate-worker-version.js

@@ -1,35 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateWorkerVersion = void 0;
-const assert_1 = require("../env-utils/assert");
-const version_1 = require("../env-utils/version");
-/**
- * Check if worker is compatible with this library version
- * @param worker
- * @param libVersion
- * @returns `true` if the two versions are compatible
- */
-function validateWorkerVersion(worker, coreVersion = version_1.VERSION) {
-    (0, assert_1.assert)(worker, 'no worker provided');
-    const workerVersion = worker.version;
-    if (!coreVersion || !workerVersion) {
-        return false;
-    }
-    // TODO enable when fix the __version__ injection
-    // const coreVersions = parseVersion(coreVersion);
-    // const workerVersions = parseVersion(workerVersion);
-    // assert(
-    //   coreVersion.major === workerVersion.major && coreVersion.minor <= workerVersion.minor,
-    //   `worker: ${worker.name} is not compatible. ${coreVersion.major}.${
-    //     coreVersion.minor
-    //   }+ is required.`
-    // );
-    return true;
+import { assert } from '../env-utils/assert';
+import { VERSION } from '../env-utils/version';
+export function validateWorkerVersion(worker, coreVersion = VERSION) {
+  assert(worker, 'no worker provided');
+  const workerVersion = worker.version;
+
+  if (!coreVersion || !workerVersion) {
+    return false;
+  }
+
+  return true;
 }
-exports.validateWorkerVersion = validateWorkerVersion;
-// @ts-ignore
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
+
 function parseVersion(version) {
-    const parts = version.split('.').map(Number);
-    return { major: parts[0], minor: parts[1] };
+  const parts = version.split('.').map(Number);
+  return {
+    major: parts[0],
+    minor: parts[1]
+  };
 }
+//# sourceMappingURL=validate-worker-version.js.map

package/dist/lib/worker-api/validate-worker-version.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lib/worker-api/validate-worker-version.ts"],"names":["assert","VERSION","validateWorkerVersion","worker","coreVersion","workerVersion","version","parseVersion","parts","split","map","Number","major","minor"],"mappings":"AACA,SAAQA,MAAR,QAAqB,qBAArB;AACA,SAAQC,OAAR,QAAsB,sBAAtB;AAQA,OAAO,SAASC,qBAAT,CACLC,MADK,EAELC,WAAmB,GAAGH,OAFjB,EAGI;AACTD,EAAAA,MAAM,CAACG,MAAD,EAAS,oBAAT,CAAN;AAEA,QAAME,aAAa,GAAGF,MAAM,CAACG,OAA7B;;AACA,MAAI,CAACF,WAAD,IAAgB,CAACC,aAArB,EAAoC;AAClC,WAAO,KAAP;AACD;;AAYD,SAAO,IAAP;AACD;;AAID,SAASE,YAAT,CAAsBD,OAAtB,EAA+B;AAC7B,QAAME,KAAK,GAAGF,OAAO,CAACG,KAAR,CAAc,GAAd,EAAmBC,GAAnB,CAAuBC,MAAvB,CAAd;AACA,SAAO;AAACC,IAAAA,KAAK,EAAEJ,KAAK,CAAC,CAAD,CAAb;AAAkBK,IAAAA,KAAK,EAAEL,KAAK,CAAC,CAAD;AAA9B,GAAP;AACD","sourcesContent":["import type {WorkerObject} from '../../types';\nimport {assert} from '../env-utils/assert';\nimport {VERSION} from '../env-utils/version';\n\n/**\n * Check if worker is compatible with this library version\n * @param worker\n * @param libVersion\n * @returns `true` if the two versions are compatible\n */\nexport function validateWorkerVersion(\n  worker: WorkerObject,\n  coreVersion: string = VERSION\n): boolean {\n  assert(worker, 'no worker provided');\n\n  const workerVersion = worker.version;\n  if (!coreVersion || !workerVersion) {\n    return false;\n  }\n\n  // TODO enable when fix the __version__ injection\n  // const coreVersions = parseVersion(coreVersion);\n  // const workerVersions = parseVersion(workerVersion);\n  // assert(\n  //   coreVersion.major === workerVersion.major && coreVersion.minor <= workerVersion.minor,\n  //   `worker: ${worker.name} is not compatible. ${coreVersion.major}.${\n  //     coreVersion.minor\n  //   }+ is required.`\n  // );\n\n  return true;\n}\n\n// @ts-ignore\n// eslint-disable-next-line @typescript-eslint/no-unused-vars\nfunction parseVersion(version) {\n  const parts = version.split('.').map(Number);\n  return {major: parts[0], minor: parts[1]};\n}\n"],"file":"validate-worker-version.js"}