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

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,SAAS,CAAC;AAI1C,YAAY,EACV,YAAY,EACZ,aAAa,EAEb,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAC,MAAM,EAAC,MAAM,wBAAwB,CAAC;AAC9C,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAC,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,MAAM,iCAAiC,CAAC;AAGxE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAGpE,YAAY,EAAC,sBAAsB,EAAC,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAC,eAAe,EAAE,kBAAkB,EAAC,MAAM,oCAAoC,CAAC;AACvF,OAAO,EAAC,YAAY,EAAC,MAAM,gCAAgC,CAAC;AAG5D,OAAO,EAAC,YAAY,EAAC,MAAM,iCAAiC,CAAC;AAC7D,OAAO,EAAC,qBAAqB,EAAC,MAAM,0CAA0C,CAAC;AAC/E,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,MAAM,sCAAsC,CAAC;AAG/F,OAAO,EAAC,aAAa,EAAE,WAAW,EAAC,MAAM,mCAAmC,CAAC;AAG7E,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAGpE,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,yCAAyC,CAAC;AAIrF,iEAAiE;AACjE,eAAO,MAAM,UAAU,EAAE,YAQxB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAC,mBAAgB;AAI1C,YAAY,EACV,YAAY,EACZ,aAAa,EAEb,aAAa,EACb,iBAAiB,EACjB,iBAAiB,EACjB,oBAAoB,EACrB,mBAAgB;AAGjB,OAAO,EAAC,MAAM,EAAC,kCAA+B;AAC9C,OAAO,EAAC,SAAS,EAAE,QAAQ,EAAC,mCAAgC;AAG5D,OAAO,EAAC,OAAO,IAAI,SAAS,EAAC,wCAAqC;AAClE,OAAO,EAAC,OAAO,IAAI,YAAY,EAAC,2CAAwC;AAGxE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yCAAsC;AACpE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yCAAsC;AACpE,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yCAAsC;AAGpE,YAAY,EAAC,sBAAsB,EAAC,8CAA2C;AAC/E,OAAO,EAAC,eAAe,EAAE,kBAAkB,EAAC,8CAA2C;AACvF,OAAO,EAAC,YAAY,EAAC,0CAAuC;AAG5D,OAAO,EAAC,YAAY,EAAC,2CAAwC;AAC7D,OAAO,EAAC,qBAAqB,EAAC,oDAAiD;AAC/E,OAAO,EAAC,eAAe,EAAE,wBAAwB,EAAC,gDAA6C;AAG/F,OAAO,EAAC,aAAa,EAAE,WAAW,EAAC,6CAA0C;AAG7E,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,yCAAsC;AAGpE,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,mDAAgD;AAIrF,iEAAiE;AACjE,eAAO,MAAM,UAAU,EAAE,YAQxB,CAAC"}

package/dist/index.js

@@ -1,26 +1,37 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { VERSION } from "./lib/env-utils/version.js";
+// GENERAL UTILS
 export { assert } from "./lib/env-utils/assert.js";
 export { isBrowser, isWorker } from "./lib/env-utils/globals.js";
+// WORKER UTILS - TYPES
 export { default as WorkerJob } from "./lib/worker-farm/worker-job.js";
 export { default as WorkerThread } from "./lib/worker-farm/worker-thread.js";
+// WORKER FARMS
 export { default as WorkerFarm } from "./lib/worker-farm/worker-farm.js";
 export { default as WorkerPool } from "./lib/worker-farm/worker-pool.js";
 export { default as WorkerBody } from "./lib/worker-farm/worker-body.js";
 export { processOnWorker, canProcessOnWorker } from "./lib/worker-api/process-on-worker.js";
 export { createWorker } from "./lib/worker-api/create-worker.js";
+// WORKER UTILS - EXPORTS
 export { getWorkerURL } from "./lib/worker-api/get-worker-url.js";
 export { validateWorkerVersion } from "./lib/worker-api/validate-worker-version.js";
 export { getTransferList, getTransferListForWriter } from "./lib/worker-utils/get-transfer-list.js";
+// LIBRARY UTILS
 export { getLibraryUrl, loadLibrary } from "./lib/library-utils/library-utils.js";
+// PARSER UTILS
 export { default as AsyncQueue } from "./lib/async-queue/async-queue.js";
+// PROCESS UTILS
 export { default as ChildProcessProxy } from "./lib/process-utils/child-process-proxy.js";
+// WORKER OBJECTS
+/** A null worker to test that worker processing is functional */
 export const NullWorker = {
-  id: 'null',
-  name: 'null',
-  module: 'worker-utils',
-  version: VERSION,
-  options: {
-    null: {}
-  }
+    id: 'null',
+    name: 'null',
+    module: 'worker-utils',
+    version: VERSION,
+    options: {
+        null: {}
+    }
 };
-//# sourceMappingURL=index.js.map

package/dist/lib/async-queue/async-queue.js

@@ -1,75 +1,87 @@
-let _Symbol$asyncIterator;
-_Symbol$asyncIterator = Symbol.asyncIterator;
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license
+// http://2ality.com/2016/10/asynchronous-iteration.html
+/**
+ * Async Queue
+ * - AsyncIterable: An async iterator can be
+ * - Values can be pushed onto the queue
+ * @example
+ *   const asyncQueue = new AsyncQueue();
+ *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);
+ *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);
+ *   for await (const value of asyncQueue) {
+ *     console.log(value); // tick
+ *   }
+ */
 export default class AsyncQueue {
-  constructor() {
-    this._values = void 0;
-    this._settlers = void 0;
-    this._closed = void 0;
-    this._values = [];
-    this._settlers = [];
-    this._closed = false;
-  }
-  [_Symbol$asyncIterator]() {
-    return this;
-  }
-  push(value) {
-    return this.enqueue(value);
-  }
-  enqueue(value) {
-    if (this._closed) {
-      throw new Error('Closed');
+    constructor() {
+        this._values = []; // enqueues > dequeues
+        this._settlers = []; // dequeues > enqueues
+        this._closed = false;
     }
-    if (this._settlers.length > 0) {
-      if (this._values.length > 0) {
-        throw new Error('Illegal internal state');
-      }
-      const settler = this._settlers.shift();
-      if (value instanceof Error) {
-        settler.reject(value);
-      } else {
-        settler.resolve({
-          value
-        });
-      }
-    } else {
-      this._values.push(value);
+    /** Return an async iterator for this queue */
+    [Symbol.asyncIterator]() {
+        return this;
+    }
+    /** Push a new value - the async iterator will yield a promise resolved to this value */
+    push(value) {
+        return this.enqueue(value);
     }
-  }
-  close() {
-    while (this._settlers.length > 0) {
-      const settler = this._settlers.shift();
-      settler.resolve({
-        done: true
-      });
+    /**
+     * Push a new value - the async iterator will yield a promise resolved to this value
+     * Add an error - the async iterator will yield a promise rejected with this value
+     */
+    enqueue(value) {
+        if (this._closed) {
+            throw new Error('Closed');
+        }
+        if (this._settlers.length > 0) {
+            if (this._values.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            const settler = this._settlers.shift();
+            if (value instanceof Error) {
+                settler.reject(value);
+            }
+            else {
+                settler.resolve({ value });
+            }
+        }
+        else {
+            this._values.push(value);
+        }
     }
-    this._closed = true;
-  }
-  next() {
-    if (this._values.length > 0) {
-      const value = this._values.shift();
-      if (value instanceof Error) {
-        return Promise.reject(value);
-      }
-      return Promise.resolve({
-        done: false,
-        value
-      });
+    /** Indicate that we not waiting for more values - The async iterator will be done */
+    close() {
+        while (this._settlers.length > 0) {
+            const settler = this._settlers.shift();
+            settler.resolve({ done: true });
+        }
+        this._closed = true;
     }
-    if (this._closed) {
-      if (this._settlers.length > 0) {
-        throw new Error('Illegal internal state');
-      }
-      return Promise.resolve({
-        done: true,
-        value: undefined
-      });
+    // ITERATOR IMPLEMENTATION
+    /** @returns a Promise for an IteratorResult */
+    next() {
+        // If values in queue, yield the first value
+        if (this._values.length > 0) {
+            const value = this._values.shift();
+            if (value instanceof Error) {
+                return Promise.reject(value);
+            }
+            return Promise.resolve({ done: false, value });
+        }
+        // If queue is closed, the iterator is done
+        if (this._closed) {
+            if (this._settlers.length > 0) {
+                throw new Error('Illegal internal state');
+            }
+            return Promise.resolve({ done: true, value: undefined });
+        }
+        // Yield a promise that waits for new values to be enqueued
+        return new Promise((resolve, reject) => {
+            this._settlers.push({ resolve, reject });
+        });
     }
-    return new Promise((resolve, reject) => {
-      this._settlers.push({
-        resolve,
-        reject
-      });
-    });
-  }
 }
-//# sourceMappingURL=async-queue.js.map

package/dist/lib/env-utils/assert.js

@@ -1,6 +1,12 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Replacement for the external assert method to reduce bundle size
+// Note: We don't use the second "message" argument in calling code,
+// so no need to support it here
+/** Throws an `Error` with the optional `message` if `condition` is falsy */
 export function assert(condition, message) {
-  if (!condition) {
-    throw new Error(message || 'loaders.gl assertion failed.');
-  }
+    if (!condition) {
+        throw new Error(message || 'loaders.gl assertion failed.');
+    }
 }
-//# sourceMappingURL=assert.js.map

package/dist/lib/env-utils/globals.js

@@ -1,17 +1,29 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Purpose: include this in your module to avoids adding dependencies on
+// micro modules like 'global' and 'is-browser';
+/* eslint-disable no-restricted-globals */
 const globals = {
-  self: typeof self !== 'undefined' && self,
-  window: typeof window !== 'undefined' && window,
-  global: typeof global !== 'undefined' && global,
-  document: typeof document !== 'undefined' && document
+    self: typeof self !== 'undefined' && self,
+    window: typeof window !== 'undefined' && window,
+    global: typeof global !== 'undefined' && global,
+    document: typeof document !== 'undefined' && document
 };
 const self_ = globals.self || globals.window || globals.global || {};
 const window_ = globals.window || globals.self || globals.global || {};
 const global_ = globals.global || globals.self || globals.window || {};
 const document_ = globals.document || {};
 export { self_ as self, window_ as window, global_ as global, document_ as document };
-export const isBrowser = typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+/** true if running in the browser, false if running in Node.js */
+export const isBrowser = 
+// @ts-ignore process.browser
+typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+/** true if running on a worker thread */
 export const isWorker = typeof importScripts === 'function';
+/** true if running on a mobile device */
 export const isMobile = typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
+// Extract node major version
 const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
-export const nodeVersion = matches && parseFloat(matches[1]) || 0;
-//# sourceMappingURL=globals.js.map
+/** Version of Node.js if running under Node, otherwise 0 */
+export const nodeVersion = (matches && parseFloat(matches[1])) || 0;

package/dist/lib/env-utils/version.js

@@ -1,16 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+/**
+ * TODO - unpkg.com doesn't seem to have a `latest` specifier for alpha releases...
+ * 'beta' on beta branch, 'latest' on prod branch
+ */
 export const NPM_TAG = 'latest';
 function getVersion() {
-  var _globalThis$_loadersg;
-  if (!((_globalThis$_loadersg = globalThis._loadersgl_) !== null && _globalThis$_loadersg !== void 0 && _globalThis$_loadersg.version)) {
-    globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-    if (typeof "4.2.0-alpha.4" === 'undefined') {
-      console.warn('loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.');
-      globalThis._loadersgl_.version = NPM_TAG;
-    } else {
-      globalThis._loadersgl_.version = "4.2.0-alpha.4";
+    if (!globalThis._loadersgl_?.version) {
+        globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+        // __VERSION__ is injected by babel-plugin-version-inline
+        if (typeof "4.2.0-alpha.4" === 'undefined') {
+            // eslint-disable-next-line
+            console.warn('loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.');
+            globalThis._loadersgl_.version = NPM_TAG;
+        }
+        else {
+            globalThis._loadersgl_.version = "4.2.0-alpha.4";
+        }
     }
-  }
-  return globalThis._loadersgl_.version;
+    return globalThis._loadersgl_.version;
 }
 export const VERSION = getVersion();
-//# sourceMappingURL=version.js.map

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

@@ -1,89 +1,164 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/* global importScripts */
 import { isBrowser, isWorker } from "../env-utils/globals.js";
 import * as node from "../node/require-utils.node.js";
 import { assert } from "../env-utils/assert.js";
 import { VERSION } from "../env-utils/version.js";
-const loadLibraryPromises = {};
-export async function loadLibrary(libraryUrl) {
-  let moduleName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  let libraryName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-  if (moduleName) {
-    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
-  }
-  loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
-  return await loadLibraryPromises[libraryUrl];
+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
+ */
+export async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+    if (moduleName) {
+        libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
+    }
+    // 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];
 }
-export function getLibraryUrl(library, moduleName) {
-  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-  let libraryName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
-  if (!options.useLocalLibraries && library.startsWith('http')) {
-    return library;
-  }
-  libraryName = libraryName || library;
-  const modules = options.modules || {};
-  if (modules[libraryName]) {
-    return modules[libraryName];
-  }
-  if (!isBrowser) {
-    return `modules/${moduleName}/dist/libs/${libraryName}`;
-  }
-  if (options.CDN) {
-    assert(options.CDN.startsWith('http'));
-    return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
-  }
-  if (isWorker) {
-    return `../src/libs/${libraryName}`;
-  }
-  return `modules/${moduleName}/src/libs/${libraryName}`;
+// TODO - sort out how to resolve paths for main/worker and dev/prod
+export function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    // Check if already a URL
+    if (!options.useLocalLibraries && library.startsWith('http')) {
+        return library;
+    }
+    libraryName = libraryName || library;
+    // Allow application to import and supply libraries through `options.modules`
+    const modules = options.modules || {};
+    if (modules[libraryName]) {
+        return modules[libraryName];
+    }
+    // Load from local files, not from CDN scripts in Node.js
+    // TODO - needs to locate the modules directory when installed!
+    if (!isBrowser) {
+        return `modules/${moduleName}/dist/libs/${libraryName}`;
+    }
+    // In browser, load from external scripts
+    if (options.CDN) {
+        assert(options.CDN.startsWith('http'));
+        return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    }
+    // TODO - loading inside workers requires paths relative to worker script location...
+    if (isWorker) {
+        return `../src/libs/${libraryName}`;
+    }
+    return `modules/${moduleName}/src/libs/${libraryName}`;
 }
 async function loadLibraryFromFile(libraryUrl) {
-  if (libraryUrl.endsWith('wasm')) {
-    return await loadAsArrayBuffer(libraryUrl);
-  }
-  if (!isBrowser) {
-    try {
-      return node && node.requireFromFile && (await node.requireFromFile(libraryUrl));
-    } catch (error) {
-      console.error(error);
-      return null;
+    if (libraryUrl.endsWith('wasm')) {
+        return await loadAsArrayBuffer(libraryUrl);
+    }
+    if (!isBrowser) {
+        // TODO - Node doesn't yet support dynamic import from https URLs
+        // try {
+        //   return await import(libraryUrl);
+        // } catch (error) {
+        //   console.error(error);
+        // }
+        try {
+            return node && node.requireFromFile && (await node.requireFromFile(libraryUrl));
+        }
+        catch (error) {
+            console.error(error); // eslint-disable-line no-console
+            return null;
+        }
     }
-  }
-  if (isWorker) {
-    return importScripts(libraryUrl);
-  }
-  const scriptSource = await loadAsText(libraryUrl);
-  return loadLibraryFromString(scriptSource, libraryUrl);
+    if (isWorker) {
+        return importScripts(libraryUrl);
+    }
+    // TODO - fix - should be more secure than string parsing since observes CORS
+    // if (isBrowser) {
+    //   return await loadScriptFromFile(libraryUrl);
+    // }
+    const scriptSource = await loadAsText(libraryUrl);
+    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 (!isBrowser) {
-    return node.requireFromString && node.requireFromString(scriptSource, id);
-  }
-  if (isWorker) {
-    eval.call(globalThis, scriptSource);
+    if (!isBrowser) {
+        return node.requireFromString && node.requireFromString(scriptSource, id);
+    }
+    if (isWorker) {
+        // Use lvalue trick to make eval run in global scope
+        eval.call(globalThis, 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;
-  }
-  const script = document.createElement('script');
-  script.id = id;
-  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]));
+}
+*/
 async function loadAsArrayBuffer(url) {
-  if (isBrowser || !node.readFileAsArrayBuffer || url.startsWith('http')) {
-    const response = await fetch(url);
-    return await response.arrayBuffer();
-  }
-  return await node.readFileAsArrayBuffer(url);
+    if (isBrowser || !node.readFileAsArrayBuffer || url.startsWith('http')) {
+        const response = await fetch(url);
+        return await response.arrayBuffer();
+    }
+    return await node.readFileAsArrayBuffer(url);
 }
+/**
+ * Load a file from local file system
+ * @param filename
+ * @returns
+ */
 async function loadAsText(url) {
-  if (isBrowser || !node.readFileAsText || url.startsWith('http')) {
-    const response = await fetch(url);
-    return await response.text();
-  }
-  return await node.readFileAsText(url);
+    if (isBrowser || !node.readFileAsText || url.startsWith('http')) {
+        const response = await fetch(url);
+        return await response.text();
+    }
+    return await node.readFileAsText(url);
 }
-//# sourceMappingURL=library-utils.js.map