@loaders.gl/core 4.0.0-alpha.23 → 4.0.0-alpha.24

package/dist/lib/api/parse-in-batches.js

@@ -1,117 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInBatches = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const option_utils_1 = require("../loader-utils/option-utils");
-const loader_context_1 = require("../loader-utils/loader-context");
-const get_data_1 = require("../loader-utils/get-data");
-const resource_utils_1 = require("../utils/resource-utils");
-const select_loader_1 = require("./select-loader");
-// Ensure `parse` is available in context if loader falls back to `parse`
-const parse_1 = require("./parse");
-/**
- * Parses `data` using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-async function parseInBatches(data, loaders, options, context) {
-    const loaderArray = Array.isArray(loaders) ? loaders : undefined;
-    // Signature: parseInBatches(data, options, url) - Uses registered loaders
-    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
-        context = undefined; // context not supported in short signature
-        options = loaders;
-        loaders = undefined;
-    }
-    data = await data; // Resolve any promise
-    options = options || {};
-    // Extract a url for auto detection
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    // Chooses a loader and normalizes it
-    // Note - only uses URL and contentType for streams and iterator inputs
-    const loader = await (0, select_loader_1.selectLoader)(data, loaders, options);
-    // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null
-    if (!loader) {
-        // @ts-ignore
-        return null;
-    }
-    // Normalize options
-    options = (0, option_utils_1.normalizeOptions)(options, loader, loaderArray, url);
-    context = (0, loader_context_1.getLoaderContext)({ url, _parseInBatches: parseInBatches, _parse: parse_1.parse, loaders: loaderArray }, options, context || null);
-    return await parseWithLoaderInBatches(loader, data, options, context);
-}
-exports.parseInBatches = parseInBatches;
-/**
- * Loader has been selected and context has been prepared, see if we need to emit a metadata batch
- */
-async function parseWithLoaderInBatches(loader, data, options, context) {
-    const outputIterator = await parseToOutputIterator(loader, data, options, context);
-    // Generate metadata batch if requested
-    if (!options.metadata) {
-        return outputIterator;
-    }
-    const metadataBatch = {
-        batchType: 'metadata',
-        metadata: {
-            _loader: loader,
-            _context: context
-        },
-        // Populate with some default fields to avoid crashing
-        data: [],
-        bytesUsed: 0
-    };
-    async function* makeMetadataBatchIterator(iterator) {
-        yield metadataBatch;
-        yield* iterator;
-    }
-    return makeMetadataBatchIterator(outputIterator);
-}
-/**
- * Prep work is done, now it is time to start parsing into an output operator
- * The approach depends on which parse function the loader exposes
- * `parseInBatches` (preferred), `parse` (fallback)
- */
-async function parseToOutputIterator(loader, data, options, context) {
-    // Get an iterator from the input
-    const inputIterator = await (0, get_data_1.getAsyncIterableFromData)(data, options);
-    // Apply any iterator transforms (options.transforms)
-    const transformedIterator = await applyInputTransforms(inputIterator, options?.transforms || []);
-    // If loader supports parseInBatches, we are done
-    if (loader.parseInBatches) {
-        return loader.parseInBatches(transformedIterator, options, context);
-    }
-    // Fallback: load atomically using `parse` concatenating input iterator into single chunk
-    async function* parseChunkInBatches() {
-        const arrayBuffer = await (0, loader_utils_1.concatenateArrayBuffersAsync)(transformedIterator);
-        // Call `parse` instead of `loader.parse` to ensure we can call workers etc.
-        const parsedData = await (0, parse_1.parse)(arrayBuffer, loader, 
-        // TODO - Hack: supply loaders MIME type to ensure we match it
-        { ...options, mimeType: loader.mimeTypes[0] }, context);
-        // yield a single batch, the output from loader.parse()
-        // TODO - run through batch builder to apply options etc...
-        const batch = {
-            mimeType: loader.mimeTypes[0],
-            shape: Array.isArray(parsedData) ? 'row-table' : 'unknown',
-            batchType: 'data',
-            data: parsedData,
-            length: Array.isArray(parsedData) ? parsedData.length : 1
-        };
-        yield batch;
-    }
-    return parseChunkInBatches();
-}
-/**
- * Create an iterator chain with any transform iterators (crypto, decompression)
- * @param inputIterator
- * @param options
- */
-async function applyInputTransforms(inputIterator, transforms = []) {
-    let iteratorChain = inputIterator;
-    for await (const transformBatches of transforms) {
-        iteratorChain = transformBatches(iteratorChain);
-    }
-    return iteratorChain;
-}

package/dist/lib/api/parse-sync.js

@@ -1,54 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSync = void 0;
-const select_loader_1 = require("./select-loader");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const option_utils_1 = require("../loader-utils/option-utils");
-const get_data_1 = require("../loader-utils/get-data");
-const loader_context_1 = require("../loader-utils/loader-context");
-const resource_utils_1 = require("../utils/resource-utils");
-/**
- * Parses `data` synchronously using a specified loader
- */
-function parseSync(data, loaders, options, context) {
-    // Signature: parseSync(data, options)
-    // Uses registered loaders
-    if (!Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
-        context = undefined; // context not supported in short signature
-        options = loaders;
-        loaders = undefined;
-    }
-    options = options || {};
-    // Chooses a loader (and normalizes it)
-    // Also use any loaders in the context, new loaders take priority
-    const typedLoaders = loaders;
-    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
-    const loader = (0, select_loader_1.selectLoaderSync)(data, candidateLoaders, options);
-    // Note: if nothrow option was set, it is possible that no loader was found, if so just return null
-    if (!loader) {
-        return null;
-    }
-    // Normalize options
-    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders);
-    // Extract a url for auto detection
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const parse = () => {
-        throw new Error('parseSync called parse (which is async');
-    };
-    context = (0, loader_context_1.getLoaderContext)({ url, _parseSync: parse, _parse: parse, loaders: loaders }, options, context || null);
-    return parseWithLoaderSync(loader, data, options, context);
-}
-exports.parseSync = parseSync;
-// TODO - should accept loader.parseSync/parse and generate 1 chunk asyncIterator
-function parseWithLoaderSync(loader, data, options, context) {
-    data = (0, get_data_1.getArrayBufferOrStringFromDataSync)(data, loader, options);
-    if (loader.parseTextSync && typeof data === 'string') {
-        return loader.parseTextSync(data, options); // , context, loader);
-    }
-    if (loader.parseSync && data instanceof ArrayBuffer) {
-        return loader.parseSync(data, options, context); // , loader);
-    }
-    // TBD - If synchronous parser not available, return null
-    throw new Error(`${loader.name} loader: 'parseSync' not supported by this loader, use 'parse' instead. ${context.url || ''}`);
-}

package/dist/lib/api/parse.js

@@ -1,87 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parse = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const is_type_1 = require("../../javascript-utils/is-type");
-const option_utils_1 = require("../loader-utils/option-utils");
-const get_data_1 = require("../loader-utils/get-data");
-const loader_context_1 = require("../loader-utils/loader-context");
-const resource_utils_1 = require("../utils/resource-utils");
-const select_loader_1 = require("./select-loader");
-/**
- * Parses `data` using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-// implementation signature
-async function parse(data, loaders, options, context) {
-    // Signature: parse(data, options, context | url)
-    // Uses registered loaders
-    if (loaders && !Array.isArray(loaders) && !(0, normalize_loader_1.isLoaderObject)(loaders)) {
-        context = undefined; // context not supported in short signature
-        options = loaders;
-        loaders = undefined;
-    }
-    data = await data; // Resolve any promise
-    options = options || {}; // Could be invalid...
-    // Extract a url for auto detection
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    // Chooses a loader (and normalizes it)
-    // Also use any loaders in the context, new loaders take priority
-    const typedLoaders = loaders;
-    const candidateLoaders = (0, loader_context_1.getLoadersFromContext)(typedLoaders, context);
-    // todo hacky type cast
-    const loader = await (0, select_loader_1.selectLoader)(data, candidateLoaders, options);
-    // Note: if no loader was found, if so just return null
-    if (!loader) {
-        return null;
-    }
-    // Normalize options
-    // @ts-expect-error
-    options = (0, option_utils_1.normalizeOptions)(options, loader, candidateLoaders, url); // Could be invalid...
-    // Get a context (if already present, will be unchanged)
-    context = (0, loader_context_1.getLoaderContext)(
-    // @ts-expect-error
-    { url, _parse: parse, loaders: candidateLoaders }, options, context || null);
-    return await parseWithLoader(loader, data, options, context);
-}
-exports.parse = parse;
-// TODO: support progress and abort
-// TODO - should accept loader.parseAsyncIterator and concatenate.
-async function parseWithLoader(loader, data, options, context) {
-    (0, worker_utils_1.validateWorkerVersion)(loader);
-    if ((0, is_type_1.isResponse)(data)) {
-        // Serialize to support passing the response to web worker
-        const response = data;
-        const { ok, redirected, status, statusText, type, url } = response;
-        const headers = Object.fromEntries(response.headers.entries());
-        // @ts-expect-error TODO - fix this
-        context.response = { headers, ok, redirected, status, statusText, type, url };
-    }
-    data = await (0, get_data_1.getArrayBufferOrStringFromData)(data, loader, options);
-    const loaderWithParser = loader;
-    // First check for synchronous text parser, wrap results in promises
-    if (loaderWithParser.parseTextSync && typeof data === 'string') {
-        return loaderWithParser.parseTextSync(data, options, context);
-    }
-    // If we have a workerUrl and the loader can parse the given options efficiently in a worker
-    if ((0, loader_utils_1.canParseWithWorker)(loader, options)) {
-        return await (0, loader_utils_1.parseWithWorker)(loader, data, options, context, parse);
-    }
-    // Check for asynchronous parser
-    if (loaderWithParser.parseText && typeof data === 'string') {
-        return await loaderWithParser.parseText(data, options, context);
-    }
-    if (loaderWithParser.parse) {
-        return await loaderWithParser.parse(data, options, context);
-    }
-    // This should not happen, all sync loaders should also offer `parse` function
-    (0, worker_utils_1.assert)(!loaderWithParser.parseSync);
-    // TBD - If asynchronous parser not available, return null
-    throw new Error(`${loader.id} loader - no parser found and worker is disabled`);
-}

package/dist/lib/api/register-loaders.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._unregisterLoaders = exports.getRegisteredLoaders = exports.registerLoaders = void 0;
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const option_utils_1 = require("../loader-utils/option-utils");
-// Store global registered loaders on the global object to increase chances of cross loaders-version interoperability
-// This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
-const getGlobalLoaderRegistry = () => {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = state.loaderRegistry || [];
-    return state.loaderRegistry;
-};
-/** Register a list of global loaders */
-function registerLoaders(loaders) {
-    const loaderRegistry = getGlobalLoaderRegistry();
-    loaders = Array.isArray(loaders) ? loaders : [loaders];
-    for (const loader of loaders) {
-        const normalizedLoader = (0, normalize_loader_1.normalizeLoader)(loader);
-        if (!loaderRegistry.find((registeredLoader) => normalizedLoader === registeredLoader)) {
-            // add to the beginning of the loaderRegistry, so the last registeredLoader get picked
-            loaderRegistry.unshift(normalizedLoader);
-        }
-    }
-}
-exports.registerLoaders = registerLoaders;
-function getRegisteredLoaders() {
-    return getGlobalLoaderRegistry();
-}
-exports.getRegisteredLoaders = getRegisteredLoaders;
-/** @deprecated For testing only  */
-function _unregisterLoaders() {
-    const state = (0, option_utils_1.getGlobalLoaderState)();
-    state.loaderRegistry = [];
-}
-exports._unregisterLoaders = _unregisterLoaders;

package/dist/lib/api/save.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.saveSync = exports.save = void 0;
-const encode_1 = require("./encode");
-const write_file_1 = require("../fetch/write-file");
-async function save(data, url, writer, options) {
-    const encodedData = await (0, encode_1.encode)(data, writer, options);
-    return await (0, write_file_1.writeFile)(url, encodedData);
-}
-exports.save = save;
-function saveSync(data, url, writer, options) {
-    const encodedData = (0, encode_1.encodeSync)(data, writer, options);
-    return (0, write_file_1.writeFileSync)(url, encodedData);
-}
-exports.saveSync = saveSync;

package/dist/lib/api/select-loader.js

@@ -1,258 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectLoaderSync = exports.selectLoader = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const normalize_loader_1 = require("../loader-utils/normalize-loader");
-const log_1 = require("../utils/log");
-const resource_utils_1 = require("../utils/resource-utils");
-const register_loaders_1 = require("./register-loaders");
-const is_type_1 = require("../../javascript-utils/is-type");
-const url_utils_1 = require("../utils/url-utils");
-const EXT_PATTERN = /\.([^.]+)$/;
-// TODO - Need a variant that peeks at streams for parseInBatches
-// TODO - Detect multiple matching loaders? Use heuristics to grade matches?
-// TODO - Allow apps to pass context to disambiguate between multiple matches (e.g. multiple .json formats)?
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-async function selectLoader(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // First make a sync attempt, disabling exceptions
-    let loader = selectLoaderSync(data, loaders, { ...options, nothrow: true }, context);
-    if (loader) {
-        return loader;
-    }
-    // For Blobs and Files, try to asynchronously read a small initial slice and test again with that
-    // to see if we can detect by initial content
-    if ((0, is_type_1.isBlob)(data)) {
-        data = await data.slice(0, 10).arrayBuffer();
-        loader = selectLoaderSync(data, loaders, options, context);
-    }
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
-    return loader;
-}
-exports.selectLoader = selectLoader;
-/**
- * Find a loader that matches file extension and/or initial file content
- * Search the loaders array argument for a loader that matches url extension or initial data
- * Returns: a normalized loader
- * @param data data to assist
- * @param loaders
- * @param options
- * @param context used internally, applications should not provide this parameter
- */
-function selectLoaderSync(data, loaders = [], options, context) {
-    if (!validHTTPResponse(data)) {
-        return null;
-    }
-    // eslint-disable-next-line complexity
-    // if only a single loader was provided (not as array), force its use
-    // TODO - Should this behavior be kept and documented?
-    if (loaders && !Array.isArray(loaders)) {
-        // TODO - remove support for legacy loaders
-        return (0, normalize_loader_1.normalizeLoader)(loaders);
-    }
-    // Build list of candidate loaders that will be searched in order for a match
-    let candidateLoaders = [];
-    // First search supplied loaders
-    if (loaders) {
-        candidateLoaders = candidateLoaders.concat(loaders);
-    }
-    // Then fall back to registered loaders
-    if (!options?.ignoreRegisteredLoaders) {
-        candidateLoaders.push(...(0, register_loaders_1.getRegisteredLoaders)());
-    }
-    // TODO - remove support for legacy loaders
-    normalizeLoaders(candidateLoaders);
-    const loader = selectLoaderInternal(data, candidateLoaders, options, context);
-    // no loader available
-    if (!loader && !options?.nothrow) {
-        throw new Error(getNoValidLoaderMessage(data));
-    }
-    return loader;
-}
-exports.selectLoaderSync = selectLoaderSync;
-/** Implements loaders selection logic */
-// eslint-disable-next-line complexity
-function selectLoaderInternal(data, loaders, options, context) {
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const type = (0, resource_utils_1.getResourceMIMEType)(data);
-    const testUrl = (0, url_utils_1.stripQueryString)(url) || context?.url;
-    let loader = null;
-    let reason = '';
-    // if options.mimeType is supplied, it takes precedence
-    if (options?.mimeType) {
-        loader = findLoaderByMIMEType(loaders, options?.mimeType);
-        reason = `match forced by supplied MIME type ${options?.mimeType}`;
-    }
-    // Look up loader by url
-    loader = loader || findLoaderByUrl(loaders, testUrl);
-    reason = reason || (loader ? `matched url ${testUrl}` : '');
-    // Look up loader by mime type
-    loader = loader || findLoaderByMIMEType(loaders, type);
-    reason = reason || (loader ? `matched MIME type ${type}` : '');
-    // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)
-    // @ts-ignore Blob | Response
-    loader = loader || findLoaderByInitialBytes(loaders, data);
-    // @ts-ignore Blob | Response
-    reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : '');
-    // Look up loader by fallback mime type
-    if (options?.fallbackMimeType) {
-        loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-        reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
-    }
-    if (reason) {
-        log_1.log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
-    }
-    return loader;
-}
-/** Check HTTP Response */
-function validHTTPResponse(data) {
-    // HANDLE HTTP status
-    if (data instanceof Response) {
-        // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile
-        if (data.status === 204) {
-            return false;
-        }
-    }
-    return true;
-}
-/** Generate a helpful message to help explain why loader selection failed. */
-function getNoValidLoaderMessage(data) {
-    const url = (0, resource_utils_1.getResourceUrl)(data);
-    const type = (0, resource_utils_1.getResourceMIMEType)(data);
-    let message = 'No valid loader found (';
-    message += url ? `${loader_utils_1.path.filename(url)}, ` : 'no url provided, ';
-    message += `MIME type: ${type ? `"${type}"` : 'not provided'}, `;
-    // First characters are only accessible when called on data (string or arrayBuffer).
-    // @ts-ignore Blob | Response
-    const firstCharacters = data ? getFirstCharacters(data) : '';
-    message += firstCharacters ? ` first bytes: "${firstCharacters}"` : 'first bytes: not available';
-    message += ')';
-    return message;
-}
-function normalizeLoaders(loaders) {
-    for (const loader of loaders) {
-        (0, normalize_loader_1.normalizeLoader)(loader);
-    }
-}
-// TODO - Would be nice to support http://example.com/file.glb?parameter=1
-// E.g: x = new URL('http://example.com/file.glb?load=1'; x.pathname
-function findLoaderByUrl(loaders, url) {
-    // Get extension
-    const match = url && EXT_PATTERN.exec(url);
-    const extension = match && match[1];
-    return extension ? findLoaderByExtension(loaders, extension) : null;
-}
-function findLoaderByExtension(loaders, extension) {
-    extension = extension.toLowerCase();
-    for (const loader of loaders) {
-        for (const loaderExtension of loader.extensions) {
-            if (loaderExtension.toLowerCase() === extension) {
-                return loader;
-            }
-        }
-    }
-    return null;
-}
-function findLoaderByMIMEType(loaders, mimeType) {
-    for (const loader of loaders) {
-        if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
-            return loader;
-        }
-        // Support referring to loaders using the "unregistered tree"
-        // https://en.wikipedia.org/wiki/Media_type#Unregistered_tree
-        if (mimeType === `application/x.${loader.id}`) {
-            return loader;
-        }
-    }
-    return null;
-}
-function findLoaderByInitialBytes(loaders, data) {
-    if (!data) {
-        return null;
-    }
-    for (const loader of loaders) {
-        if (typeof data === 'string') {
-            if (testDataAgainstText(data, loader)) {
-                return loader;
-            }
-        }
-        else if (ArrayBuffer.isView(data)) {
-            // Typed Arrays can have offsets into underlying buffer
-            if (testDataAgainstBinary(data.buffer, data.byteOffset, loader)) {
-                return loader;
-            }
-        }
-        else if (data instanceof ArrayBuffer) {
-            const byteOffset = 0;
-            if (testDataAgainstBinary(data, byteOffset, loader)) {
-                return loader;
-            }
-        }
-        // TODO Handle streaming case (requires creating a new AsyncIterator)
-    }
-    return null;
-}
-function testDataAgainstText(data, loader) {
-    if (loader.testText) {
-        return loader.testText(data);
-    }
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => data.startsWith(test));
-}
-function testDataAgainstBinary(data, byteOffset, loader) {
-    const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-    return tests.some((test) => testBinary(data, byteOffset, loader, test));
-}
-function testBinary(data, byteOffset, loader, test) {
-    if (test instanceof ArrayBuffer) {
-        return (0, loader_utils_1.compareArrayBuffers)(test, data, test.byteLength);
-    }
-    switch (typeof test) {
-        case 'function':
-            return test(data);
-        case 'string':
-            // Magic bytes check: If `test` is a string, check if binary data starts with that strings
-            const magic = getMagicString(data, byteOffset, test.length);
-            return test === magic;
-        default:
-            return false;
-    }
-}
-function getFirstCharacters(data, length = 5) {
-    if (typeof data === 'string') {
-        return data.slice(0, length);
-    }
-    else if (ArrayBuffer.isView(data)) {
-        // Typed Arrays can have offsets into underlying buffer
-        return getMagicString(data.buffer, data.byteOffset, length);
-    }
-    else if (data instanceof ArrayBuffer) {
-        const byteOffset = 0;
-        return getMagicString(data, byteOffset, length);
-    }
-    return '';
-}
-function getMagicString(arrayBuffer, byteOffset, length) {
-    if (arrayBuffer.byteLength < byteOffset + length) {
-        return '';
-    }
-    const dataView = new DataView(arrayBuffer);
-    let magic = '';
-    for (let i = 0; i < length; i++) {
-        magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
-    }
-    return magic;
-}

package/dist/lib/common.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/fetch/fetch-error-message.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getErrorMessageFromResponse = exports.getErrorMessageFromResponseSync = void 0;
-function getErrorMessageFromResponseSync(response) {
-    return `Failed to fetch resource ${response.url}(${response.status}): ${response.statusText} `;
-}
-exports.getErrorMessageFromResponseSync = getErrorMessageFromResponseSync;
-async function getErrorMessageFromResponse(response) {
-    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
-    try {
-        const contentType = response.headers.get('Content-Type') || '';
-        if (contentType.includes('application/json')) {
-            message += await response.text();
-        }
-        else {
-            message += response.statusText;
-        }
-    }
-    catch (error) {
-        // eslint forbids return in finally statement
-        return message;
-    }
-    return message;
-}
-exports.getErrorMessageFromResponse = getErrorMessageFromResponse;

package/dist/lib/fetch/fetch-file.js

@@ -1,61 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchFile = exports.isDataURL = exports.isRequestURL = exports.isNodePath = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const response_utils_1 = require("../utils/response-utils");
-const node = __importStar(require("./fetch-file.node"));
-function isNodePath(url) {
-    return !isRequestURL(url) && !isDataURL(url);
-}
-exports.isNodePath = isNodePath;
-function isRequestURL(url) {
-    return url.startsWith('http:') || url.startsWith('https:');
-}
-exports.isRequestURL = isRequestURL;
-function isDataURL(url) {
-    return url.startsWith('data:');
-}
-exports.isDataURL = isDataURL;
-/**
- * fetch API compatible function
- * - Supports fetching from Node.js local file system paths
- * - Respects pathPrefix and file aliases
- */
-async function fetchFile(urlOrData, fetchOptions) {
-    if (typeof urlOrData === 'string') {
-        const url = (0, loader_utils_1.resolvePath)(urlOrData);
-        // Support fetching from local file system
-        if (isNodePath(url) && node?.fetchFileNode) {
-            return node.fetchFileNode(url, fetchOptions);
-        }
-        // Call global fetch
-        return await fetch(url, fetchOptions);
-    }
-    // TODO - should we still call fetch on non-URL inputs?
-    return await (0, response_utils_1.makeResponse)(urlOrData);
-}
-exports.fetchFile = fetchFile;