@loaders.gl/worker-utils 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/es5/index.js

@@ -0,0 +1,160 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "assert", {
+  enumerable: true,
+  get: function () {
+    return _assert.assert;
+  }
+});
+Object.defineProperty(exports, "isBrowser", {
+  enumerable: true,
+  get: function () {
+    return _globals.isBrowser;
+  }
+});
+Object.defineProperty(exports, "isWorker", {
+  enumerable: true,
+  get: function () {
+    return _globals.isWorker;
+  }
+});
+Object.defineProperty(exports, "WorkerJob", {
+  enumerable: true,
+  get: function () {
+    return _workerJob.default;
+  }
+});
+Object.defineProperty(exports, "WorkerThread", {
+  enumerable: true,
+  get: function () {
+    return _workerThread.default;
+  }
+});
+Object.defineProperty(exports, "WorkerFarm", {
+  enumerable: true,
+  get: function () {
+    return _workerFarm.default;
+  }
+});
+Object.defineProperty(exports, "WorkerPool", {
+  enumerable: true,
+  get: function () {
+    return _workerPool.default;
+  }
+});
+Object.defineProperty(exports, "WorkerBody", {
+  enumerable: true,
+  get: function () {
+    return _workerBody.default;
+  }
+});
+Object.defineProperty(exports, "processOnWorker", {
+  enumerable: true,
+  get: function () {
+    return _processOnWorker.processOnWorker;
+  }
+});
+Object.defineProperty(exports, "canProcessOnWorker", {
+  enumerable: true,
+  get: function () {
+    return _processOnWorker.canProcessOnWorker;
+  }
+});
+Object.defineProperty(exports, "createWorker", {
+  enumerable: true,
+  get: function () {
+    return _createWorker.createWorker;
+  }
+});
+Object.defineProperty(exports, "getWorkerURL", {
+  enumerable: true,
+  get: function () {
+    return _getWorkerUrl.getWorkerURL;
+  }
+});
+Object.defineProperty(exports, "validateWorkerVersion", {
+  enumerable: true,
+  get: function () {
+    return _validateWorkerVersion.validateWorkerVersion;
+  }
+});
+Object.defineProperty(exports, "getTransferList", {
+  enumerable: true,
+  get: function () {
+    return _getTransferList.getTransferList;
+  }
+});
+Object.defineProperty(exports, "getLibraryUrl", {
+  enumerable: true,
+  get: function () {
+    return _libraryUtils.getLibraryUrl;
+  }
+});
+Object.defineProperty(exports, "loadLibrary", {
+  enumerable: true,
+  get: function () {
+    return _libraryUtils.loadLibrary;
+  }
+});
+Object.defineProperty(exports, "AsyncQueue", {
+  enumerable: true,
+  get: function () {
+    return _asyncQueue.default;
+  }
+});
+Object.defineProperty(exports, "ChildProcessProxy", {
+  enumerable: true,
+  get: function () {
+    return _childProcessProxy.default;
+  }
+});
+exports.NullWorker = void 0;
+
+var _version = require("./lib/env-utils/version");
+
+var _assert = require("./lib/env-utils/assert");
+
+var _globals = require("./lib/env-utils/globals");
+
+var _workerJob = _interopRequireDefault(require("./lib/worker-farm/worker-job"));
+
+var _workerThread = _interopRequireDefault(require("./lib/worker-farm/worker-thread"));
+
+var _workerFarm = _interopRequireDefault(require("./lib/worker-farm/worker-farm"));
+
+var _workerPool = _interopRequireDefault(require("./lib/worker-farm/worker-pool"));
+
+var _workerBody = _interopRequireDefault(require("./lib/worker-farm/worker-body"));
+
+var _processOnWorker = require("./lib/worker-api/process-on-worker");
+
+var _createWorker = require("./lib/worker-api/create-worker");
+
+var _getWorkerUrl = require("./lib/worker-api/get-worker-url");
+
+var _validateWorkerVersion = require("./lib/worker-api/validate-worker-version");
+
+var _getTransferList = require("./lib/worker-utils/get-transfer-list");
+
+var _libraryUtils = require("./lib/library-utils/library-utils");
+
+var _asyncQueue = _interopRequireDefault(require("./lib/async-queue/async-queue"));
+
+var _childProcessProxy = _interopRequireDefault(require("./lib/process-utils/child-process-proxy"));
+
+const NullWorker = {
+  id: 'null',
+  name: 'null',
+  module: 'worker-utils',
+  version: _version.VERSION,
+  options: {
+    null: {}
+  }
+};
+exports.NullWorker = NullWorker;
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"names":["NullWorker","id","name","module","version","VERSION","options","null"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;;AAcA;;AACA;;AAGA;;AACA;;AAGA;;AACA;;AACA;;AAEA;;AACA;;AAGA;;AACA;;AACA;;AAGA;;AAGA;;AAGA;;AAKO,MAAMA,UAAwB,GAAG;AACtCC,EAAAA,EAAE,EAAE,MADkC;AAEtCC,EAAAA,IAAI,EAAE,MAFgC;AAGtCC,EAAAA,MAAM,EAAE,cAH8B;AAItCC,EAAAA,OAAO,EAAEC,gBAJ6B;AAKtCC,EAAAA,OAAO,EAAE;AACPC,IAAAA,IAAI,EAAE;AADC;AAL6B,CAAjC","sourcesContent":["import type {WorkerObject} from './types';\nimport {VERSION} from './lib/env-utils/version';\n\n// TYPES\nexport type {\n  WorkerObject,\n  WorkerOptions,\n  // Protocol\n  WorkerMessage,\n  WorkerMessageType,\n  WorkerMessageData,\n  WorkerMessagePayload\n} from './types';\n\n// GENERAL UTILS\nexport {assert} from './lib/env-utils/assert';\nexport {isBrowser, isWorker} from './lib/env-utils/globals';\n\n// WORKER UTILS - TYPES\nexport {default as WorkerJob} from './lib/worker-farm/worker-job';\nexport {default as WorkerThread} from './lib/worker-farm/worker-thread';\n\n// WORKER FARMS\nexport {default as WorkerFarm} from './lib/worker-farm/worker-farm';\nexport {default as WorkerPool} from './lib/worker-farm/worker-pool';\nexport {default as WorkerBody} from './lib/worker-farm/worker-body';\n\nexport {processOnWorker, canProcessOnWorker} from './lib/worker-api/process-on-worker';\nexport {createWorker} from './lib/worker-api/create-worker';\n\n// WORKER UTILS - EXPORTS\nexport {getWorkerURL} from './lib/worker-api/get-worker-url';\nexport {validateWorkerVersion} from './lib/worker-api/validate-worker-version';\nexport {getTransferList} from './lib/worker-utils/get-transfer-list';\n\n// LIBRARY UTILS\nexport {getLibraryUrl, loadLibrary} from './lib/library-utils/library-utils';\n\n// PARSER UTILS\nexport {default as AsyncQueue} from './lib/async-queue/async-queue';\n\n// PROCESS UTILS\nexport {default as ChildProcessProxy} from './lib/process-utils/child-process-proxy';\n\n// WORKER OBJECTS\n\n/** A null worker to test that worker processing is functional */\nexport const NullWorker: WorkerObject = {\n  id: 'null',\n  name: 'null',\n  module: 'worker-utils',\n  version: VERSION,\n  options: {\n    null: {}\n  }\n};\n"],"file":"index.js"}

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

@@ -0,0 +1,106 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+let _Symbol$asyncIterator;
+
+_Symbol$asyncIterator = Symbol.asyncIterator;
+
+class AsyncQueue {
+  constructor() {
+    (0, _defineProperty2.default)(this, "_values", void 0);
+    (0, _defineProperty2.default)(this, "_settlers", void 0);
+    (0, _defineProperty2.default)(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');
+    }
+
+    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);
+    }
+  }
+
+  close() {
+    while (this._settlers.length > 0) {
+      const settler = this._settlers.shift();
+
+      settler.resolve({
+        done: true
+      });
+    }
+
+    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
+      });
+    }
+
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error('Illegal internal state');
+      }
+
+      return Promise.resolve({
+        done: true,
+        value: undefined
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      this._settlers.push({
+        resolve,
+        reject
+      });
+    });
+  }
+
+}
+
+exports.default = AsyncQueue;
+//# sourceMappingURL=async-queue.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/async-queue/async-queue.ts"],"names":["Symbol","asyncIterator","AsyncQueue","constructor","_values","_settlers","_closed","push","value","enqueue","Error","length","settler","shift","reject","resolve","close","done","next","Promise","undefined"],"mappings":";;;;;;;;;;;;;wBA2BGA,MAAM,CAACC,a;;AAZK,MAAMC,UAAN,CAAoB;AAKjCC,EAAAA,WAAW,GAAG;AAAA;AAAA;AAAA;AACZ,SAAKC,OAAL,GAAe,EAAf;AACA,SAAKC,SAAL,GAAiB,EAAjB;AACA,SAAKC,OAAL,GAAe,KAAf;AACD;;AAGD,4BAA2C;AACzC,WAAO,IAAP;AACD;;AAGDC,EAAAA,IAAI,CAACC,KAAD,EAAiB;AACnB,WAAO,KAAKC,OAAL,CAAaD,KAAb,CAAP;AACD;;AAMDC,EAAAA,OAAO,CAACD,KAAD,EAAyB;AAC9B,QAAI,KAAKF,OAAT,EAAkB;AAChB,YAAM,IAAII,KAAJ,CAAU,QAAV,CAAN;AACD;;AAED,QAAI,KAAKL,SAAL,CAAeM,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,UAAI,KAAKP,OAAL,CAAaO,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,cAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,YAAME,OAAO,GAAG,KAAKP,SAAL,CAAeQ,KAAf,EAAhB;;AACA,UAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1BE,QAAAA,OAAO,CAACE,MAAR,CAAeN,KAAf;AACD,OAFD,MAEO;AACLI,QAAAA,OAAO,CAACG,OAAR,CAAgB;AAACP,UAAAA;AAAD,SAAhB;AACD;AACF,KAVD,MAUO;AACL,WAAKJ,OAAL,CAAaG,IAAb,CAAkBC,KAAlB;AACD;AACF;;AAGDQ,EAAAA,KAAK,GAAS;AACZ,WAAO,KAAKX,SAAL,CAAeM,MAAf,GAAwB,CAA/B,EAAkC;AAChC,YAAMC,OAAO,GAAG,KAAKP,SAAL,CAAeQ,KAAf,EAAhB;;AACAD,MAAAA,OAAO,CAACG,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE;AAAP,OAAhB;AACD;;AACD,SAAKX,OAAL,GAAe,IAAf;AACD;;AAKDY,EAAAA,IAAI,GAAoC;AAEtC,QAAI,KAAKd,OAAL,CAAaO,MAAb,GAAsB,CAA1B,EAA6B;AAC3B,YAAMH,KAAK,GAAG,KAAKJ,OAAL,CAAaS,KAAb,EAAd;;AACA,UAAIL,KAAK,YAAYE,KAArB,EAA4B;AAC1B,eAAOS,OAAO,CAACL,MAAR,CAAeN,KAAf,CAAP;AACD;;AACD,aAAOW,OAAO,CAACJ,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE,KAAP;AAAcT,QAAAA;AAAd,OAAhB,CAAP;AACD;;AAGD,QAAI,KAAKF,OAAT,EAAkB;AAChB,UAAI,KAAKD,SAAL,CAAeM,MAAf,GAAwB,CAA5B,EAA+B;AAC7B,cAAM,IAAID,KAAJ,CAAU,wBAAV,CAAN;AACD;;AACD,aAAOS,OAAO,CAACJ,OAAR,CAAgB;AAACE,QAAAA,IAAI,EAAE,IAAP;AAAaT,QAAAA,KAAK,EAAEY;AAApB,OAAhB,CAAP;AACD;;AAGD,WAAO,IAAID,OAAJ,CAAY,CAACJ,OAAD,EAAUD,MAAV,KAAqB;AACtC,WAAKT,SAAL,CAAeE,IAAf,CAAoB;AAACQ,QAAAA,OAAD;AAAUD,QAAAA;AAAV,OAApB;AACD,KAFM,CAAP;AAGD;;AA/EgC","sourcesContent":["// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\n/**\n * Async Queue\n * - AsyncIterable: An async iterator can be\n * - Values can be pushed onto the queue\n * @example\n *   const asyncQueue = new AsyncQueue();\n *   setTimeout(() => asyncQueue.enqueue('tick'), 1000);\n *   setTimeout(() => asyncQueue.enqueue(new Error('done')), 10000);\n *   for await (const value of asyncQueue) {\n *     console.log(value); // tick\n *   }\n */\nexport default class AsyncQueue<T> {\n  private _values: any[];\n  private _settlers: any[];\n  private _closed: boolean;\n\n  constructor() {\n    this._values = []; // enqueues > dequeues\n    this._settlers = []; // dequeues > enqueues\n    this._closed = false;\n  }\n\n  /** Return an async iterator for this queue */\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  /** Push a new value - the async iterator will yield a promise resolved to this value */\n  push(value: T): void {\n    return this.enqueue(value);\n  }\n\n  /**\n   * Push a new value - the async iterator will yield a promise resolved to this value\n   * Add an error - the async iterator will yield a promise rejected with this value\n   */\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.shift();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.push(value);\n    }\n  }\n\n  /** Indicate that we not waiting for more values - The async iterator will be done */\n  close(): void {\n    while (this._settlers.length > 0) {\n      const settler = this._settlers.shift();\n      settler.resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  // ITERATOR IMPLEMENTATION\n\n  /** @returns a Promise for an IteratorResult */\n  next(): Promise<IteratorResult<T, any>> {\n    // If values in queue, yield the first value\n    if (this._values.length > 0) {\n      const value = this._values.shift();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({done: false, value});\n    }\n\n    // If queue is closed, the iterator is done\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true, value: undefined});\n    }\n\n    // Yield a promise that waits for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.push({resolve, reject});\n    });\n  }\n}\n"],"file":"async-queue.js"}

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assert = assert;
+
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message || 'loaders.gl assertion failed.');
+  }
+}
+//# sourceMappingURL=assert.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/env-utils/assert.ts"],"names":["assert","condition","message","Error"],"mappings":";;;;;;;AAKO,SAASA,MAAT,CAAgBC,SAAhB,EAAgCC,OAAhC,EAAwD;AAC7D,MAAI,CAACD,SAAL,EAAgB;AACd,UAAM,IAAIE,KAAJ,CAAUD,OAAO,IAAI,8BAArB,CAAN;AACD;AACF","sourcesContent":["// Replacement for the external assert method to reduce bundle size\n// Note: We don't use the second \"message\" argument in calling code,\n// so no need to support it here\n\n/** Throws an `Error` with the optional `message` if `condition` is falsy */\nexport function assert(condition: any, message?: string): void {\n  if (!condition) {\n    throw new Error(message || 'loaders.gl assertion failed.');\n  }\n}\n"],"file":"assert.js"}

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

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.nodeVersion = exports.isMobile = exports.isWorker = exports.isBrowser = exports.document = exports.global = exports.window = exports.self = void 0;
+const globals = {
+  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 || {};
+exports.self = self_;
+const window_ = globals.window || globals.self || globals.global || {};
+exports.window = window_;
+const global_ = globals.global || globals.self || globals.window || {};
+exports.global = global_;
+const document_ = globals.document || {};
+exports.document = document_;
+const isBrowser = typeof process !== 'object' || String(process) !== '[object process]' || process.browser;
+exports.isBrowser = isBrowser;
+const isWorker = typeof importScripts === 'function';
+exports.isWorker = isWorker;
+const isMobile = typeof window !== 'undefined' && typeof window.orientation !== 'undefined';
+exports.isMobile = isMobile;
+const matches = typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);
+const nodeVersion = matches && parseFloat(matches[1]) || 0;
+exports.nodeVersion = nodeVersion;
+//# sourceMappingURL=globals.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/env-utils/globals.ts"],"names":["globals","self","window","global","document","self_","window_","global_","document_","isBrowser","process","String","browser","isWorker","importScripts","isMobile","orientation","matches","version","exec","nodeVersion","parseFloat"],"mappings":";;;;;;AAIA,MAAMA,OAAO,GAAG;AACdC,EAAAA,IAAI,EAAE,OAAOA,IAAP,KAAgB,WAAhB,IAA+BA,IADvB;AAEdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAF3B;AAGdC,EAAAA,MAAM,EAAE,OAAOA,MAAP,KAAkB,WAAlB,IAAiCA,MAH3B;AAIdC,EAAAA,QAAQ,EAAE,OAAOA,QAAP,KAAoB,WAApB,IAAmCA;AAJ/B,CAAhB;AAOA,MAAMC,KAA2B,GAAGL,OAAO,CAACC,IAAR,IAAgBD,OAAO,CAACE,MAAxB,IAAkCF,OAAO,CAACG,MAA1C,IAAoD,EAAxF;;AACA,MAAMG,OAA6B,GAAGN,OAAO,CAACE,MAAR,IAAkBF,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACG,MAA1C,IAAoD,EAA1F;;AACA,MAAMI,OAA6B,GAAGP,OAAO,CAACG,MAAR,IAAkBH,OAAO,CAACC,IAA1B,IAAkCD,OAAO,CAACE,MAA1C,IAAoD,EAA1F;;AACA,MAAMM,SAA+B,GAAGR,OAAO,CAACI,QAAR,IAAoB,EAA5D;;AAKO,MAAMK,SAAkB,GAE7B,OAAOC,OAAP,KAAmB,QAAnB,IAA+BC,MAAM,CAACD,OAAD,CAAN,KAAoB,kBAAnD,IAAyEA,OAAO,CAACE,OAF5E;;AAKA,MAAMC,QAAiB,GAAG,OAAOC,aAAP,KAAyB,UAAnD;;AAGA,MAAMC,QAAiB,GAC5B,OAAOb,MAAP,KAAkB,WAAlB,IAAiC,OAAOA,MAAM,CAACc,WAAd,KAA8B,WAD1D;;AAIP,MAAMC,OAAO,GACX,OAAOP,OAAP,KAAmB,WAAnB,IAAkCA,OAAO,CAACQ,OAA1C,IAAqD,YAAYC,IAAZ,CAAiBT,OAAO,CAACQ,OAAzB,CADvD;AAIO,MAAME,WAAmB,GAAIH,OAAO,IAAII,UAAU,CAACJ,OAAO,CAAC,CAAD,CAAR,CAAtB,IAAuC,CAAnE","sourcesContent":["// Purpose: include this in your module to avoids adding dependencies on\n// micro modules like 'global' and 'is-browser';\n\n/* eslint-disable no-restricted-globals */\nconst globals = {\n  self: typeof self !== 'undefined' && self,\n  window: typeof window !== 'undefined' && window,\n  global: typeof global !== 'undefined' && global,\n  document: typeof document !== 'undefined' && document\n};\n\nconst self_: {[key: string]: any} = globals.self || globals.window || globals.global || {};\nconst window_: {[key: string]: any} = globals.window || globals.self || globals.global || {};\nconst global_: {[key: string]: any} = globals.global || globals.self || globals.window || {};\nconst document_: {[key: string]: any} = globals.document || {};\n\nexport {self_ as self, window_ as window, global_ as global, document_ as document};\n\n/** true if running in the browser, false if running in Node.js */\nexport const isBrowser: boolean =\n  // @ts-ignore process.browser\n  typeof process !== 'object' || String(process) !== '[object process]' || process.browser;\n\n/** true if running on a worker thread */\nexport const isWorker: boolean = typeof importScripts === 'function';\n\n/** true if running on a mobile device */\nexport const isMobile: boolean =\n  typeof window !== 'undefined' && typeof window.orientation !== 'undefined';\n\n// Extract node major version\nconst matches =\n  typeof process !== 'undefined' && process.version && /v([0-9]*)/.exec(process.version);\n\n/** Version of Node.js if running under Node, otherwise 0 */\nexport const nodeVersion: number = (matches && parseFloat(matches[1])) || 0;\n"],"file":"globals.js"}

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

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.VERSION = void 0;
+const DEFAULT_VERSION = 'beta';
+const VERSION = typeof "3.1.0-beta.1" !== 'undefined' ? "3.1.0-beta.1" : DEFAULT_VERSION;
+exports.VERSION = VERSION;
+
+if (typeof "3.1.0-beta.1" === 'undefined') {
+  console.error('loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.');
+}
+//# sourceMappingURL=version.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/env-utils/version.ts"],"names":["DEFAULT_VERSION","VERSION","console","error"],"mappings":";;;;;;AAIA,MAAMA,eAAe,GAAG,MAAxB;AAEO,MAAMC,OAAO,GAAG,0BAAuB,WAAvB,oBAAmDD,eAAnE;;;AACP,IAAI,0BAAuB,WAA3B,EAAwC;AAEtCE,EAAAA,OAAO,CAACC,KAAR,CACE,iIADF;AAGD","sourcesContent":["// Version constant cannot be imported, it needs to correspond to the build version of **this** module.\n// __VERSION__ is injected by babel-plugin-version-inline\n\n// Change to `latest` on production branches\nconst DEFAULT_VERSION = 'beta';\ndeclare let __VERSION__: string;\nexport const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : DEFAULT_VERSION;\nif (typeof __VERSION__ === 'undefined') {\n  // eslint-disable-next-line\n  console.error(\n    'loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.'\n  );\n}\n"],"file":"version.js"}

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

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadLibrary = loadLibrary;
+exports.getLibraryUrl = getLibraryUrl;
+
+var _globals = require("../env-utils/globals");
+
+var node = _interopRequireWildcard(require("../node/require-utils.node"));
+
+var _assert = require("../env-utils/assert");
+
+var _version = require("../env-utils/version");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const LATEST = 'beta';
+const VERSION = typeof "3.1.0-beta.1" !== 'undefined' ? "3.1.0-beta.1" : LATEST;
+const loadLibraryPromises = {};
+
+async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+  if (moduleName) {
+    libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+  }
+
+  loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+  return await loadLibraryPromises[libraryUrl];
+}
+
+function getLibraryUrl(library, moduleName, options) {
+  if (library.startsWith('http')) {
+    return library;
+  }
+
+  const modules = options.modules || {};
+
+  if (modules[library]) {
+    return modules[library];
+  }
+
+  if (!_globals.isBrowser) {
+    return "modules/".concat(moduleName, "/dist/libs/").concat(library);
+  }
+
+  if (options.CDN) {
+    (0, _assert.assert)(options.CDN.startsWith('http'));
+    return "".concat(options.CDN, "/").concat(moduleName, "@").concat(VERSION, "/dist/libs/").concat(library);
+  }
+
+  if (_globals.isWorker) {
+    return "../src/libs/".concat(library);
+  }
+
+  return "modules/".concat(moduleName, "/src/libs/").concat(library);
+}
+
+async function loadLibraryFromFile(libraryUrl) {
+  if (libraryUrl.endsWith('wasm')) {
+    const response = await fetch(libraryUrl);
+    return await response.arrayBuffer();
+  }
+
+  if (!_globals.isBrowser) {
+    return node.requireFromFile && (await node.requireFromFile(libraryUrl));
+  }
+
+  if (_globals.isWorker) {
+    return importScripts(libraryUrl);
+  }
+
+  const response = await fetch(libraryUrl);
+  const scriptSource = await response.text();
+  return loadLibraryFromString(scriptSource, libraryUrl);
+}
+
+function loadLibraryFromString(scriptSource, id) {
+  if (!_globals.isBrowser) {
+    return node.requireFromString && node.requireFromString(scriptSource, id);
+  }
+
+  if (_globals.isWorker) {
+    eval.call(_globals.global, scriptSource);
+    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;
+}
+//# sourceMappingURL=library-utils.js.map

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.requireFromFile = requireFromFile;
+exports.requireFromString = requireFromString;
+
+var _module = _interopRequireDefault(require("module"));
+
+var _path = _interopRequireDefault(require("path"));
+
+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 = "".concat(process.cwd(), "/").concat(filename);
+  }
+
+  return require(filename);
+}
+
+function requireFromString(code, filename = '', options) {
+  var _options, _options2;
+
+  if (typeof filename === 'object') {
+    options = filename;
+    filename = '';
+  }
+
+  if (typeof code !== 'string') {
+    throw new Error("code must be a string, not ".concat(typeof code));
+  }
+
+  const paths = _module.default._nodeModulePaths(_path.default.dirname(filename));
+
+  const parent = module.parent;
+  const newModule = new _module.default(filename, parent);
+  newModule.filename = filename;
+  newModule.paths = [].concat(((_options = options) === null || _options === void 0 ? void 0 : _options.prependPaths) || []).concat(paths).concat(((_options2 = options) === null || _options2 === void 0 ? void 0 : _options2.appendPaths) || []);
+
+  newModule._compile(code, filename);
+
+  if (parent && parent.children) {
+    parent.children.splice(parent.children.indexOf(newModule), 1);
+  }
+
+  return newModule.exports;
+}
+//# sourceMappingURL=require-utils.node.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/node/require-utils.node.ts"],"names":["requireFromFile","filename","startsWith","response","fetch","code","text","requireFromString","process","cwd","require","options","Error","paths","Module","_nodeModulePaths","path","dirname","parent","module","newModule","concat","prependPaths","appendPaths","_compile","children","splice","indexOf","exports"],"mappings":";;;;;;;;;;AAMA;;AACA;;AAMO,eAAeA,eAAf,CAA+BC,QAA/B,EAA+D;AACpE,MAAIA,QAAQ,CAACC,UAAT,CAAoB,MAApB,CAAJ,EAAiC;AAC/B,UAAMC,QAAQ,GAAG,MAAMC,KAAK,CAACH,QAAD,CAA5B;AACA,UAAMI,IAAI,GAAG,MAAMF,QAAQ,CAACG,IAAT,EAAnB;AACA,WAAOC,iBAAiB,CAACF,IAAD,CAAxB;AACD;;AAED,MAAI,CAACJ,QAAQ,CAACC,UAAT,CAAoB,GAApB,CAAL,EAA+B;AAC7BD,IAAAA,QAAQ,aAAMO,OAAO,CAACC,GAAR,EAAN,cAAuBR,QAAvB,CAAR;AACD;;AACD,SAAOS,OAAO,CAACT,QAAD,CAAd;AACD;;AAQM,SAASM,iBAAT,CACLF,IADK,EAELJ,QAAQ,GAAG,EAFN,EAGLU,OAHK,EAOA;AAAA;;AACL,MAAI,OAAOV,QAAP,KAAoB,QAAxB,EAAkC;AAChCU,IAAAA,OAAO,GAAGV,QAAV;AACAA,IAAAA,QAAQ,GAAG,EAAX;AACD;;AAED,MAAI,OAAOI,IAAP,KAAgB,QAApB,EAA8B;AAC5B,UAAM,IAAIO,KAAJ,sCAAwC,OAAOP,IAA/C,EAAN;AACD;;AAGD,QAAMQ,KAAK,GAAGC,gBAAOC,gBAAP,CAAwBC,cAAKC,OAAL,CAAahB,QAAb,CAAxB,CAAd;;AAEA,QAAMiB,MAAM,GAAGC,MAAM,CAACD,MAAtB;AAEA,QAAME,SAAS,GAAG,IAAIN,eAAJ,CAAWb,QAAX,EAAqBiB,MAArB,CAAlB;AACAE,EAAAA,SAAS,CAACnB,QAAV,GAAqBA,QAArB;AACAmB,EAAAA,SAAS,CAACP,KAAV,GAAmB,EAAD,CACfQ,MADe,CACR,aAAAV,OAAO,UAAP,4CAASW,YAAT,KAAyB,EADjB,EAEfD,MAFe,CAERR,KAFQ,EAGfQ,MAHe,CAGR,cAAAV,OAAO,UAAP,8CAASY,WAAT,KAAwB,EAHhB,CAAlB;;AAKAH,EAAAA,SAAS,CAACI,QAAV,CAAmBnB,IAAnB,EAAyBJ,QAAzB;;AAEA,MAAIiB,MAAM,IAAIA,MAAM,CAACO,QAArB,EAA+B;AAC7BP,IAAAA,MAAM,CAACO,QAAP,CAAgBC,MAAhB,CAAuBR,MAAM,CAACO,QAAP,CAAgBE,OAAhB,CAAwBP,SAAxB,CAAvB,EAA2D,CAA3D;AACD;;AAED,SAAOA,SAAS,CAACQ,OAAjB;AACD","sourcesContent":["// Fork of https://github.com/floatdrop/require-from-string/blob/master/index.js\n// Copyright (c) Vsevolod Strukchinsky <floatdrop@gmail.com> (github.com/floatdrop)\n// MIT license\n\n// this file is not visible to webpack (it is excluded in the package.json \"browser\" field).\n\nimport Module from 'module';\nimport path from 'path';\n\n// Node.js Dynamically require from file\n// Relative names are resolved relative to cwd\n// This indirect function is provided because webpack will try to bundle `module.require`.\n// this file is not visible to webpack (it is excluded in the package.json \"browser\" field).\nexport async function requireFromFile(filename: string): Promise<any> {\n  if (filename.startsWith('http')) {\n    const response = await fetch(filename);\n    const code = await response.text();\n    return requireFromString(code);\n  }\n\n  if (!filename.startsWith('/')) {\n    filename = `${process.cwd()}/${filename}`;\n  }\n  return require(filename);\n}\n\n// Dynamically require from string\n// - `code` - Required - Type: string - Module code.\n// - `filename` - Type: string - Default: '' - Optional filename.\n// - `options.appendPaths` Type: Array List of paths, that will be appended to module paths.\n// Useful, when you want to be able require modules from these paths.\n// - `options.prependPaths` Type: Array Same as appendPaths, but paths will be prepended.\nexport function requireFromString(\n  code: string,\n  filename = '',\n  options?: {\n    prependPaths?: string[];\n    appendPaths?: string[];\n  }\n): any {\n  if (typeof filename === 'object') {\n    options = filename;\n    filename = '';\n  }\n\n  if (typeof code !== 'string') {\n    throw new Error(`code must be a string, not ${typeof code}`);\n  }\n\n  // @ts-ignore\n  const paths = Module._nodeModulePaths(path.dirname(filename));\n\n  const parent = module.parent;\n  // @ts-ignore\n  const newModule = new Module(filename, parent);\n  newModule.filename = filename;\n  newModule.paths = ([] as string[])\n    .concat(options?.prependPaths || [])\n    .concat(paths)\n    .concat(options?.appendPaths || []);\n  // @ts-ignore\n  newModule._compile(code, filename);\n\n  if (parent && parent.children) {\n    parent.children.splice(parent.children.indexOf(newModule), 1);\n  }\n\n  return newModule.exports;\n}\n"],"file":"require-utils.node.js"}