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

package/dist/index.cjs

@@ -5,9 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -29,26 +27,16 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 
-// (disabled):src/lib/node/require-utils.node
-var require_require_utils = __commonJS({
-  "(disabled):src/lib/node/require-utils.node"() {
-    "use strict";
-  }
-});
-
-// (disabled):src/lib/process-utils/child-process-proxy
-var require_child_process_proxy = __commonJS({
-  "(disabled):src/lib/process-utils/child-process-proxy"() {
-    "use strict";
-  }
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   AsyncQueue: () => AsyncQueue,
-  ChildProcessProxy: () => import_child_process_proxy.default,
+  ChildProcessProxy: () => ChildProcessProxy,
   NullWorker: () => NullWorker,
   WorkerBody: () => WorkerBody,
   WorkerFarm: () => WorkerFarm,
@@ -68,35 +56,33 @@ __export(src_exports, {
   processOnWorker: () => processOnWorker,
   validateWorkerVersion: () => validateWorkerVersion
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/lib/env-utils/version.ts
+// dist/lib/env-utils/version.js
 var NPM_TAG = "latest";
 function getVersion() {
   var _a;
   if (!((_a = globalThis._loadersgl_) == null ? void 0 : _a.version)) {
     globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-    if (typeof __VERSION__ === "undefined") {
-      console.warn(
-        "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
-      );
+    if (false) {
+      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 = __VERSION__;
+      globalThis._loadersgl_.version = "4.2.0-alpha.5";
     }
   }
   return globalThis._loadersgl_.version;
 }
 var VERSION = getVersion();
 
-// src/lib/env-utils/assert.ts
+// dist/lib/env-utils/assert.js
 function assert(condition, message) {
   if (!condition) {
     throw new Error(message || "loaders.gl assertion failed.");
   }
 }
 
-// src/lib/env-utils/globals.ts
+// dist/lib/env-utils/globals.js
 var globals = {
   self: typeof self !== "undefined" && self,
   window: typeof window !== "undefined" && window,
@@ -116,14 +102,18 @@ var isMobile = typeof window !== "undefined" && typeof window.orientation !== "u
 var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
 var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
-// src/lib/worker-farm/worker-job.ts
+// dist/lib/worker-farm/worker-job.js
 var WorkerJob = class {
+  name;
+  workerThread;
+  isRunning = true;
+  /** Promise that resolves when Job is done */
+  result;
+  _resolve = () => {
+  };
+  _reject = () => {
+  };
   constructor(jobName, workerThread) {
-    this.isRunning = true;
-    this._resolve = () => {
-    };
-    this._reject = () => {
-    };
     this.name = jobName;
     this.workerThread = workerThread;
     this.result = new Promise((resolve, reject) => {
@@ -161,14 +151,14 @@ var WorkerJob = class {
   }
 };
 
-// src/lib/node/worker_threads-browser.ts
+// dist/lib/node/worker_threads-browser.js
 var NodeWorker = class {
   terminate() {
   }
 };
 var parentPort = null;
 
-// src/lib/worker-utils/get-loadable-worker-url.ts
+// dist/lib/worker-utils/get-loadable-worker-url.js
 var workerURLCache = /* @__PURE__ */ new Map();
 function getLoadableWorkerURL(props) {
   assert(props.source && !props.url || !props.source && props.url);
@@ -206,7 +196,7 @@ function buildScriptSource(workerUrl) {
 }`;
 }
 
-// src/lib/worker-utils/get-transfer-list.ts
+// dist/lib/worker-utils/get-transfer-list.js
 function getTransferList(object, recursive = true, transfers) {
   const transfersSet = transfers || /* @__PURE__ */ new Set();
   if (!object) {
@@ -257,13 +247,23 @@ function getTransferListForWriter(object) {
   return clone;
 }
 
-// src/lib/worker-farm/worker-thread.ts
+// dist/lib/worker-farm/worker-thread.js
 var NOOP = () => {
 };
 var WorkerThread = class {
+  name;
+  source;
+  url;
+  terminated = false;
+  worker;
+  onMessage;
+  onError;
+  _loadableURL = "";
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
+  }
   constructor(props) {
-    this.terminated = false;
-    this._loadableURL = "";
     const { name, source, url } = props;
     assert(source || url);
     this.name = name;
@@ -273,10 +273,6 @@ var WorkerThread = class {
     this.onError = (error) => console.log(error);
     this.worker = isBrowser ? this._createBrowserWorker() : this._createNodeWorker();
   }
-  /** Checks if workers are supported on this platform */
-  static isSupported() {
-    return typeof Worker !== "undefined" && isBrowser || typeof NodeWorker !== "undefined" && !isBrowser;
-  }
   /**
    * Terminate this worker thread
    * @note Can free up significant memory
@@ -362,32 +358,35 @@ var WorkerThread = class {
   }
 };
 
-// src/lib/worker-farm/worker-pool.ts
+// dist/lib/worker-farm/worker-pool.js
 var WorkerPool = class {
+  name = "unnamed";
+  source;
+  // | Function;
+  url;
+  maxConcurrency = 1;
+  maxMobileConcurrency = 1;
+  onDebug = () => {
+  };
+  reuseWorkers = true;
+  props = {};
+  jobQueue = [];
+  idleQueue = [];
+  count = 0;
+  isDestroyed = false;
+  /** Checks if workers are supported on this platform */
+  static isSupported() {
+    return WorkerThread.isSupported();
+  }
   /**
    * @param processor - worker function
    * @param maxConcurrency - max count of workers
    */
   constructor(props) {
-    this.name = "unnamed";
-    this.maxConcurrency = 1;
-    this.maxMobileConcurrency = 1;
-    this.onDebug = () => {
-    };
-    this.reuseWorkers = true;
-    this.props = {};
-    this.jobQueue = [];
-    this.idleQueue = [];
-    this.count = 0;
-    this.isDestroyed = false;
     this.source = props.source;
     this.url = props.url;
     this.setProps(props);
   }
-  /** Checks if workers are supported on this platform */
-  static isSupported() {
-    return WorkerThread.isSupported();
-  }
   /**
    * Terminates all workers in the pool
    * @note Can free up significant memory
@@ -502,7 +501,7 @@ var WorkerPool = class {
   }
 };
 
-// src/lib/worker-farm/worker-farm.ts
+// dist/lib/worker-farm/worker-farm.js
 var DEFAULT_PROPS = {
   maxConcurrency: 3,
   maxMobileConcurrency: 1,
@@ -510,23 +509,24 @@ var DEFAULT_PROPS = {
   onDebug: () => {
   }
 };
-var WorkerFarm = class {
-  /** get global instance with WorkerFarm.getWorkerFarm() */
-  constructor(props) {
-    this.workerPools = /* @__PURE__ */ new Map();
-    this.props = { ...DEFAULT_PROPS };
-    this.setProps(props);
-    this.workerPools = /* @__PURE__ */ new Map();
-  }
+var _WorkerFarm = class {
+  props;
+  workerPools = /* @__PURE__ */ new Map();
   /** Checks if workers are supported on this platform */
   static isSupported() {
     return WorkerThread.isSupported();
   }
   /** Get the singleton instance of the global worker farm */
   static getWorkerFarm(props = {}) {
-    WorkerFarm._workerFarm = WorkerFarm._workerFarm || new WorkerFarm({});
-    WorkerFarm._workerFarm.setProps(props);
-    return WorkerFarm._workerFarm;
+    _WorkerFarm._workerFarm = _WorkerFarm._workerFarm || new _WorkerFarm({});
+    _WorkerFarm._workerFarm.setProps(props);
+    return _WorkerFarm._workerFarm;
+  }
+  /** get global instance with WorkerFarm.getWorkerFarm() */
+  constructor(props) {
+    this.props = { ...DEFAULT_PROPS };
+    this.setProps(props);
+    this.workerPools = /* @__PURE__ */ new Map();
   }
   /**
    * Terminate all workers in the farm
@@ -580,8 +580,11 @@ var WorkerFarm = class {
     };
   }
 };
+var WorkerFarm = _WorkerFarm;
+// singleton
+__publicField(WorkerFarm, "_workerFarm");
 
-// src/lib/worker-farm/worker-body.ts
+// dist/lib/worker-farm/worker-body.js
 async function getParentPort() {
   return parentPort;
 }
@@ -602,7 +605,9 @@ var WorkerBody = class {
     }
     getParentPort().then((parentPort2) => {
       if (parentPort2) {
-        parentPort2.on("message", handleMessage);
+        parentPort2.on("message", (message) => {
+          handleMessage(message);
+        });
         parentPort2.on("exit", () => console.debug("Node worker closing"));
       } else {
         globalThis.onmessage = handleMessage;
@@ -659,7 +664,7 @@ function isKnownMessage(message) {
   return type === "message" && data && typeof data.source === "string" && data.source.startsWith("loaders.gl");
 }
 
-// src/lib/worker-api/get-worker-url.ts
+// dist/lib/worker-api/get-worker-url.js
 function getWorkerName(worker) {
   const warning = worker.version !== VERSION ? ` (worker-utils@${VERSION})` : "";
   return `${worker.name}@${worker.version}${warning}`;
@@ -690,7 +695,7 @@ function getWorkerURL(worker, options2 = {}) {
   return url;
 }
 
-// src/lib/worker-api/process-on-worker.ts
+// dist/lib/worker-api/process-on-worker.js
 function canProcessOnWorker(worker, options2) {
   if (!WorkerFarm.isSupported()) {
     return false;
@@ -744,8 +749,11 @@ async function onMessage(context, job, type, payload) {
   }
 }
 
-// src/lib/async-queue/async-queue.ts
+// dist/lib/async-queue/async-queue.js
 var AsyncQueue = class {
+  _values;
+  _settlers;
+  _closed;
   constructor() {
     this._values = [];
     this._settlers = [];
@@ -811,7 +819,7 @@ var AsyncQueue = class {
   }
 };
 
-// src/lib/worker-api/create-worker.ts
+// dist/lib/worker-api/create-worker.js
 var requestId = 0;
 var inputBatches;
 var options;
@@ -883,7 +891,7 @@ function processOnMainThread(arrayBuffer, options2 = {}) {
   });
 }
 
-// src/lib/worker-api/validate-worker-version.ts
+// dist/lib/worker-api/validate-worker-version.js
 function validateWorkerVersion(worker, coreVersion = VERSION) {
   assert(worker, "no worker provided");
   const workerVersion = worker.version;
@@ -893,8 +901,10 @@ function validateWorkerVersion(worker, coreVersion = VERSION) {
   return true;
 }
 
-// src/lib/library-utils/library-utils.ts
-var node = __toESM(require_require_utils(), 1);
+// (disabled):dist/lib/node/require-utils.node.js
+var require_utils_node_exports = {};
+
+// dist/lib/library-utils/library-utils.js
 var loadLibraryPromises = {};
 async function loadLibrary(libraryUrl, moduleName = null, options2 = {}, libraryName = null) {
   if (moduleName) {
@@ -931,7 +941,7 @@ async function loadLibraryFromFile(libraryUrl) {
   }
   if (!isBrowser) {
     try {
-      return node && void 0 && await (void 0)(libraryUrl);
+      return require_utils_node_exports && void 0 && await (void 0)(libraryUrl);
     } catch (error) {
       console.error(error);
       return null;
@@ -976,8 +986,136 @@ async function loadAsText(url) {
   return await (void 0)(url);
 }
 
-// src/index.ts
-var import_child_process_proxy = __toESM(require_child_process_proxy(), 1);
+// dist/lib/process-utils/child-process-proxy.js
+var ChildProcess2 = __toESM(require("child_process"), 1);
+
+// dist/lib/process-utils/process-utils.js
+var import_child_process = __toESM(require("child_process"), 1);
+function getAvailablePort(defaultPort = 3e3) {
+  return new Promise((resolve) => {
+    import_child_process.default.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);
+    });
+  });
+}
+
+// dist/lib/process-utils/child-process-proxy.js
+var DEFAULT_PROPS2 = {
+  command: "",
+  arguments: [],
+  port: 5e3,
+  autoPort: true,
+  wait: 2e3,
+  onSuccess: (processProxy) => {
+    console.log(`Started ${processProxy.props.command}`);
+  }
+};
+var ChildProcessProxy = class {
+  id;
+  props = { ...DEFAULT_PROPS2 };
+  childProcess = null;
+  port = 0;
+  successTimer;
+  // NodeJS.Timeout;
+  // constructor(props?: {id?: string});
+  constructor({ id = "browser-driver" } = {}) {
+    this.id = id;
+  }
+  /** Starts a child process with the provided props */
+  async start(props) {
+    props = { ...DEFAULT_PROPS2, ...props };
+    this.props = props;
+    const args = [...props.arguments];
+    this.port = Number(props.port);
+    if (props.portArg) {
+      if (props.autoPort) {
+        this.port = await 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 = ChildProcess2.spawn(props.command, args, props.spawn);
+        this.childProcess = childProcess;
+        childProcess.stdout.on("data", (data) => {
+          console.log(data.toString());
+        });
+        childProcess.stderr.on("data", (data) => {
+          console.log(`Child process wrote to stderr: "${data}".`);
+          if (!props.ignoreStderr) {
+            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();
+      process.exit(statusCode);
+    } catch (error) {
+      console.error(error.message || error);
+      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);
+    }
+  }
+};
+
+// dist/index.js
 var NullWorker = {
   id: "null",
   name: "null",
@@ -987,3 +1125,4 @@ var NullWorker = {
     null: {}
   }
 };
+//# sourceMappingURL=index.cjs.map