@loaders.gl/textures 3.1.0-beta.2 → 3.1.0

package/dist/es5/lib/texture-api/async-deep-map.js

@@ -1,48 +1,177 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.asyncDeepMap = asyncDeepMap;
 exports.mapSubtree = mapSubtree;
 
-const isObject = value => value && typeof value === 'object';
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
+var isObject = function isObject(value) {
+  return value && (0, _typeof2.default)(value) === 'object';
+};
 
-async function asyncDeepMap(tree, func, options = {}) {
-  return await mapSubtree(tree, func, options);
+function asyncDeepMap(_x, _x2) {
+  return _asyncDeepMap.apply(this, arguments);
 }
 
-async function mapSubtree(object, func, options) {
-  if (Array.isArray(object)) {
-    return await mapArray(object, func, options);
-  }
+function _asyncDeepMap() {
+  _asyncDeepMap = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(tree, func) {
+    var options,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+            _context.next = 3;
+            return mapSubtree(tree, func, options);
+
+          case 3:
+            return _context.abrupt("return", _context.sent);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _asyncDeepMap.apply(this, arguments);
+}
+
+function mapSubtree(_x3, _x4, _x5) {
+  return _mapSubtree.apply(this, arguments);
+}
+
+function _mapSubtree() {
+  _mapSubtree = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(object, func, options) {
+    var url;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!Array.isArray(object)) {
+              _context2.next = 4;
+              break;
+            }
+
+            _context2.next = 3;
+            return mapArray(object, func, options);
+
+          case 3:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 4:
+            if (!isObject(object)) {
+              _context2.next = 8;
+              break;
+            }
 
-  if (isObject(object)) {
-    return await mapObject(object, func, options);
-  }
+            _context2.next = 7;
+            return mapObject(object, func, options);
 
-  const url = object;
-  return await func(url, options);
+          case 7:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 8:
+            url = object;
+            _context2.next = 11;
+            return func(url, options);
+
+          case 11:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 12:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _mapSubtree.apply(this, arguments);
 }
 
-async function mapObject(object, func, options) {
-  const promises = [];
-  const values = {};
+function mapObject(_x6, _x7, _x8) {
+  return _mapObject.apply(this, arguments);
+}
+
+function _mapObject() {
+  _mapObject = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee3(object, func, options) {
+    var promises, values, _loop, key;
+
+    return _regenerator.default.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            promises = [];
+            values = {};
+
+            _loop = function _loop(key) {
+              var url = object[key];
+              var promise = mapSubtree(url, func, options).then(function (value) {
+                values[key] = value;
+              });
+              promises.push(promise);
+            };
 
-  for (const key in object) {
-    const url = object[key];
-    const promise = mapSubtree(url, func, options).then(value => {
-      values[key] = value;
-    });
-    promises.push(promise);
-  }
+            for (key in object) {
+              _loop(key);
+            }
 
-  await Promise.all(promises);
-  return values;
+            _context3.next = 6;
+            return Promise.all(promises);
+
+          case 6:
+            return _context3.abrupt("return", values);
+
+          case 7:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _mapObject.apply(this, arguments);
+}
+
+function mapArray(_x9, _x10) {
+  return _mapArray.apply(this, arguments);
 }
 
-async function mapArray(urlArray, func, options = {}) {
-  const promises = urlArray.map(url => mapSubtree(url, func, options));
-  return await Promise.all(promises);
+function _mapArray() {
+  _mapArray = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee4(urlArray, func) {
+    var options,
+        promises,
+        _args4 = arguments;
+    return _regenerator.default.wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            options = _args4.length > 2 && _args4[2] !== undefined ? _args4[2] : {};
+            promises = urlArray.map(function (url) {
+              return mapSubtree(url, func, options);
+            });
+            _context4.next = 4;
+            return Promise.all(promises);
+
+          case 4:
+            return _context4.abrupt("return", _context4.sent);
+
+          case 5:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  }));
+  return _mapArray.apply(this, arguments);
 }
 //# sourceMappingURL=async-deep-map.js.map

package/dist/es5/lib/texture-api/async-deep-map.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/async-deep-map.ts"],"names":["isObject","value","asyncDeepMap","tree","func","options","mapSubtree","object","Array","isArray","mapArray","mapObject","url","promises","values","key","promise","then","push","Promise","all","urlArray","map"],"mappings":";;;;;;;;AAmBA,MAAMA,QAAQ,GAAIC,KAAD,IAAyBA,KAAK,IAAI,OAAOA,KAAP,KAAiB,QAApE;;AAKO,eAAeC,YAAf,CAA4BC,IAA5B,EAA2CC,IAA3C,EAAuDC,OAAgB,GAAG,EAA1E,EAA8E;AACnF,SAAO,MAAMC,UAAU,CAACH,IAAD,EAAOC,IAAP,EAAaC,OAAb,CAAvB;AACD;;AAEM,eAAeC,UAAf,CAA0BC,MAA1B,EAA2CH,IAA3C,EAAuDC,OAAvD,EAAyE;AAC9E,MAAIG,KAAK,CAACC,OAAN,CAAcF,MAAd,CAAJ,EAA2B;AACzB,WAAO,MAAMG,QAAQ,CAACH,MAAD,EAASH,IAAT,EAAeC,OAAf,CAArB;AACD;;AAED,MAAIL,QAAQ,CAACO,MAAD,CAAZ,EAAsB;AACpB,WAAO,MAAMI,SAAS,CAACJ,MAAD,EAAmBH,IAAnB,EAAyBC,OAAzB,CAAtB;AACD;;AAGD,QAAMO,GAAG,GAAGL,MAAZ;AACA,SAAO,MAAMH,IAAI,CAACQ,GAAD,EAAMP,OAAN,CAAjB;AACD;;AAID,eAAeM,SAAf,CACEJ,MADF,EAEEH,IAFF,EAGEC,OAHF,EAIgC;AAC9B,QAAMQ,QAAwB,GAAG,EAAjC;AACA,QAAMC,MAA2B,GAAG,EAApC;;AAEA,OAAK,MAAMC,GAAX,IAAkBR,MAAlB,EAA0B;AACxB,UAAMK,GAAG,GAAGL,MAAM,CAACQ,GAAD,CAAlB;AACA,UAAMC,OAAO,GAAGV,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAV,CAA+BY,IAA/B,CAAqChB,KAAD,IAAW;AAC7Da,MAAAA,MAAM,CAACC,GAAD,CAAN,GAAcd,KAAd;AACD,KAFe,CAAhB;AAGAY,IAAAA,QAAQ,CAACK,IAAT,CAAcF,OAAd;AACD;;AAED,QAAMG,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAAN;AAEA,SAAOC,MAAP;AACD;;AAED,eAAeJ,QAAf,CAAwBW,QAAxB,EAA4CjB,IAA5C,EAAwDC,OAAO,GAAG,EAAlE,EAAsF;AACpF,QAAMQ,QAAQ,GAAGQ,QAAQ,CAACC,GAAT,CAAcV,GAAD,IAASN,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAhC,CAAjB;AACA,SAAO,MAAMc,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAAb;AACD","sourcesContent":["// loaders.gl, MIT license\n/*\nAsynchronously maps a deep structure of values (e.g. objects and arrays of urls).\n\nE.g. a mipmapped cubemap\n{\n  [CUBE_FACE_FRONT]: [\n    \"image-front-0.jpg\",\n    \"image-front-1.jpg\",\n    \"image-front-2.jpg\",\n  ],\n  [CUBE_MAP_BACK]: [\n    ...\n  ]\n}\n*/\nexport type Options = Record<string, any>;\nexport type Func = (url: string, options: Options) => unknown;\n\nconst isObject = (value: any): boolean => value && typeof value === 'object';\n\n// Loads a deep structure of urls (objects and arrays of urls)\n// Returns an object with six key-value pairs containing the images (or image mip arrays)\n// for each cube face\nexport async function asyncDeepMap(tree: unknown, func: Func, options: Options = {}) {\n  return await mapSubtree(tree, func, options);\n}\n\nexport async function mapSubtree(object: unknown, func: Func, options: Options) {\n  if (Array.isArray(object)) {\n    return await mapArray(object, func, options);\n  }\n\n  if (isObject(object)) {\n    return await mapObject(object as object, func, options);\n  }\n\n  // TODO - ignore non-urls, non-arraybuffers?\n  const url = object as string;\n  return await func(url, options);\n}\n\n// HELPERS\n\nasync function mapObject(\n  object: Record<string, any>,\n  func: Func,\n  options: Options\n): Promise<Record<string, any>> {\n  const promises: Promise<any>[] = [];\n  const values: Record<string, any> = {};\n\n  for (const key in object) {\n    const url = object[key];\n    const promise = mapSubtree(url, func, options).then((value) => {\n      values[key] = value;\n    });\n    promises.push(promise);\n  }\n\n  await Promise.all(promises);\n\n  return values;\n}\n\nasync function mapArray(urlArray: string[], func: Func, options = {}): Promise<any[]> {\n  const promises = urlArray.map((url) => mapSubtree(url, func, options));\n  return await Promise.all(promises);\n}\n"],"file":"async-deep-map.js"}
+{"version":3,"sources":["../../../../src/lib/texture-api/async-deep-map.ts"],"names":["isObject","value","asyncDeepMap","tree","func","options","mapSubtree","object","Array","isArray","mapArray","mapObject","url","promises","values","key","promise","then","push","Promise","all","urlArray","map"],"mappings":";;;;;;;;;;;;;;;;AAmBA,IAAMA,QAAQ,GAAG,SAAXA,QAAW,CAACC,KAAD;AAAA,SAAyBA,KAAK,IAAI,sBAAOA,KAAP,MAAiB,QAAnD;AAAA,CAAjB;;SAKsBC,Y;;;;;4EAAf,iBAA4BC,IAA5B,EAA2CC,IAA3C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAuDC,YAAAA,OAAvD,2DAA0E,EAA1E;AAAA;AAAA,mBACQC,UAAU,CAACH,IAAD,EAAOC,IAAP,EAAaC,OAAb,CADlB;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAIeC,U;;;;;0EAAf,kBAA0BC,MAA1B,EAA2CH,IAA3C,EAAuDC,OAAvD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iBACDG,KAAK,CAACC,OAAN,CAAcF,MAAd,CADC;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAEUG,QAAQ,CAACH,MAAD,EAASH,IAAT,EAAeC,OAAf,CAFlB;;AAAA;AAAA;;AAAA;AAAA,iBAKDL,QAAQ,CAACO,MAAD,CALP;AAAA;AAAA;AAAA;;AAAA;AAAA,mBAMUI,SAAS,CAACJ,MAAD,EAAmBH,IAAnB,EAAyBC,OAAzB,CANnB;;AAAA;AAAA;;AAAA;AAUCO,YAAAA,GAVD,GAUOL,MAVP;AAAA;AAAA,mBAWQH,IAAI,CAACQ,GAAD,EAAMP,OAAN,CAXZ;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAgBQM,S;;;;;yEAAf,kBACEJ,MADF,EAEEH,IAFF,EAGEC,OAHF;AAAA;;AAAA;AAAA;AAAA;AAAA;AAKQQ,YAAAA,QALR,GAKmC,EALnC;AAMQC,YAAAA,MANR,GAMsC,EANtC;;AAAA,mCAQaC,GARb;AASI,kBAAMH,GAAG,GAAGL,MAAM,CAACQ,GAAD,CAAlB;AACA,kBAAMC,OAAO,GAAGV,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAV,CAA+BY,IAA/B,CAAoC,UAAChB,KAAD,EAAW;AAC7Da,gBAAAA,MAAM,CAACC,GAAD,CAAN,GAAcd,KAAd;AACD,eAFe,CAAhB;AAGAY,cAAAA,QAAQ,CAACK,IAAT,CAAcF,OAAd;AAbJ;;AAQE,iBAAWD,GAAX,IAAkBR,MAAlB,EAA0B;AAAA,oBAAfQ,GAAe;AAMzB;;AAdH;AAAA,mBAgBQI,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAhBR;;AAAA;AAAA,8CAkBSC,MAlBT;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAqBeJ,Q;;;;;wEAAf,kBAAwBW,QAAxB,EAA4CjB,IAA5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwDC,YAAAA,OAAxD,8DAAkE,EAAlE;AACQQ,YAAAA,QADR,GACmBQ,QAAQ,CAACC,GAAT,CAAa,UAACV,GAAD;AAAA,qBAASN,UAAU,CAACM,GAAD,EAAMR,IAAN,EAAYC,OAAZ,CAAnB;AAAA,aAAb,CADnB;AAAA;AAAA,mBAEec,OAAO,CAACC,GAAR,CAAYP,QAAZ,CAFf;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["// loaders.gl, MIT license\n/*\nAsynchronously maps a deep structure of values (e.g. objects and arrays of urls).\n\nE.g. a mipmapped cubemap\n{\n  [CUBE_FACE_FRONT]: [\n    \"image-front-0.jpg\",\n    \"image-front-1.jpg\",\n    \"image-front-2.jpg\",\n  ],\n  [CUBE_MAP_BACK]: [\n    ...\n  ]\n}\n*/\nexport type Options = Record<string, any>;\nexport type Func = (url: string, options: Options) => unknown;\n\nconst isObject = (value: any): boolean => value && typeof value === 'object';\n\n// Loads a deep structure of urls (objects and arrays of urls)\n// Returns an object with six key-value pairs containing the images (or image mip arrays)\n// for each cube face\nexport async function asyncDeepMap(tree: unknown, func: Func, options: Options = {}) {\n  return await mapSubtree(tree, func, options);\n}\n\nexport async function mapSubtree(object: unknown, func: Func, options: Options) {\n  if (Array.isArray(object)) {\n    return await mapArray(object, func, options);\n  }\n\n  if (isObject(object)) {\n    return await mapObject(object as object, func, options);\n  }\n\n  // TODO - ignore non-urls, non-arraybuffers?\n  const url = object as string;\n  return await func(url, options);\n}\n\n// HELPERS\n\nasync function mapObject(\n  object: Record<string, any>,\n  func: Func,\n  options: Options\n): Promise<Record<string, any>> {\n  const promises: Promise<any>[] = [];\n  const values: Record<string, any> = {};\n\n  for (const key in object) {\n    const url = object[key];\n    const promise = mapSubtree(url, func, options).then((value) => {\n      values[key] = value;\n    });\n    promises.push(promise);\n  }\n\n  await Promise.all(promises);\n\n  return values;\n}\n\nasync function mapArray(urlArray: string[], func: Func, options = {}): Promise<any[]> {\n  const promises = urlArray.map((url) => mapSubtree(url, func, options));\n  return await Promise.all(promises);\n}\n"],"file":"async-deep-map.js"}

package/dist/es5/lib/texture-api/deep-load.js

@@ -1,20 +1,81 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.deepLoad = deepLoad;
 exports.shallowLoad = shallowLoad;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _asyncDeepMap = require("./async-deep-map");
 
-async function deepLoad(urlTree, load, options) {
-  return await (0, _asyncDeepMap.asyncDeepMap)(urlTree, url => shallowLoad(url, load, options));
+function deepLoad(_x, _x2, _x3) {
+  return _deepLoad.apply(this, arguments);
+}
+
+function _deepLoad() {
+  _deepLoad = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(urlTree, load, options) {
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            _context.next = 2;
+            return (0, _asyncDeepMap.asyncDeepMap)(urlTree, function (url) {
+              return shallowLoad(url, load, options);
+            });
+
+          case 2:
+            return _context.abrupt("return", _context.sent);
+
+          case 3:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _deepLoad.apply(this, arguments);
 }
 
-async function shallowLoad(url, load, options) {
-  const response = await fetch(url, options.fetch);
-  const arrayBuffer = await response.arrayBuffer();
-  return await load(arrayBuffer, options);
+function shallowLoad(_x4, _x5, _x6) {
+  return _shallowLoad.apply(this, arguments);
+}
+
+function _shallowLoad() {
+  _shallowLoad = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(url, load, options) {
+    var response, arrayBuffer;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            _context2.next = 2;
+            return fetch(url, options.fetch);
+
+          case 2:
+            response = _context2.sent;
+            _context2.next = 5;
+            return response.arrayBuffer();
+
+          case 5:
+            arrayBuffer = _context2.sent;
+            _context2.next = 8;
+            return load(arrayBuffer, options);
+
+          case 8:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _shallowLoad.apply(this, arguments);
 }
 //# sourceMappingURL=deep-load.js.map

package/dist/es5/lib/texture-api/deep-load.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/deep-load.ts"],"names":["deepLoad","urlTree","load","options","url","shallowLoad","response","fetch","arrayBuffer"],"mappings":";;;;;;;;AACA;;AAKO,eAAeA,QAAf,CAAwBC,OAAxB,EAA0CC,IAA1C,EAAsDC,OAAtD,EAA4E;AACjF,SAAO,MAAM,gCAAaF,OAAb,EAAuBG,GAAD,IAAiBC,WAAW,CAACD,GAAD,EAAMF,IAAN,EAAYC,OAAZ,CAAlD,CAAb;AACD;;AAEM,eAAeE,WAAf,CAA2BD,GAA3B,EAAwCF,IAAxC,EAAoDC,OAApD,EAAwF;AAE7F,QAAMG,QAAQ,GAAG,MAAMC,KAAK,CAACH,GAAD,EAAMD,OAAO,CAACI,KAAd,CAA5B;AACA,QAAMC,WAAW,GAAG,MAAMF,QAAQ,CAACE,WAAT,EAA1B;AACA,SAAO,MAAMN,IAAI,CAACM,WAAD,EAAcL,OAAd,CAAjB;AACD","sourcesContent":["// loaders.gl, MIT license\nimport {asyncDeepMap} from './async-deep-map';\n\nexport type LoadOptions = Record<string, any>;\nexport type Load = (data: ArrayBuffer, options: Record<string, any>) => Promise<any>;\n\nexport async function deepLoad(urlTree: unknown, load: Load, options: LoadOptions) {\n  return await asyncDeepMap(urlTree, (url: string) => shallowLoad(url, load, options));\n}\n\nexport async function shallowLoad(url: string, load: Load, options: LoadOptions): Promise<any> {\n  // console.error('loading', url);\n  const response = await fetch(url, options.fetch);\n  const arrayBuffer = await response.arrayBuffer();\n  return await load(arrayBuffer, options);\n}\n"],"file":"deep-load.js"}
+{"version":3,"sources":["../../../../src/lib/texture-api/deep-load.ts"],"names":["deepLoad","urlTree","load","options","url","shallowLoad","fetch","response","arrayBuffer"],"mappings":";;;;;;;;;;;;;;AACA;;SAKsBA,Q;;;;;wEAAf,iBAAwBC,OAAxB,EAA0CC,IAA1C,EAAsDC,OAAtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBACQ,gCAAaF,OAAb,EAAsB,UAACG,GAAD;AAAA,qBAAiBC,WAAW,CAACD,GAAD,EAAMF,IAAN,EAAYC,OAAZ,CAA5B;AAAA,aAAtB,CADR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SAIeE,W;;;;;2EAAf,kBAA2BD,GAA3B,EAAwCF,IAAxC,EAAoDC,OAApD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAEkBG,KAAK,CAACF,GAAD,EAAMD,OAAO,CAACG,KAAd,CAFvB;;AAAA;AAECC,YAAAA,QAFD;AAAA;AAAA,mBAGqBA,QAAQ,CAACC,WAAT,EAHrB;;AAAA;AAGCA,YAAAA,WAHD;AAAA;AAAA,mBAIQN,IAAI,CAACM,WAAD,EAAcL,OAAd,CAJZ;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["// loaders.gl, MIT license\nimport {asyncDeepMap} from './async-deep-map';\n\nexport type LoadOptions = Record<string, any>;\nexport type Load = (data: ArrayBuffer, options: Record<string, any>) => Promise<any>;\n\nexport async function deepLoad(urlTree: unknown, load: Load, options: LoadOptions) {\n  return await asyncDeepMap(urlTree, (url: string) => shallowLoad(url, load, options));\n}\n\nexport async function shallowLoad(url: string, load: Load, options: LoadOptions): Promise<any> {\n  // console.error('loading', url);\n  const response = await fetch(url, options.fetch);\n  const arrayBuffer = await response.arrayBuffer();\n  return await load(arrayBuffer, options);\n}\n"],"file":"deep-load.js"}

package/dist/es5/lib/texture-api/generate-url.js

@@ -1,17 +1,23 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.generateUrl = generateUrl;
 
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
 var _loaderUtils = require("@loaders.gl/loader-utils");
 
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
 function generateUrl(getUrl, options, urlOptions) {
-  let url = typeof getUrl === 'function' ? getUrl({ ...options,
-    ...urlOptions
-  }) : getUrl;
-  const baseUrl = options.baseUrl;
+  var url = typeof getUrl === 'function' ? getUrl(_objectSpread(_objectSpread({}, options), urlOptions)) : getUrl;
+  var baseUrl = options.baseUrl;
 
   if (baseUrl) {
     url = baseUrl[baseUrl.length - 1] === '/' ? "".concat(baseUrl).concat(url) : "".concat(baseUrl, "/").concat(url);

package/dist/es5/lib/texture-api/generate-url.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/generate-url.ts"],"names":["generateUrl","getUrl","options","urlOptions","url","baseUrl","length"],"mappings":";;;;;;;AACA;;AAIO,SAASA,WAAT,CACLC,MADK,EAELC,OAFK,EAGLC,UAHK,EAIG;AAER,MAAIC,GAAG,GAAG,OAAOH,MAAP,KAAkB,UAAlB,GAA+BA,MAAM,CAAC,EAAC,GAAGC,OAAJ;AAAa,OAAGC;AAAhB,GAAD,CAArC,GAAqEF,MAA/E;AAGA,QAAMI,OAAO,GAAGH,OAAO,CAACG,OAAxB;;AACA,MAAIA,OAAJ,EAAa;AACXD,IAAAA,GAAG,GAAGC,OAAO,CAACA,OAAO,CAACC,MAAR,GAAiB,CAAlB,CAAP,KAAgC,GAAhC,aAAyCD,OAAzC,SAAmDD,GAAnD,cAA8DC,OAA9D,cAAyED,GAAzE,CAAN;AACD;;AAED,SAAO,8BAAYA,GAAZ,CAAP;AACD","sourcesContent":["// loaders.gl, MIT license\nimport {resolvePath} from '@loaders.gl/loader-utils';\nimport type {GetUrl, UrlOptions} from './texture-api-types';\n\n// Generate a url by calling getUrl with mix of options, applying options.baseUrl\nexport function generateUrl(\n  getUrl: string | GetUrl,\n  options: UrlOptions,\n  urlOptions: Record<string, any>\n): string {\n  // Get url\n  let url = typeof getUrl === 'function' ? getUrl({...options, ...urlOptions}) : getUrl;\n\n  // Apply options.baseUrl\n  const baseUrl = options.baseUrl;\n  if (baseUrl) {\n    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  }\n\n  return resolvePath(url);\n}\n"],"file":"generate-url.js"}
+{"version":3,"sources":["../../../../src/lib/texture-api/generate-url.ts"],"names":["generateUrl","getUrl","options","urlOptions","url","baseUrl","length"],"mappings":";;;;;;;;;;;AACA;;;;;;AAIO,SAASA,WAAT,CACLC,MADK,EAELC,OAFK,EAGLC,UAHK,EAIG;AAER,MAAIC,GAAG,GAAG,OAAOH,MAAP,KAAkB,UAAlB,GAA+BA,MAAM,iCAAKC,OAAL,GAAiBC,UAAjB,EAArC,GAAqEF,MAA/E;AAGA,MAAMI,OAAO,GAAGH,OAAO,CAACG,OAAxB;;AACA,MAAIA,OAAJ,EAAa;AACXD,IAAAA,GAAG,GAAGC,OAAO,CAACA,OAAO,CAACC,MAAR,GAAiB,CAAlB,CAAP,KAAgC,GAAhC,aAAyCD,OAAzC,SAAmDD,GAAnD,cAA8DC,OAA9D,cAAyED,GAAzE,CAAN;AACD;;AAED,SAAO,8BAAYA,GAAZ,CAAP;AACD","sourcesContent":["// loaders.gl, MIT license\nimport {resolvePath} from '@loaders.gl/loader-utils';\nimport type {GetUrl, UrlOptions} from './texture-api-types';\n\n// Generate a url by calling getUrl with mix of options, applying options.baseUrl\nexport function generateUrl(\n  getUrl: string | GetUrl,\n  options: UrlOptions,\n  urlOptions: Record<string, any>\n): string {\n  // Get url\n  let url = typeof getUrl === 'function' ? getUrl({...options, ...urlOptions}) : getUrl;\n\n  // Apply options.baseUrl\n  const baseUrl = options.baseUrl;\n  if (baseUrl) {\n    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n  }\n\n  return resolvePath(url);\n}\n"],"file":"generate-url.js"}

package/dist/es5/lib/texture-api/load-image-array.js

@@ -1,32 +1,96 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.loadImageTextureArray = loadImageTextureArray;
 exports.getImageArrayUrls = getImageArrayUrls;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _images = require("@loaders.gl/images");
 
 var _loadImage = require("./load-image");
 
 var _deepLoad = require("./deep-load");
 
-async function loadImageTextureArray(count, getUrl, options = {}) {
-  const imageUrls = await getImageArrayUrls(count, getUrl, options);
-  return await (0, _deepLoad.deepLoad)(imageUrls, _images.ImageLoader.parse, options);
+function loadImageTextureArray(_x, _x2) {
+  return _loadImageTextureArray.apply(this, arguments);
+}
+
+function _loadImageTextureArray() {
+  _loadImageTextureArray = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(count, getUrl) {
+    var options,
+        imageUrls,
+        _args = arguments;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            options = _args.length > 2 && _args[2] !== undefined ? _args[2] : {};
+            _context.next = 3;
+            return getImageArrayUrls(count, getUrl, options);
+
+          case 3:
+            imageUrls = _context.sent;
+            _context.next = 6;
+            return (0, _deepLoad.deepLoad)(imageUrls, _images.ImageLoader.parse, options);
+
+          case 6:
+            return _context.abrupt("return", _context.sent);
+
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _loadImageTextureArray.apply(this, arguments);
+}
+
+function getImageArrayUrls(_x3, _x4) {
+  return _getImageArrayUrls.apply(this, arguments);
 }
 
-async function getImageArrayUrls(count, getUrl, options = {}) {
-  const promises = [];
+function _getImageArrayUrls() {
+  _getImageArrayUrls = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(count, getUrl) {
+    var options,
+        promises,
+        index,
+        promise,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            options = _args2.length > 2 && _args2[2] !== undefined ? _args2[2] : {};
+            promises = [];
+
+            for (index = 0; index < count; index++) {
+              promise = (0, _loadImage.getImageUrls)(getUrl, options, {
+                index: index
+              });
+              promises.push(promise);
+            }
+
+            _context2.next = 5;
+            return Promise.all(promises);
 
-  for (let index = 0; index < count; index++) {
-    const promise = (0, _loadImage.getImageUrls)(getUrl, options, {
-      index
-    });
-    promises.push(promise);
-  }
+          case 5:
+            return _context2.abrupt("return", _context2.sent);
 
-  return await Promise.all(promises);
+          case 6:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getImageArrayUrls.apply(this, arguments);
 }
 //# sourceMappingURL=load-image-array.js.map

package/dist/es5/lib/texture-api/load-image-array.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../../src/lib/texture-api/load-image-array.ts"],"names":["loadImageTextureArray","count","getUrl","options","imageUrls","getImageArrayUrls","ImageLoader","parse","promises","index","promise","push","Promise","all"],"mappings":";;;;;;;;AACA;;AAEA;;AACA;;AAEO,eAAeA,qBAAf,CACLC,KADK,EAELC,MAFK,EAGLC,OAAO,GAAG,EAHL,EAIS;AACd,QAAMC,SAAS,GAAG,MAAMC,iBAAiB,CAACJ,KAAD,EAAQC,MAAR,EAAgBC,OAAhB,CAAzC;AACA,SAAO,MAAM,wBAASC,SAAT,EAAoBE,oBAAYC,KAAhC,EAAuCJ,OAAvC,CAAb;AACD;;AAEM,eAAeE,iBAAf,CAAiCJ,KAAjC,EAAgDC,MAAhD,EAAgEC,OAAO,GAAG,EAA1E,EAA4F;AACjG,QAAMK,QAAwB,GAAG,EAAjC;;AACA,OAAK,IAAIC,KAAK,GAAG,CAAjB,EAAoBA,KAAK,GAAGR,KAA5B,EAAmCQ,KAAK,EAAxC,EAA4C;AAC1C,UAAMC,OAAO,GAAG,6BAAaR,MAAb,EAAqBC,OAArB,EAA8B;AAACM,MAAAA;AAAD,KAA9B,CAAhB;AACAD,IAAAA,QAAQ,CAACG,IAAT,CAAcD,OAAd;AACD;;AACD,SAAO,MAAME,OAAO,CAACC,GAAR,CAAYL,QAAZ,CAAb;AACD","sourcesContent":["// loaders.gl, MIT license\nimport {ImageLoader} from '@loaders.gl/images';\nimport type {GetUrl} from './texture-api-types';\nimport {getImageUrls} from './load-image';\nimport {deepLoad} from './deep-load';\n\nexport async function loadImageTextureArray(\n  count: number,\n  getUrl: GetUrl,\n  options = {}\n): Promise<any> {\n  const imageUrls = await getImageArrayUrls(count, getUrl, options);\n  return await deepLoad(imageUrls, ImageLoader.parse, options);\n}\n\nexport async function getImageArrayUrls(count: number, getUrl: GetUrl, options = {}): Promise<any> {\n  const promises: Promise<any>[] = [];\n  for (let index = 0; index < count; index++) {\n    const promise = getImageUrls(getUrl, options, {index});\n    promises.push(promise);\n  }\n  return await Promise.all(promises);\n}\n"],"file":"load-image-array.js"}
+{"version":3,"sources":["../../../../src/lib/texture-api/load-image-array.ts"],"names":["loadImageTextureArray","count","getUrl","options","getImageArrayUrls","imageUrls","ImageLoader","parse","promises","index","promise","push","Promise","all"],"mappings":";;;;;;;;;;;;;;AACA;;AAEA;;AACA;;SAEsBA,qB;;;;;qFAAf,iBACLC,KADK,EAELC,MAFK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGLC,YAAAA,OAHK,2DAGK,EAHL;AAAA;AAAA,mBAKmBC,iBAAiB,CAACH,KAAD,EAAQC,MAAR,EAAgBC,OAAhB,CALpC;;AAAA;AAKCE,YAAAA,SALD;AAAA;AAAA,mBAMQ,wBAASA,SAAT,EAAoBC,oBAAYC,KAAhC,EAAuCJ,OAAvC,CANR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G;;;;SASeC,iB;;;;;iFAAf,kBAAiCH,KAAjC,EAAgDC,MAAhD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAgEC,YAAAA,OAAhE,8DAA0E,EAA1E;AACCK,YAAAA,QADD,GAC4B,EAD5B;;AAEL,iBAASC,KAAT,GAAiB,CAAjB,EAAoBA,KAAK,GAAGR,KAA5B,EAAmCQ,KAAK,EAAxC,EAA4C;AACpCC,cAAAA,OADoC,GAC1B,6BAAaR,MAAb,EAAqBC,OAArB,EAA8B;AAACM,gBAAAA,KAAK,EAALA;AAAD,eAA9B,CAD0B;AAE1CD,cAAAA,QAAQ,CAACG,IAAT,CAAcD,OAAd;AACD;;AALI;AAAA,mBAMQE,OAAO,CAACC,GAAR,CAAYL,QAAZ,CANR;;AAAA;AAAA;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,G","sourcesContent":["// loaders.gl, MIT license\nimport {ImageLoader} from '@loaders.gl/images';\nimport type {GetUrl} from './texture-api-types';\nimport {getImageUrls} from './load-image';\nimport {deepLoad} from './deep-load';\n\nexport async function loadImageTextureArray(\n  count: number,\n  getUrl: GetUrl,\n  options = {}\n): Promise<any> {\n  const imageUrls = await getImageArrayUrls(count, getUrl, options);\n  return await deepLoad(imageUrls, ImageLoader.parse, options);\n}\n\nexport async function getImageArrayUrls(count: number, getUrl: GetUrl, options = {}): Promise<any> {\n  const promises: Promise<any>[] = [];\n  for (let index = 0; index < count; index++) {\n    const promise = getImageUrls(getUrl, options, {index});\n    promises.push(promise);\n  }\n  return await Promise.all(promises);\n}\n"],"file":"load-image-array.js"}

package/dist/es5/lib/texture-api/load-image-cube.js

@@ -1,24 +1,36 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getImageCubeUrls = getImageCubeUrls;
 exports.loadImageTextureCube = loadImageTextureCube;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _images = require("@loaders.gl/images");
 
 var _loadImage = require("./load-image");
 
 var _deepLoad = require("./deep-load");
 
-const GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
-const GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
-const GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a;
-const CUBE_FACES = [{
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+var GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
+var GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
+var GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
+var GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a;
+var CUBE_FACES = [{
   face: GL_TEXTURE_CUBE_MAP_POSITIVE_X,
   direction: 'right',
   axis: 'x',
@@ -50,27 +62,84 @@ const CUBE_FACES = [{
   sign: 'negative'
 }];
 
-async function getImageCubeUrls(getUrl, options) {
-  const urls = {};
-  const promises = [];
-  let index = 0;
-
-  for (let i = 0; i < CUBE_FACES.length; ++i) {
-    const face = CUBE_FACES[index];
-    const promise = (0, _loadImage.getImageUrls)(getUrl, options, { ...face,
-      index: index++
-    }).then(url => {
-      urls[face.face] = url;
-    });
-    promises.push(promise);
-  }
-
-  await Promise.all(promises);
-  return urls;
+function getImageCubeUrls(_x, _x2) {
+  return _getImageCubeUrls.apply(this, arguments);
 }
 
-async function loadImageTextureCube(getUrl, options = {}) {
-  const urls = await getImageCubeUrls(getUrl, options);
-  return await (0, _deepLoad.deepLoad)(urls, _images.ImageLoader.parse, options);
+function _getImageCubeUrls() {
+  _getImageCubeUrls = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(getUrl, options) {
+    var urls, promises, index, _loop, i;
+
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            urls = {};
+            promises = [];
+            index = 0;
+
+            _loop = function _loop(i) {
+              var face = CUBE_FACES[index];
+              var promise = (0, _loadImage.getImageUrls)(getUrl, options, _objectSpread(_objectSpread({}, face), {}, {
+                index: index++
+              })).then(function (url) {
+                urls[face.face] = url;
+              });
+              promises.push(promise);
+            };
+
+            for (i = 0; i < CUBE_FACES.length; ++i) {
+              _loop(i);
+            }
+
+            _context.next = 7;
+            return Promise.all(promises);
+
+          case 7:
+            return _context.abrupt("return", urls);
+
+          case 8:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _getImageCubeUrls.apply(this, arguments);
+}
+
+function loadImageTextureCube(_x3) {
+  return _loadImageTextureCube.apply(this, arguments);
+}
+
+function _loadImageTextureCube() {
+  _loadImageTextureCube = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee2(getUrl) {
+    var options,
+        urls,
+        _args2 = arguments;
+    return _regenerator.default.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            options = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {};
+            _context2.next = 3;
+            return getImageCubeUrls(getUrl, options);
+
+          case 3:
+            urls = _context2.sent;
+            _context2.next = 6;
+            return (0, _deepLoad.deepLoad)(urls, _images.ImageLoader.parse, options);
+
+          case 6:
+            return _context2.abrupt("return", _context2.sent);
+
+          case 7:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _loadImageTextureCube.apply(this, arguments);
 }
 //# sourceMappingURL=load-image-cube.js.map