@loaders.gl/core 4.2.0-alpha.5 → 4.2.0-beta.1

package/dist/index.cjs

@@ -20,16 +20,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  JSONLoader: () => import_loader_utils17.JSONLoader,
+  FetchError: () => FetchError,
+  JSONLoader: () => import_loader_utils18.JSONLoader,
   NullLoader: () => NullLoader,
   NullWorkerLoader: () => NullWorkerLoader,
-  RequestScheduler: () => import_loader_utils16.RequestScheduler,
+  RequestScheduler: () => import_loader_utils17.RequestScheduler,
   _BrowserFileSystem: () => BrowserFileSystem,
   _fetchProgress: () => fetchProgress,
   _unregisterLoaders: () => _unregisterLoaders,
-  assert: () => import_loader_utils19.assert,
-  concatenateArrayBuffersAsync: () => import_loader_utils20.concatenateArrayBuffersAsync,
-  document: () => import_loader_utils18.document,
+  assert: () => import_loader_utils20.assert,
+  concatenateArrayBuffersAsync: () => import_loader_utils21.concatenateArrayBuffersAsync,
+  document: () => import_loader_utils19.document,
   encode: () => encode,
   encodeInBatches: () => encodeInBatches,
   encodeSync: () => encodeSync,
@@ -40,40 +41,40 @@ __export(dist_exports, {
   encodeTextSync: () => encodeTextSync,
   encodeURLtoURL: () => encodeURLtoURL,
   fetchFile: () => fetchFile,
-  forEach: () => import_loader_utils20.forEach,
+  forEach: () => import_loader_utils21.forEach,
   getLoaderOptions: () => getGlobalLoaderOptions,
-  getPathPrefix: () => import_loader_utils15.getPathPrefix,
-  global: () => import_loader_utils18.global,
+  getPathPrefix: () => import_loader_utils16.getPathPrefix,
+  global: () => import_loader_utils19.global,
   isAsyncIterable: () => isAsyncIterable,
-  isBrowser: () => import_loader_utils18.isBrowser,
+  isBrowser: () => import_loader_utils19.isBrowser,
   isIterable: () => isIterable,
   isIterator: () => isIterator,
   isPromise: () => isPromise,
   isPureObject: () => isPureObject,
   isReadableStream: () => isReadableStream,
   isResponse: () => isResponse,
-  isWorker: () => import_loader_utils18.isWorker,
+  isWorker: () => import_loader_utils19.isWorker,
   isWritableStream: () => isWritableStream,
   load: () => load,
   loadInBatches: () => loadInBatches,
   makeIterator: () => makeIterator,
-  makeLineIterator: () => import_loader_utils21.makeLineIterator,
-  makeNumberedLineIterator: () => import_loader_utils21.makeNumberedLineIterator,
+  makeLineIterator: () => import_loader_utils22.makeLineIterator,
+  makeNumberedLineIterator: () => import_loader_utils22.makeNumberedLineIterator,
   makeStream: () => makeStream,
-  makeTextDecoderIterator: () => import_loader_utils21.makeTextDecoderIterator,
-  makeTextEncoderIterator: () => import_loader_utils21.makeTextEncoderIterator,
+  makeTextDecoderIterator: () => import_loader_utils22.makeTextDecoderIterator,
+  makeTextEncoderIterator: () => import_loader_utils22.makeTextEncoderIterator,
   parse: () => parse,
   parseInBatches: () => parseInBatches,
   parseSync: () => parseSync,
   readArrayBuffer: () => readArrayBuffer,
   registerLoaders: () => registerLoaders,
-  resolvePath: () => import_loader_utils15.resolvePath,
+  resolvePath: () => import_loader_utils16.resolvePath,
   selectLoader: () => selectLoader,
   selectLoaderSync: () => selectLoaderSync,
-  self: () => import_loader_utils18.self,
+  self: () => import_loader_utils19.self,
   setLoaderOptions: () => setGlobalOptions,
-  setPathPrefix: () => import_loader_utils15.setPathPrefix,
-  window: () => import_loader_utils18.window
+  setPathPrefix: () => import_loader_utils16.setPathPrefix,
+  window: () => import_loader_utils19.window
 });
 module.exports = __toCommonJS(dist_exports);
 
@@ -99,9 +100,31 @@ var isReadableNodeStream = (x) => isObject(x) && isFunction(x.read) && isFunctio
 var isReadableStream = (x) => isReadableDOMStream(x) || isReadableNodeStream(x);
 var isWritableStream = (x) => isWritableDOMStream(x) || isWritableNodeStream(x);
 
+// dist/lib/fetch/fetch-error.js
+var FetchError = class extends Error {
+  constructor(message, info) {
+    super(message);
+    this.reason = info.reason;
+    this.url = info.url;
+    this.response = info.response;
+  }
+  /** A best effort reason for why the fetch failed */
+  reason;
+  /** The URL that failed to load. Empty string if not available. */
+  url;
+  /** The Response object, if any. */
+  response;
+};
+
 // dist/lib/utils/mime-type-utils.js
 var DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
 var MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+function compareMIMETypes(mimeType1, mimeType2) {
+  if (mimeType1.toLowerCase() === mimeType2.toLowerCase()) {
+    return true;
+  }
+  return false;
+}
 function parseMIMEType(mimeString) {
   const matches = MIME_TYPE_PATTERN.exec(mimeString);
   if (matches) {
@@ -126,6 +149,14 @@ function extractQueryString(url) {
 function stripQueryString(url) {
   return url.replace(QUERY_STRING_PATTERN, "");
 }
+function shortenUrlForDisplay(url) {
+  if (url.length < 50) {
+    return url;
+  }
+  const urlEnd = url.slice(url.length - 15);
+  const urlStart = url.substr(0, 32);
+  return `${urlStart}...${urlEnd}`;
+}
 
 // dist/lib/utils/resource-utils.js
 function getResourceUrl(resource) {
@@ -207,23 +238,25 @@ async function makeResponse(resource) {
 }
 async function checkResponse(response) {
   if (!response.ok) {
-    const message = await getResponseError(response);
-    throw new Error(message);
+    const error = await getResponseError(response);
+    throw error;
   }
 }
 async function getResponseError(response) {
-  let message = `Failed to fetch resource ${response.url} (${response.status}): `;
+  const shortUrl = shortenUrlForDisplay(response.url);
+  let message = `Failed to fetch resource (${response.status}) ${response.statusText}: ${shortUrl}`;
+  message = message.length > 100 ? `${message.slice(0, 100)}...` : message;
+  const info = {
+    reason: response.statusText,
+    url: response.url,
+    response
+  };
   try {
     const contentType = response.headers.get("Content-Type");
-    let text = response.statusText;
-    if (contentType == null ? void 0 : contentType.includes("application/json")) {
-      text += ` ${await response.text()}`;
-    }
-    message += text;
-    message = message.length > 60 ? `${message.slice(0, 60)}...` : message;
+    info.reason = (contentType == null ? void 0 : contentType.includes("application/json")) ? await response.json() : response.text();
   } catch (error) {
   }
-  return message;
+  return new FetchError(message, info);
 }
 async function getInitialDataUrl(resource) {
   const INITIAL_DATA_LENGTH = 5;
@@ -301,6 +334,9 @@ async function readBlob(blob) {
   });
 }
 
+// dist/lib/loader-utils/option-utils.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+
 // dist/lib/loader-utils/loggers.js
 var import_log = require("@probe.gl/log");
 var probeLog = new import_log.Log({ id: "loaders.gl" });
@@ -323,6 +359,7 @@ var NullLog = class {
   }
 };
 var ConsoleLog = class {
+  console;
   constructor() {
     this.console = console;
   }
@@ -408,6 +445,7 @@ function setGlobalOptions(options) {
   const state = getGlobalLoaderState();
   const globalOptions = getGlobalLoaderOptions();
   state.globalOptions = normalizeOptionsInternal(globalOptions, options);
+  (0, import_loader_utils3.registerJSModules)(options.modules);
 }
 function normalizeOptions(options, loader, loaders, url) {
   loaders = loaders || [];
@@ -491,7 +529,7 @@ function addUrlOptions(options, url) {
 }
 
 // dist/lib/loader-utils/normalize-loader.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 function isLoaderObject(loader) {
   if (!loader) {
     return false;
@@ -503,8 +541,8 @@ function isLoaderObject(loader) {
   return hasExtensions;
 }
 function normalizeLoader(loader) {
-  (0, import_loader_utils3.assert)(loader, "null loader");
-  (0, import_loader_utils3.assert)(isLoaderObject(loader), "invalid loader");
+  (0, import_loader_utils4.assert)(loader, "null loader");
+  (0, import_loader_utils4.assert)(isLoaderObject(loader), "invalid loader");
   let options;
   if (Array.isArray(loader)) {
     options = loader[1];
@@ -548,7 +586,7 @@ function _unregisterLoaders() {
 }
 
 // dist/lib/api/select-loader.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 
 // dist/lib/utils/log.js
 var import_log2 = require("@probe.gl/log");
@@ -631,7 +669,7 @@ function getNoValidLoaderMessage(data) {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
   let message = "No valid loader found (";
-  message += url ? `${import_loader_utils4.path.filename(url)}, ` : "no url provided, ";
+  message += url ? `${import_loader_utils5.path.filename(url)}, ` : "no url provided, ";
   message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
   const firstCharacters = data ? getFirstCharacters(data) : "";
   message += firstCharacters ? ` first bytes: "${firstCharacters}"` : "first bytes: not available";
@@ -660,11 +698,12 @@ function findLoaderByExtension(loaders, extension) {
   return null;
 }
 function findLoaderByMIMEType(loaders, mimeType) {
+  var _a;
   for (const loader of loaders) {
-    if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
+    if ((_a = loader.mimeTypes) == null ? void 0 : _a.some((mimeType1) => compareMIMETypes(mimeType, mimeType1))) {
       return loader;
     }
-    if (mimeType === `application/x.${loader.id}`) {
+    if (compareMIMETypes(mimeType, `application/x.${loader.id}`)) {
       return loader;
     }
   }
@@ -705,7 +744,7 @@ function testDataAgainstBinary(data, byteOffset, loader) {
 }
 function testBinary(data, byteOffset, loader, test) {
   if (test instanceof ArrayBuffer) {
-    return (0, import_loader_utils4.compareArrayBuffers)(test, data, test.byteLength);
+    return (0, import_loader_utils5.compareArrayBuffers)(test, data, test.byteLength);
   }
   switch (typeof test) {
     case "function":
@@ -741,12 +780,12 @@ function getMagicString(arrayBuffer, byteOffset, length) {
 }
 
 // dist/lib/api/parse.js
-var import_loader_utils8 = require("@loaders.gl/loader-utils");
-var import_worker_utils = require("@loaders.gl/worker-utils");
 var import_loader_utils9 = require("@loaders.gl/loader-utils");
+var import_worker_utils = require("@loaders.gl/worker-utils");
+var import_loader_utils10 = require("@loaders.gl/loader-utils");
 
 // dist/lib/loader-utils/get-data.js
-var import_loader_utils6 = require("@loaders.gl/loader-utils");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
 
 // dist/iterators/make-iterator/make-string-iterator.js
 var DEFAULT_CHUNK_SIZE = 256 * 1024;
@@ -792,9 +831,9 @@ async function* makeBlobIterator(blob, options) {
 }
 
 // dist/iterators/make-iterator/make-stream-iterator.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 function makeStreamIterator(stream, options) {
-  return import_loader_utils5.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
+  return import_loader_utils6.isBrowser ? makeBrowserStreamIterator(stream, options) : makeNodeStreamIterator(stream, options);
 }
 async function* makeBrowserStreamIterator(stream, options) {
   const reader = stream.getReader();
@@ -809,7 +848,7 @@ async function* makeBrowserStreamIterator(stream, options) {
       if (done) {
         return;
       }
-      yield (0, import_loader_utils5.toArrayBuffer)(value);
+      yield (0, import_loader_utils6.toArrayBuffer)(value);
     }
   } catch (error) {
     reader.releaseLock();
@@ -817,7 +856,7 @@ async function* makeBrowserStreamIterator(stream, options) {
 }
 async function* makeNodeStreamIterator(stream, options) {
   for await (const chunk of stream) {
-    yield (0, import_loader_utils5.toArrayBuffer)(chunk);
+    yield (0, import_loader_utils6.toArrayBuffer)(chunk);
   }
 }
 
@@ -890,7 +929,7 @@ async function getArrayBufferOrStringFromData(data, loader, options) {
     data = makeIterator(data, options);
   }
   if (isIterable(data) || isAsyncIterable(data)) {
-    return (0, import_loader_utils6.concatenateArrayBuffersAsync)(data);
+    return (0, import_loader_utils7.concatenateArrayBuffersAsync)(data);
   }
   throw new Error(ERR_DATA);
 }
@@ -949,7 +988,7 @@ function getFetchFunction(options, context) {
 }
 
 // dist/lib/loader-utils/loader-context.js
-var import_loader_utils7 = require("@loaders.gl/loader-utils");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
 function getLoaderContext(context, options, parentContext) {
   if (parentContext) {
     return parentContext;
@@ -962,8 +1001,8 @@ function getLoaderContext(context, options, parentContext) {
     const baseUrl = stripQueryString(newContext.url);
     newContext.baseUrl = baseUrl;
     newContext.queryString = extractQueryString(newContext.url);
-    newContext.filename = import_loader_utils7.path.filename(baseUrl);
-    newContext.baseUrl = import_loader_utils7.path.dirname(baseUrl);
+    newContext.filename = import_loader_utils8.path.filename(baseUrl);
+    newContext.baseUrl = import_loader_utils8.path.dirname(baseUrl);
   }
   if (!Array.isArray(newContext.loaders)) {
     newContext.loaders = null;
@@ -1012,7 +1051,7 @@ async function parse(data, loaders, options, context) {
 }
 async function parseWithLoader(loader, data, options, context) {
   (0, import_worker_utils.validateWorkerVersion)(loader);
-  options = (0, import_loader_utils9.mergeLoaderOptions)(loader.options, options);
+  options = (0, import_loader_utils10.mergeLoaderOptions)(loader.options, options);
   if (isResponse(data)) {
     const response = data;
     const { ok, redirected, status, statusText, type, url } = response;
@@ -1024,8 +1063,8 @@ async function parseWithLoader(loader, data, options, context) {
   if (loaderWithParser.parseTextSync && typeof data === "string") {
     return loaderWithParser.parseTextSync(data, options, context);
   }
-  if ((0, import_loader_utils8.canParseWithWorker)(loader, options)) {
-    return await (0, import_loader_utils8.parseWithWorker)(loader, data, options, context, parse);
+  if ((0, import_loader_utils9.canParseWithWorker)(loader, options)) {
+    return await (0, import_loader_utils9.parseWithWorker)(loader, data, options, context, parse);
   }
   if (loaderWithParser.parseText && typeof data === "string") {
     return await loaderWithParser.parseText(data, options, context);
@@ -1072,7 +1111,7 @@ function parseWithLoaderSync(loader, data, options, context) {
 
 // dist/lib/api/parse-in-batches.js
 var import_schema = require("@loaders.gl/schema");
-var import_loader_utils10 = require("@loaders.gl/loader-utils");
+var import_loader_utils11 = require("@loaders.gl/loader-utils");
 async function parseInBatches(data, loaders, options, context) {
   const loaderArray = Array.isArray(loaders) ? loaders : void 0;
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -1122,7 +1161,7 @@ async function parseToOutputIterator(loader, data, options, context) {
   return parseChunkInBatches(transformedIterator, loader, options, context);
 }
 async function* parseChunkInBatches(transformedIterator, loader, options, context) {
-  const arrayBuffer = await (0, import_loader_utils10.concatenateArrayBuffersAsync)(transformedIterator);
+  const arrayBuffer = await (0, import_loader_utils11.concatenateArrayBuffersAsync)(transformedIterator);
   const parsedData = await parse(
     arrayBuffer,
     loader,
@@ -1201,7 +1240,7 @@ async function loadOneFileInBatches(file, loaders, options, fetch2) {
 }
 
 // dist/lib/api/encode-table.js
-var import_loader_utils11 = require("@loaders.gl/loader-utils");
+var import_loader_utils12 = require("@loaders.gl/loader-utils");
 async function encodeTable(data, writer, options) {
   if (writer.encode) {
     return await writer.encode(data, options);
@@ -1216,7 +1255,7 @@ async function encodeTable(data, writer, options) {
     for await (const batch of batches) {
       chunks.push(batch);
     }
-    return (0, import_loader_utils11.concatenateArrayBuffers)(...chunks);
+    return (0, import_loader_utils12.concatenateArrayBuffers)(...chunks);
   }
   throw new Error("Writer could not encode data");
 }
@@ -1243,16 +1282,16 @@ function getIterator(data) {
 }
 
 // dist/lib/api/encode.js
-var import_loader_utils12 = require("@loaders.gl/loader-utils");
-var import_worker_utils2 = require("@loaders.gl/worker-utils");
 var import_loader_utils13 = require("@loaders.gl/loader-utils");
+var import_worker_utils2 = require("@loaders.gl/worker-utils");
+var import_loader_utils14 = require("@loaders.gl/loader-utils");
 async function encode(data, writer, options) {
   const globalOptions = getGlobalLoaderOptions();
   options = { ...globalOptions, ...options };
   if (writer.encodeURLtoURL) {
     return encodeWithCommandLineTool(writer, data, options);
   }
-  if ((0, import_loader_utils12.canEncodeWithWorker)(writer, options)) {
+  if ((0, import_loader_utils13.canEncodeWithWorker)(writer, options)) {
     return await (0, import_worker_utils2.processOnWorker)(writer, data, options);
   }
   return await writer.encode(data, options);
@@ -1297,20 +1336,20 @@ function encodeInBatches(data, writer, options) {
   throw new Error(`Writer ${writer.name} could not encode in batches`);
 }
 async function encodeURLtoURL(inputUrl, outputUrl, writer, options) {
-  inputUrl = (0, import_loader_utils12.resolvePath)(inputUrl);
-  outputUrl = (0, import_loader_utils12.resolvePath)(outputUrl);
-  if (import_loader_utils13.isBrowser || !writer.encodeURLtoURL) {
+  inputUrl = (0, import_loader_utils13.resolvePath)(inputUrl);
+  outputUrl = (0, import_loader_utils13.resolvePath)(outputUrl);
+  if (import_loader_utils14.isBrowser || !writer.encodeURLtoURL) {
     throw new Error();
   }
   const outputFilename = await writer.encodeURLtoURL(inputUrl, outputUrl, options);
   return outputFilename;
 }
 async function encodeWithCommandLineTool(writer, data, options) {
-  if (import_loader_utils13.isBrowser) {
+  if (import_loader_utils14.isBrowser) {
     throw new Error(`Writer ${writer.name} not supported in browser`);
   }
   const tmpInputFilename = getTemporaryFilename("input");
-  const file = new import_loader_utils12.NodeFile(tmpInputFilename, "w");
+  const file = new import_loader_utils13.NodeFile(tmpInputFilename, "w");
   await file.write(data);
   const tmpOutputFilename = getTemporaryFilename("output");
   const outputFilename = await encodeURLtoURL(tmpInputFilename, tmpOutputFilename, writer, options);
@@ -1326,8 +1365,8 @@ function getTemporaryFilename(filename) {
 }
 
 // dist/index.js
-var import_loader_utils15 = require("@loaders.gl/loader-utils");
 var import_loader_utils16 = require("@loaders.gl/loader-utils");
+var import_loader_utils17 = require("@loaders.gl/loader-utils");
 
 // dist/iterators/make-stream/make-stream.js
 function makeStream(source, options) {
@@ -1369,8 +1408,10 @@ function makeStream(source, options) {
 }
 
 // dist/null-loader.js
-var VERSION = true ? "4.2.0-alpha.4" : "latest";
+var VERSION = true ? "4.2.0-alpha.6" : "latest";
 var NullWorkerLoader = {
+  dataType: null,
+  batchType: null,
   name: "Null loader",
   id: "null",
   module: "core",
@@ -1384,6 +1425,8 @@ var NullWorkerLoader = {
   }
 };
 var NullLoader = {
+  dataType: null,
+  batchType: null,
   name: "Null loader",
   id: "null",
   module: "core",
@@ -1407,7 +1450,7 @@ function parseSync2(arrayBuffer, options, context) {
 }
 
 // dist/index.js
-var import_loader_utils17 = require("@loaders.gl/loader-utils");
+var import_loader_utils18 = require("@loaders.gl/loader-utils");
 
 // dist/lib/progress/fetch-progress.js
 async function fetchProgress(response, onProgress, onDone = () => {
@@ -1457,17 +1500,18 @@ async function read(controller, reader, loadedBytes, totalBytes, onProgress, onD
 }
 
 // dist/lib/filesystems/browser-filesystem.js
-var import_loader_utils14 = require("@loaders.gl/loader-utils");
+var import_loader_utils15 = require("@loaders.gl/loader-utils");
 var BrowserFileSystem = class {
+  _fetch;
+  files = {};
+  lowerCaseFiles = {};
+  usedFiles = {};
   /**
    * A FileSystem API wrapper around a list of browser 'File' objects
    * @param files
    * @param options
    */
   constructor(files, options) {
-    this.files = {};
-    this.lowerCaseFiles = {};
-    this.usedFiles = {};
     this._fetch = (options == null ? void 0 : options.fetch) || fetch;
     for (let i = 0; i < files.length; ++i) {
       const file = files[i];
@@ -1538,7 +1582,7 @@ var BrowserFileSystem = class {
   // implements IRandomAccessFileSystem
   // RANDOM ACCESS
   async openReadableFile(pathname, flags) {
-    return new import_loader_utils14.BlobFile(this.files[pathname]);
+    return new import_loader_utils15.BlobFile(this.files[pathname]);
   }
   // PRIVATE
   // Supports case independent paths, and file usage tracking
@@ -1552,8 +1596,8 @@ var BrowserFileSystem = class {
 };
 
 // dist/index.js
-var import_loader_utils18 = require("@loaders.gl/loader-utils");
 var import_loader_utils19 = require("@loaders.gl/loader-utils");
 var import_loader_utils20 = require("@loaders.gl/loader-utils");
 var import_loader_utils21 = require("@loaders.gl/loader-utils");
+var import_loader_utils22 = require("@loaders.gl/loader-utils");
 //# sourceMappingURL=index.cjs.map