@loaders.gl/worker-utils 3.1.0-alpha.5 → 3.1.0-beta.4

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

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLibraryUrl = exports.loadLibrary = void 0;
+/* global importScripts */
+const globals_1 = require("../env-utils/globals");
+const node = __importStar(require("../node/require-utils.node"));
+const assert_1 = require("../env-utils/assert");
+const version_1 = require("../env-utils/version");
+// TODO - unpkg.com doesn't seem to have a `latest` specifier for alpha releases...
+const LATEST = 'beta';
+const VERSION = typeof version_1.VERSION !== 'undefined' ? version_1.VERSION : LATEST;
+const loadLibraryPromises = {}; // promises
+/**
+ * Dynamically loads a library ("module")
+ *
+ * - wasm library: Array buffer is returned
+ * - js library: Parse JS is returned
+ *
+ * Method depends on environment
+ * - browser - script element is created and installed on document
+ * - worker - eval is called on global context
+ * - node - file is required
+ *
+ * @param libraryUrl
+ * @param moduleName
+ * @param options
+ */
+async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+    if (moduleName) {
+        libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+    }
+    // Ensure libraries are only loaded once
+    loadLibraryPromises[libraryUrl] =
+        // eslint-disable-next-line @typescript-eslint/no-misused-promises
+        loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+}
+exports.loadLibrary = loadLibrary;
+// TODO - sort out how to resolve paths for main/worker and dev/prod
+function getLibraryUrl(library, moduleName, options) {
+    // Check if already a URL
+    if (library.startsWith('http')) {
+        return library;
+    }
+    // Allow application to import and supply libraries through `options.modules`
+    const modules = options.modules || {};
+    if (modules[library]) {
+        return modules[library];
+    }
+    // Load from local files, not from CDN scripts in Node.js
+    // TODO - needs to locate the modules directory when installed!
+    if (!globals_1.isBrowser) {
+        return `modules/${moduleName}/dist/libs/${library}`;
+    }
+    // In browser, load from external scripts
+    if (options.CDN) {
+        (0, assert_1.assert)(options.CDN.startsWith('http'));
+        return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${library}`;
+    }
+    // TODO - loading inside workers requires paths relative to worker script location...
+    if (globals_1.isWorker) {
+        return `../src/libs/${library}`;
+    }
+    return `modules/${moduleName}/src/libs/${library}`;
+}
+exports.getLibraryUrl = getLibraryUrl;
+async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith('wasm')) {
+        const response = await fetch(libraryUrl);
+        return await response.arrayBuffer();
+    }
+    if (!globals_1.isBrowser) {
+        return node.requireFromFile && (await node.requireFromFile(libraryUrl));
+    }
+    if (globals_1.isWorker) {
+        return importScripts(libraryUrl);
+    }
+    // TODO - fix - should be more secure than string parsing since observes CORS
+    // if (isBrowser) {
+    //   return await loadScriptFromFile(libraryUrl);
+    // }
+    const response = await fetch(libraryUrl);
+    const scriptSource = await response.text();
+    return loadLibraryFromString(scriptSource, libraryUrl);
+}
+/*
+async function loadScriptFromFile(libraryUrl) {
+  const script = document.createElement('script');
+  script.src = libraryUrl;
+  return await new Promise((resolve, reject) => {
+    script.onload = data => {
+      resolve(data);
+    };
+    script.onerror = reject;
+  });
+}
+*/
+// TODO - Needs security audit...
+//  - Raw eval call
+//  - Potentially bypasses CORS
+// Upside is that this separates fetching and parsing
+// we could create a`LibraryLoader` or`ModuleLoader`
+function loadLibraryFromString(scriptSource, id) {
+    if (!globals_1.isBrowser) {
+        return node.requireFromString && node.requireFromString(scriptSource, id);
+    }
+    if (globals_1.isWorker) {
+        // Use lvalue trick to make eval run in global scope
+        eval.call(globals_1.global, scriptSource); // eslint-disable-line no-eval
+        // https://stackoverflow.com/questions/9107240/1-evalthis-vs-evalthis-in-javascript
+        // http://perfectionkills.com/global-eval-what-are-the-options/
+        return null;
+    }
+    const script = document.createElement('script');
+    script.id = id;
+    // most browsers like a separate text node but some throw an error. The second method covers those.
+    try {
+        script.appendChild(document.createTextNode(scriptSource));
+    }
+    catch (e) {
+        script.text = scriptSource;
+    }
+    document.body.appendChild(script);
+    return null;
+}
+// TODO - technique for module injection into worker, from THREE.DracoLoader...
+/*
+function combineWorkerWithLibrary(worker, jsContent) {
+  var fn = wWorker.toString();
+  var body = [
+    '// injected',
+    jsContent,
+    '',
+    '// worker',
+    fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))
+  ].join('\n');
+  this.workerSourceURL = URL.createObjectURL(new Blob([body]));
+}
+*/

package/dist/lib/node/require-utils.node.d.ts

@@ -1,2 +1,6 @@
-export function requireFromFile(filename: any): Promise<any>;
-export function requireFromString(code: any, filename?: string, options?: {}): any;
+export declare function requireFromFile(filename: string): Promise<any>;
+export declare function requireFromString(code: string, filename?: string, options?: {
+    prependPaths?: string[];
+    appendPaths?: string[];
+}): any;
+//# sourceMappingURL=require-utils.node.d.ts.map

package/dist/lib/node/require-utils.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"require-utils.node.d.ts","sourceRoot":"","sources":["../../../src/lib/node/require-utils.node.ts"],"names":[],"mappings":"AAaA,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAWpE;AAQD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,EACZ,QAAQ,SAAK,EACb,OAAO,CAAC,EAAE;IACR,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB,GACA,GAAG,CA6BL"}

package/dist/lib/node/require-utils.node.js

@@ -0,0 +1,60 @@
+"use strict";
+// Fork of https://github.com/floatdrop/require-from-string/blob/master/index.js
+// Copyright (c) Vsevolod Strukchinsky <floatdrop@gmail.com> (github.com/floatdrop)
+// MIT license
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireFromString = exports.requireFromFile = void 0;
+// this file is not visible to webpack (it is excluded in the package.json "browser" field).
+const module_1 = __importDefault(require("module"));
+const path_1 = __importDefault(require("path"));
+// Node.js Dynamically require from file
+// Relative names are resolved relative to cwd
+// This indirect function is provided because webpack will try to bundle `module.require`.
+// this file is not visible to webpack (it is excluded in the package.json "browser" field).
+async function requireFromFile(filename) {
+    if (filename.startsWith('http')) {
+        const response = await fetch(filename);
+        const code = await response.text();
+        return requireFromString(code);
+    }
+    if (!filename.startsWith('/')) {
+        filename = `${process.cwd()}/${filename}`;
+    }
+    return require(filename);
+}
+exports.requireFromFile = requireFromFile;
+// Dynamically require from string
+// - `code` - Required - Type: string - Module code.
+// - `filename` - Type: string - Default: '' - Optional filename.
+// - `options.appendPaths` Type: Array List of paths, that will be appended to module paths.
+// Useful, when you want to be able require modules from these paths.
+// - `options.prependPaths` Type: Array Same as appendPaths, but paths will be prepended.
+function requireFromString(code, filename = '', options) {
+    if (typeof filename === 'object') {
+        options = filename;
+        filename = '';
+    }
+    if (typeof code !== 'string') {
+        throw new Error(`code must be a string, not ${typeof code}`);
+    }
+    // @ts-ignore
+    const paths = module_1.default._nodeModulePaths(path_1.default.dirname(filename));
+    const parent = module.parent;
+    // @ts-ignore
+    const newModule = new module_1.default(filename, parent);
+    newModule.filename = filename;
+    newModule.paths = []
+        .concat(options?.prependPaths || [])
+        .concat(paths)
+        .concat(options?.appendPaths || []);
+    // @ts-ignore
+    newModule._compile(code, filename);
+    if (parent && parent.children) {
+        parent.children.splice(parent.children.indexOf(newModule), 1);
+    }
+    return newModule.exports;
+}
+exports.requireFromString = requireFromString;

package/dist/lib/process-utils/child-process-proxy.d.ts

@@ -40,3 +40,4 @@ export default class ChildProcessProxy {
     _setTimeout(callback: (...args: any[]) => void): void;
     _clearTimeout(): void;
 }
+//# sourceMappingURL=child-process-proxy.d.ts.map

package/dist/lib/process-utils/child-process-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-process-proxy.d.ts","sourceRoot":"","sources":["../../../src/lib/process-utils/child-process-proxy.ts"],"names":[],"mappings":";AAIA,OAAO,KAAK,YAAY,MAAM,eAAe,CAAC;AAG9C,oBAAY,sBAAsB,GAAG;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,0CAA0C;IAC1C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uBAAuB;IACvB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,8DAA8D;IAC9D,yBAAyB;IACzB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,KAAK,CAAC,EAAE,YAAY,CAAC,wBAAwB,CAAC;IAC9C,yBAAyB;IACzB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;IAC7C,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAC;CAChD,CAAC;AAaF;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,iBAAiB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,sBAAsB,CAAsB;IACnD,OAAO,CAAC,YAAY,CAA0C;IAC9D,OAAO,CAAC,IAAI,CAAa;IACzB,OAAO,CAAC,YAAY,CAAC,CAAM;gBAGf,EAAC,EAAqB,EAAC;;KAAK;IAIxC,qDAAqD;IAC/C,KAAK,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC;IAsD3D,oCAAoC;IAC9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAO3B,yBAAyB;IACnB,IAAI,CAAC,UAAU,GAAE,MAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IAYjD,WAAW,CAAC,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI;IAM9C,aAAa;CAKd"}

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

@@ -0,0 +1,131 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+// Avoid using named imports for Node builtins to help with "empty" resolution
+// for bundlers targeting browser environments. Access imports & types
+// through the `ChildProcess` object (e.g. `ChildProcess.spawn`, `ChildProcess.ChildProcess`).
+const ChildProcess = __importStar(require("child_process"));
+const process_utils_1 = require("./process-utils");
+const DEFAULT_PROPS = {
+    command: '',
+    arguments: [],
+    port: 5000,
+    autoPort: true,
+    wait: 2000,
+    onSuccess: (processProxy) => {
+        console.log(`Started ${processProxy.props.command}`);
+    }
+};
+/**
+ * Manager for a Node.js child process
+ * Prepares arguments, starts, stops and tracks output
+ */
+class ChildProcessProxy {
+    // constructor(props?: {id?: string});
+    constructor({ id = 'browser-driver' } = {}) {
+        this.props = { ...DEFAULT_PROPS };
+        this.childProcess = null;
+        this.port = 0;
+        this.id = id;
+    }
+    /** Starts a child process with the provided props */
+    async start(props) {
+        props = { ...DEFAULT_PROPS, ...props };
+        this.props = props;
+        const args = [...props.arguments];
+        // If portArg is set, we can look up an available port
+        this.port = Number(props.port);
+        if (props.portArg) {
+            if (props.autoPort) {
+                this.port = await (0, process_utils_1.getAvailablePort)(props.port);
+            }
+            args.push(props.portArg, String(this.port));
+        }
+        return await new Promise((resolve, reject) => {
+            try {
+                this._setTimeout(() => {
+                    if (props.onSuccess) {
+                        props.onSuccess(this);
+                    }
+                    resolve({});
+                });
+                console.log(`Spawning ${props.command} ${props.arguments.join(' ')}`);
+                const childProcess = ChildProcess.spawn(props.command, args, props.spawn);
+                this.childProcess = childProcess;
+                childProcess.stdout.on('data', (data) => {
+                    console.log(data.toString());
+                });
+                // TODO - add option regarding whether stderr should be treated as data
+                childProcess.stderr.on('data', (data) => {
+                    console.log(`Child process wrote to stderr: "${data}".`);
+                    this._clearTimeout();
+                    reject(new Error(data));
+                });
+                childProcess.on('error', (error) => {
+                    console.log(`Child process errored with ${error}`);
+                    this._clearTimeout();
+                    reject(error);
+                });
+                childProcess.on('close', (code) => {
+                    console.log(`Child process exited with ${code}`);
+                    this.childProcess = null;
+                    this._clearTimeout();
+                    resolve({});
+                });
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /** Stops a running child process */
+    async stop() {
+        if (this.childProcess) {
+            this.childProcess.kill();
+            this.childProcess = null;
+        }
+    }
+    /** Exits this process */
+    async exit(statusCode = 0) {
+        try {
+            await this.stop();
+            // eslint-disable-next-line no-process-exit
+            process.exit(statusCode);
+        }
+        catch (error) {
+            console.error(error.message || error);
+            // eslint-disable-next-line no-process-exit
+            process.exit(1);
+        }
+    }
+    _setTimeout(callback) {
+        if (Number(this.props.wait) > 0) {
+            this.successTimer = setTimeout(callback, this.props.wait);
+        }
+    }
+    _clearTimeout() {
+        if (this.successTimer) {
+            clearTimeout(this.successTimer);
+        }
+    }
+}
+exports.default = ChildProcessProxy;

package/dist/lib/process-utils/process-utils.d.ts

@@ -1 +1,2 @@
 export declare function getAvailablePort(defaultPort?: number): Promise<number>;
+//# sourceMappingURL=process-utils.d.ts.map

package/dist/lib/process-utils/process-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/process-utils/process-utils.ts"],"names":[],"mappings":"AAIA,wBAAgB,gBAAgB,CAAC,WAAW,GAAE,MAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAyB5E"}

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

@@ -0,0 +1,35 @@
+"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);
+        });
+    });
+}
+exports.getAvailablePort = getAvailablePort;

package/dist/lib/worker-api/create-worker.d.ts

@@ -1,8 +1,9 @@
-import type { Process, ProcessInBatches } from '../../types';
+import type { WorkerContext, Process, ProcessInBatches } from '../../types';
 export declare type ProcessOnMainThread = (data: any, options?: {
     [key: string]: any;
-}, context?: any) => any;
+}, context?: WorkerContext) => any;
 /**
  * Set up a WebWorkerGlobalScope to talk with the main thread
  */
 export declare function createWorker(process: Process, processInBatches?: ProcessInBatches): void;
+//# sourceMappingURL=create-worker.d.ts.map

package/dist/lib/worker-api/create-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-worker.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-api/create-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,aAAa,EACb,OAAO,EACP,gBAAgB,EACjB,MAAM,aAAa,CAAC;AAUrB,oBAAY,mBAAmB,GAAG,CAChC,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,EAC9B,OAAO,CAAC,EAAE,aAAa,KACpB,GAAG,CAAC;AAET;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,EAAE,gBAAgB,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAkDxF"}

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

@@ -0,0 +1,92 @@
+"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';
+/** Counter for jobs */
+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;
+    }
+    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);
+    });
+}

package/dist/lib/worker-api/get-worker-url.d.ts

@@ -11,3 +11,4 @@ export declare function getWorkerName(worker: WorkerObject): string;
  * - a URL provided by the user in options
  */
 export declare function getWorkerURL(worker: WorkerObject, options?: WorkerOptions): string;
+//# sourceMappingURL=get-worker-url.d.ts.map

package/dist/lib/worker-api/get-worker-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-worker-url.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-api/get-worker-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAC,MAAM,aAAa,CAAC;AAO7D;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,YAAY,GAAG,MAAM,CAG1D;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,GAAE,aAAkB,GAAG,MAAM,CA8BtF"}

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

@@ -0,0 +1,48 @@
+"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 = 'beta'; // 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}`;
+}
+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;
+    // 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;
+}
+exports.getWorkerURL = getWorkerURL;

package/dist/lib/worker-api/process-on-worker.d.ts

@@ -17,3 +17,4 @@ export declare function canProcessOnWorker(worker: WorkerObject, options?: Worke
  */
 export declare function processOnWorker(worker: WorkerObject, data: any, options?: ProcessOnWorkerOptions, context?: WorkerContext): Promise<any>;
 export {};
+//# sourceMappingURL=process-on-worker.d.ts.map

package/dist/lib/worker-api/process-on-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-on-worker.d.ts","sourceRoot":"","sources":["../../../src/lib/worker-api/process-on-worker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,aAAa,EACb,aAAa,EAGd,MAAM,aAAa,CAAC;AAMrB,aAAK,sBAAsB,GAAG,aAAa,GAAG;IAC5C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,aAAa,4BAM/E;AAED;;;;GAIG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,YAAY,EACpB,IAAI,EAAE,GAAG,EACT,OAAO,GAAE,sBAA2B,EACpC,OAAO,GAAE,aAAkB,GAC1B,OAAO,CAAC,GAAG,CAAC,CAoBd"}