@loaders.gl/core 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/loader-utils/option-defaults.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOVED_LOADER_OPTIONS = exports.DEFAULT_LOADER_OPTIONS = void 0;
+const loggers_1 = require("./loggers");
+exports.DEFAULT_LOADER_OPTIONS = {
+    // baseUri
+    fetch: null,
+    mimeType: undefined,
+    nothrow: false,
+    log: new loggers_1.ConsoleLog(),
+    CDN: 'https://unpkg.com/@loaders.gl',
+    worker: true,
+    maxConcurrency: 3,
+    maxMobileConcurrency: 1,
+    reuseWorkers: true,
+    _workerType: '',
+    limit: 0,
+    _limitMB: 0,
+    batchSize: 'auto',
+    batchDebounceMs: 0,
+    metadata: false,
+    transforms: []
+};
+exports.REMOVED_LOADER_OPTIONS = {
+    throws: 'nothrow',
+    dataType: '(no longer used)',
+    uri: 'baseUri',
+    // Warn if fetch options are used on top-level
+    method: 'fetch.method',
+    headers: 'fetch.headers',
+    body: 'fetch.body',
+    mode: 'fetch.mode',
+    credentials: 'fetch.credentials',
+    cache: 'fetch.cache',
+    redirect: 'fetch.redirect',
+    referrer: 'fetch.referrer',
+    referrerPolicy: 'fetch.referrerPolicy',
+    integrity: 'fetch.integrity',
+    keepalive: 'fetch.keepalive',
+    signal: 'fetch.signal'
+};

package/dist/lib/loader-utils/option-utils.d.ts

@@ -0,0 +1,36 @@
+import type { Loader, LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+/**
+ * Global state for loaders.gl. Stored on `global.loaders._state`
+ */
+declare type GlobalLoaderState = {
+    loaderRegistry: Loader[];
+    globalOptions: {
+        [key: string]: any;
+    };
+};
+/**
+ * Helper for safely accessing global loaders.gl variables
+ * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers
+ */
+export declare function getGlobalLoaderState(): GlobalLoaderState;
+/**
+ * Set global loader options
+ * @param options
+ */
+export declare function setGlobalOptions(options: object): void;
+/**
+ * Merges options with global opts and loader defaults, also injects baseUri
+ * @param options
+ * @param loader
+ * @param loaders
+ * @param url
+ */
+export declare function normalizeOptions(options: object, loader: Loader, loaders?: Loader[], url?: string): object;
+/**
+ * Gets the current fetch function from options and context
+ * @param options
+ * @param context
+ */
+export declare function getFetchFunction(options?: LoaderOptions, context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>): any;
+export {};
+//# sourceMappingURL=option-utils.d.ts.map

package/dist/lib/loader-utils/option-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"option-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/option-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAKnF;;GAEG;AACH,aAAK,iBAAiB,GAAG;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,aAAa,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,CAAC;CACrC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,iBAAiB,CASxD;AAWD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAItD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,EAAE,EAClB,GAAG,CAAC,EAAE,MAAM,GACX,MAAM,CAMR;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,CAAC,EAAE,aAAa,EACvB,OAAO,CAAC,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,OAuB/E"}

package/dist/lib/loader-utils/option-utils.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFetchFunction = exports.normalizeOptions = exports.setGlobalOptions = exports.getGlobalLoaderState = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const fetch_file_1 = require("../fetch/fetch-file");
+const loggers_1 = require("./loggers");
+const option_defaults_1 = require("./option-defaults");
+/**
+ * Helper for safely accessing global loaders.gl variables
+ * Wraps initialization of global variable in function to defeat overly aggressive tree-shakers
+ */
+function getGlobalLoaderState() {
+    // @ts-ignore
+    globalThis.loaders = globalThis.loaders || {};
+    // @ts-ignore
+    const { loaders } = globalThis;
+    // Add _state object to keep separate from modules added to globalThis.loaders
+    loaders._state = loaders._state || {};
+    return loaders._state;
+}
+exports.getGlobalLoaderState = getGlobalLoaderState;
+// Store global loader options on the global object to increase chances of cross loaders-version interoperability
+// NOTE: This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
+const getGlobalLoaderOptions = () => {
+    const state = getGlobalLoaderState();
+    // Ensure all default loader options from this library are mentioned
+    state.globalOptions = state.globalOptions || { ...option_defaults_1.DEFAULT_LOADER_OPTIONS };
+    return state.globalOptions;
+};
+/**
+ * Set global loader options
+ * @param options
+ */
+function setGlobalOptions(options) {
+    const state = getGlobalLoaderState();
+    const globalOptions = getGlobalLoaderOptions();
+    state.globalOptions = normalizeOptionsInternal(globalOptions, options);
+}
+exports.setGlobalOptions = setGlobalOptions;
+/**
+ * Merges options with global opts and loader defaults, also injects baseUri
+ * @param options
+ * @param loader
+ * @param loaders
+ * @param url
+ */
+function normalizeOptions(options, loader, loaders, url) {
+    loaders = loaders || [];
+    loaders = Array.isArray(loaders) ? loaders : [loaders];
+    validateOptions(options, loaders);
+    return normalizeOptionsInternal(loader, options, url);
+}
+exports.normalizeOptions = normalizeOptions;
+/**
+ * Gets the current fetch function from options and context
+ * @param options
+ * @param context
+ */
+function getFetchFunction(options, context) {
+    const globalOptions = getGlobalLoaderOptions();
+    const fetchOptions = options || globalOptions;
+    // options.fetch can be a function
+    if (typeof fetchOptions.fetch === 'function') {
+        return fetchOptions.fetch;
+    }
+    // options.fetch can be an options object
+    if ((0, is_type_1.isObject)(fetchOptions.fetch)) {
+        return (url) => (0, fetch_file_1.fetchFile)(url, fetchOptions);
+    }
+    // else refer to context (from parent loader) if available
+    if (context?.fetch) {
+        return context?.fetch;
+    }
+    // else return the default fetch function
+    return fetch_file_1.fetchFile;
+}
+exports.getFetchFunction = getFetchFunction;
+// VALIDATE OPTIONS
+/**
+ * Warn for unsupported options
+ * @param options
+ * @param loaders
+ */
+function validateOptions(options, loaders) {
+    // Check top level options
+    validateOptionsObject(options, null, option_defaults_1.DEFAULT_LOADER_OPTIONS, option_defaults_1.REMOVED_LOADER_OPTIONS, loaders);
+    for (const loader of loaders) {
+        // Get the scoped, loader specific options from the user supplied options
+        const idOptions = (options && options[loader.id]) || {};
+        // Get scoped, loader specific default and deprecated options from the selected loader
+        const loaderOptions = (loader.options && loader.options[loader.id]) || {};
+        const deprecatedOptions = (loader.deprecatedOptions && loader.deprecatedOptions[loader.id]) || {};
+        // Validate loader specific options
+        validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
+    }
+}
+// eslint-disable-next-line max-params, complexity
+function validateOptionsObject(options, id, defaultOptions, deprecatedOptions, loaders) {
+    const loaderName = id || 'Top level';
+    const prefix = id ? `${id}.` : '';
+    for (const key in options) {
+        // If top level option value is an object it could options for a loader, so ignore
+        const isSubOptions = !id && (0, is_type_1.isObject)(options[key]);
+        const isBaseUriOption = key === 'baseUri' && !id;
+        const isWorkerUrlOption = key === 'workerUrl' && id;
+        // <loader>.workerUrl requires special handling as it is now auto-generated and no longer specified as a default option.
+        if (!(key in defaultOptions) && !isBaseUriOption && !isWorkerUrlOption) {
+            // Issue deprecation warnings
+            if (key in deprecatedOptions) {
+                loggers_1.probeLog.warn(`${loaderName} loader option \'${prefix}${key}\' no longer supported, use \'${deprecatedOptions[key]}\'`)();
+            }
+            else if (!isSubOptions) {
+                const suggestion = findSimilarOption(key, loaders);
+                loggers_1.probeLog.warn(`${loaderName} loader option \'${prefix}${key}\' not recognized. ${suggestion}`)();
+            }
+        }
+    }
+}
+function findSimilarOption(optionKey, loaders) {
+    const lowerCaseOptionKey = optionKey.toLowerCase();
+    let bestSuggestion = '';
+    for (const loader of loaders) {
+        for (const key in loader.options) {
+            if (optionKey === key) {
+                return `Did you mean \'${loader.id}.${key}\'?`;
+            }
+            const lowerCaseKey = key.toLowerCase();
+            const isPartialMatch = lowerCaseOptionKey.startsWith(lowerCaseKey) || lowerCaseKey.startsWith(lowerCaseOptionKey);
+            if (isPartialMatch) {
+                bestSuggestion = bestSuggestion || `Did you mean \'${loader.id}.${key}\'?`;
+            }
+        }
+    }
+    return bestSuggestion;
+}
+function normalizeOptionsInternal(loader, options, url) {
+    const loaderDefaultOptions = loader.options || {};
+    const mergedOptions = { ...loaderDefaultOptions };
+    addUrlOptions(mergedOptions, url);
+    // LOGGING: options.log can be set to `null` to defeat logging
+    if (mergedOptions.log === null) {
+        mergedOptions.log = new loggers_1.NullLog();
+    }
+    mergeNestedFields(mergedOptions, getGlobalLoaderOptions());
+    mergeNestedFields(mergedOptions, options);
+    return mergedOptions;
+}
+// Merge nested options objects
+function mergeNestedFields(mergedOptions, options) {
+    for (const key in options) {
+        // Check for nested options
+        // object in options => either no key in defaultOptions or object in defaultOptions
+        if (key in options) {
+            const value = options[key];
+            if ((0, is_type_1.isPureObject)(value) && (0, is_type_1.isPureObject)(mergedOptions[key])) {
+                mergedOptions[key] = {
+                    ...mergedOptions[key],
+                    ...options[key]
+                };
+            }
+            else {
+                mergedOptions[key] = options[key];
+            }
+        }
+        // else: No need to merge nested opts, and the initial merge already copied over the nested options
+    }
+}
+// Harvest information from the url
+// TODO - baseUri should be a directory, i.e. remove file component from baseUri
+// TODO - extract extension?
+// TODO - extract query parameters?
+// TODO - should these be injected on context instead of options?
+function addUrlOptions(options, url) {
+    if (url && !('baseUri' in options)) {
+        options.baseUri = url;
+    }
+}

package/dist/lib/progress/fetch-progress.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Intercepts the Response stream and creates a new Response
+ */
+export default function fetchProgress(response: Response | Promise<Response>, onProgress: any, // TODO better callback types
+onDone?: () => void, onError?: () => void): Promise<Response>;
+//# sourceMappingURL=fetch-progress.d.ts.map

package/dist/lib/progress/fetch-progress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-progress.d.ts","sourceRoot":"","sources":["../../../src/lib/progress/fetch-progress.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAA8B,aAAa,CACzC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EACtC,UAAU,EAAE,GAAG,EAAE,6BAA6B;AAC9C,MAAM,aAAW,EACjB,OAAO,aAAW,qBA+BnB"}

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

@@ -0,0 +1,59 @@
+"use strict";
+// Forked from github AnthumChris/fetch-progress-indicators under MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Intercepts the Response stream and creates a new Response
+ */
+async function fetchProgress(response, onProgress, // TODO better callback types
+onDone = () => { }, onError = () => { }) {
+    response = await response;
+    if (!response.ok) {
+        // ERROR checking needs to be done separately
+        return response;
+    }
+    const body = response.body;
+    if (!body) {
+        // 'ReadableStream not yet supported in this browser.
+        return response;
+    }
+    const contentLength = response.headers.get('content-length') || 0;
+    const totalBytes = contentLength && parseInt(contentLength);
+    if (!(contentLength > 0)) {
+        return response;
+    }
+    // Currently override only implemented in browser
+    if (typeof ReadableStream === 'undefined' || !body.getReader) {
+        return response;
+    }
+    // Create a new stream that invisbly wraps original stream
+    const progressStream = new ReadableStream({
+        async start(controller) {
+            const reader = body.getReader();
+            await read(controller, reader, 0, totalBytes, onProgress, onDone, onError);
+        }
+    });
+    return new Response(progressStream);
+}
+exports.default = fetchProgress;
+// Forward to original streams controller
+// TODO - this causes a crazy deep "async stack"... rewrite as async iterator?
+// eslint-disable-next-line max-params
+async function read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError) {
+    try {
+        const { done, value } = await reader.read();
+        if (done) {
+            onDone();
+            controller.close();
+            return;
+        }
+        loadedBytes += value.byteLength;
+        const percent = Math.round((loadedBytes / totalBytes) * 100);
+        onProgress(percent, { loadedBytes, totalBytes });
+        controller.enqueue(value);
+        await read(controller, reader, loadedBytes, totalBytes, onProgress, onDone, onError);
+    }
+    catch (error) {
+        controller.error(error);
+        onError(error);
+    }
+}

package/dist/lib/utils/mime-type-utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Remove extra data like `charset` from MIME types
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+export declare function parseMIMEType(mimeString: string): string;
+/**
+ * Extract MIME type from data URL
+ *
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+export declare function parseMIMETypeFromURL(url: string): string;
+//# sourceMappingURL=mime-type-utils.d.ts.map

package/dist/lib/utils/mime-type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mime-type-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/mime-type-utils.ts"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAOxD"}

package/dist/lib/utils/mime-type-utils.js

@@ -0,0 +1,42 @@
+"use strict";
+// TODO - build/integrate proper MIME type parsing
+// https://mimesniff.spec.whatwg.org/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMIMETypeFromURL = exports.parseMIMEType = void 0;
+const DATA_URL_PATTERN = /^data:([-\w.]+\/[-\w.+]+)(;|,)/;
+const MIME_TYPE_PATTERN = /^([-\w.]+\/[-\w.+]+)/;
+/**
+ * Remove extra data like `charset` from MIME types
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+function parseMIMEType(mimeString) {
+    // If resource is a data url, extract any embedded mime type
+    const matches = MIME_TYPE_PATTERN.exec(mimeString);
+    if (matches) {
+        return matches[1];
+    }
+    return mimeString;
+}
+exports.parseMIMEType = parseMIMEType;
+/**
+ * Extract MIME type from data URL
+ *
+ * @param mimeString
+ * @returns A clean MIME type, or an empty string
+ *
+ * @todo - handle more advanced MIMETYpes, multiple types
+ * @todo - extract charset etc
+ */
+function parseMIMETypeFromURL(url) {
+    // If resource is a data URL, extract any embedded mime type
+    const matches = DATA_URL_PATTERN.exec(url);
+    if (matches) {
+        return matches[1];
+    }
+    return '';
+}
+exports.parseMIMETypeFromURL = parseMIMETypeFromURL;

package/dist/lib/utils/resource-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Returns an object with `url` and (MIME) `type` fields
+ * If it cannot determine url or type, the corresponding value will be an empty string
+ *
+ * @param resource Any type, but only Responses, string URLs and data URLs are processed
+ *
+ * @todo string parameters are assumed to be URLs
+ */
+export declare function getResourceUrlAndType(resource: any): {
+    url: string;
+    type: string;
+};
+/**
+  * Returns (approximate) content length for a resource if it can be determined.
+  * Returns -1 if content length cannot be determined.
+  * @param resource
+
+  * @note string parameters are NOT assumed to be URLs
+  */
+export declare function getResourceContentLength(resource: any): number;
+//# sourceMappingURL=resource-utils.d.ts.map

package/dist/lib/utils/resource-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/resource-utils.ts"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,GAAG,GAAG;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAmChF;AAED;;;;;;IAMI;AACJ,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,GAAG,GAAG,MAAM,CAkB9D"}

package/dist/lib/utils/resource-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResourceContentLength = exports.getResourceUrlAndType = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const mime_type_utils_1 = require("./mime-type-utils");
+const QUERY_STRING_PATTERN = /\?.*/;
+/**
+ * Returns an object with `url` and (MIME) `type` fields
+ * If it cannot determine url or type, the corresponding value will be an empty string
+ *
+ * @param resource Any type, but only Responses, string URLs and data URLs are processed
+ *
+ * @todo string parameters are assumed to be URLs
+ */
+function getResourceUrlAndType(resource) {
+    // If resource is a response, it contains the information directly
+    if ((0, is_type_1.isResponse)(resource)) {
+        const url = stripQueryString(resource.url || '');
+        const contentTypeHeader = resource.headers.get('content-type') || '';
+        return {
+            url,
+            type: (0, mime_type_utils_1.parseMIMEType)(contentTypeHeader) || (0, mime_type_utils_1.parseMIMETypeFromURL)(url)
+        };
+    }
+    // If the resource is a Blob or a File (subclass of Blob)
+    if ((0, is_type_1.isBlob)(resource)) {
+        return {
+            // File objects have a "name" property. Blob objects don't have any
+            // url (name) information
+            url: stripQueryString(resource.name || ''),
+            type: resource.type || ''
+        };
+    }
+    if (typeof resource === 'string') {
+        return {
+            // TODO this could mess up data URL but it doesn't matter as it is just used for inference
+            url: stripQueryString(resource),
+            // If a data url
+            type: (0, mime_type_utils_1.parseMIMETypeFromURL)(resource)
+        };
+    }
+    // Unknown
+    return {
+        url: '',
+        type: ''
+    };
+}
+exports.getResourceUrlAndType = getResourceUrlAndType;
+/**
+  * Returns (approximate) content length for a resource if it can be determined.
+  * Returns -1 if content length cannot be determined.
+  * @param resource
+
+  * @note string parameters are NOT assumed to be URLs
+  */
+function getResourceContentLength(resource) {
+    if ((0, is_type_1.isResponse)(resource)) {
+        return resource.headers['content-length'] || -1;
+    }
+    if ((0, is_type_1.isBlob)(resource)) {
+        return resource.size;
+    }
+    if (typeof resource === 'string') {
+        // TODO - handle data URL?
+        return resource.length;
+    }
+    if (resource instanceof ArrayBuffer) {
+        return resource.byteLength;
+    }
+    if (ArrayBuffer.isView(resource)) {
+        return resource.byteLength;
+    }
+    return -1;
+}
+exports.getResourceContentLength = getResourceContentLength;
+function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, '');
+}

package/dist/lib/utils/response-utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Returns a Response object
+ * Adds content-length header when possible
+ *
+ * @param resource
+ */
+export declare function makeResponse(resource: any): Promise<Response>;
+/**
+ * Checks response status (async) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+export declare function checkResponse(response: Response): Promise<void>;
+/**
+ * Checks response status (sync) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+export declare function checkResponseSync(response: Response): void;
+//# sourceMappingURL=response-utils.d.ts.map

package/dist/lib/utils/response-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/response-utils.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,QAAQ,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsCnE;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAKrE;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,CAM1D"}

package/dist/lib/utils/response-utils.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkResponseSync = exports.checkResponse = exports.makeResponse = void 0;
+const is_type_1 = require("../../javascript-utils/is-type");
+const resource_utils_1 = require("./resource-utils");
+/**
+ * Returns a Response object
+ * Adds content-length header when possible
+ *
+ * @param resource
+ */
+async function makeResponse(resource) {
+    if ((0, is_type_1.isResponse)(resource)) {
+        return resource;
+    }
+    // Add content-length header if possible
+    const headers = {};
+    const contentLength = (0, resource_utils_1.getResourceContentLength)(resource);
+    if (contentLength >= 0) {
+        headers['content-length'] = String(contentLength);
+    }
+    // `new Response(File)` does not preserve content-type and URL
+    // so we add them here
+    const { url, type } = (0, resource_utils_1.getResourceUrlAndType)(resource);
+    if (type) {
+        headers['content-type'] = type;
+    }
+    // Add a custom header with initial bytes if available
+    const initialDataUrl = await getInitialDataUrl(resource);
+    if (initialDataUrl) {
+        headers['x-first-bytes'] = initialDataUrl;
+    }
+    // TODO - is this the best way of handling strings?
+    // Maybe package as data URL instead?
+    if (typeof resource === 'string') {
+        // Convert to ArrayBuffer to avoid Response treating it as a URL
+        resource = new TextEncoder().encode(resource);
+    }
+    // Attempt to create a Response from the resource, adding headers and setting url
+    const response = new Response(resource, { headers });
+    // We can't control `Response.url` via constructor, use a property override to record URL.
+    Object.defineProperty(response, 'url', { value: url });
+    return response;
+}
+exports.makeResponse = makeResponse;
+/**
+ * Checks response status (async) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+async function checkResponse(response) {
+    if (!response.ok) {
+        const message = await getResponseError(response);
+        throw new Error(message);
+    }
+}
+exports.checkResponse = checkResponse;
+/**
+ * Checks response status (sync) and throws a helpful error message if status is not OK.
+ * @param response
+ */
+function checkResponseSync(response) {
+    if (!response.ok) {
+        let message = `${response.status} ${response.statusText}`;
+        message = message.length > 60 ? `${message.slice(60)}...` : message;
+        throw new Error(message);
+    }
+}
+exports.checkResponseSync = checkResponseSync;
+// HELPERS
+async function getResponseError(response) {
+    let message = `Failed to fetch resource ${response.url} (${response.status}): `;
+    try {
+        const contentType = response.headers.get('Content-Type');
+        let text = response.statusText;
+        if (contentType.includes('application/json')) {
+            text += ` ${await response.text()}`;
+        }
+        message += text;
+        message = message.length > 60 ? `${message.slice(60)}...` : message;
+    }
+    catch (error) {
+        // eslint forbids return in a finally statement, so we just catch here
+    }
+    return message;
+}
+async function getInitialDataUrl(resource) {
+    const INITIAL_DATA_LENGTH = 5;
+    if (typeof resource === 'string') {
+        return `data:,${resource.slice(0, INITIAL_DATA_LENGTH)}`;
+    }
+    if (resource instanceof Blob) {
+        const blobSlice = resource.slice(0, 5);
+        return await new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onload = (event) => resolve(event?.target?.result);
+            reader.readAsDataURL(blobSlice);
+        });
+    }
+    if (resource instanceof ArrayBuffer) {
+        const slice = resource.slice(0, INITIAL_DATA_LENGTH);
+        const base64 = arrayBufferToBase64(slice);
+        return `data:base64,${base64}`;
+    }
+    return null;
+}
+// https://stackoverflow.com/questions/9267899/arraybuffer-to-base64-encoded-string
+function arrayBufferToBase64(buffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    return btoa(binary);
+}

package/dist/null-loader.d.ts

@@ -0,0 +1,10 @@
+import { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
+export declare const NullWorkerLoader: Loader;
+/**
+ * Loads any data and returns null (or optionally passes through data unparsed)
+ */
+export declare const NullLoader: LoaderWithParser;
+//# sourceMappingURL=null-loader.d.ts.map

package/dist/null-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAY9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAkBxB,CAAC"}