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

package/dist/lib/loader-utils/get-data.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReadableStream = exports.getAsyncIterableFromData = exports.getArrayBufferOrStringFromData = exports.getArrayBufferOrStringFromDataSync = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const is_type_1 = require("../../javascript-utils/is-type");
+const make_iterator_1 = require("../../iterators/make-iterator/make-iterator");
+const response_utils_1 = require("../utils/response-utils");
+const ERR_DATA = 'Cannot convert supplied data type';
+// eslint-disable-next-line complexity
+function getArrayBufferOrStringFromDataSync(data, loader, options) {
+    if (loader.text && typeof data === 'string') {
+        return data;
+    }
+    if ((0, is_type_1.isBuffer)(data)) {
+        // @ts-ignore
+        data = data.buffer;
+    }
+    if (data instanceof ArrayBuffer) {
+        const arrayBuffer = data;
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(arrayBuffer);
+        }
+        return arrayBuffer;
+    }
+    // We may need to handle offsets
+    if (ArrayBuffer.isView(data)) {
+        // TextDecoder is invoked on typed arrays and will handle offsets
+        if (loader.text && !loader.binary) {
+            const textDecoder = new TextDecoder('utf8');
+            return textDecoder.decode(data);
+        }
+        let arrayBuffer = data.buffer;
+        // Since we are returning the underlying arrayBuffer, we must create a new copy
+        // if this typed array / Buffer is a partial view into the ArryayBuffer
+        // TODO - this is a potentially unnecessary copy
+        const byteLength = data.byteLength || data.length;
+        if (data.byteOffset !== 0 || byteLength !== arrayBuffer.byteLength) {
+            // console.warn(`loaders.gl copying arraybuffer of length ${byteLength}`);
+            arrayBuffer = arrayBuffer.slice(data.byteOffset, data.byteOffset + byteLength);
+        }
+        return arrayBuffer;
+    }
+    throw new Error(ERR_DATA);
+}
+exports.getArrayBufferOrStringFromDataSync = getArrayBufferOrStringFromDataSync;
+// Convert async iterator to a promise
+async function getArrayBufferOrStringFromData(data, loader, options) {
+    const isArrayBuffer = data instanceof ArrayBuffer || ArrayBuffer.isView(data);
+    if (typeof data === 'string' || isArrayBuffer) {
+        return getArrayBufferOrStringFromDataSync(data, loader, options);
+    }
+    // Blobs and files are FileReader compatible
+    if ((0, is_type_1.isBlob)(data)) {
+        data = await (0, response_utils_1.makeResponse)(data);
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        const response = data;
+        await (0, response_utils_1.checkResponse)(response);
+        return loader.binary ? await response.arrayBuffer() : await response.text();
+    }
+    if ((0, is_type_1.isReadableStream)(data)) {
+        // @ts-expect-error TS2559 options type
+        data = (0, make_iterator_1.makeIterator)(data, options);
+    }
+    if ((0, is_type_1.isIterable)(data) || (0, is_type_1.isAsyncIterable)(data)) {
+        // Assume arrayBuffer iterator - attempt to concatenate
+        return (0, loader_utils_1.concatenateArrayBuffersAsync)(data);
+    }
+    throw new Error(ERR_DATA);
+}
+exports.getArrayBufferOrStringFromData = getArrayBufferOrStringFromData;
+async function getAsyncIterableFromData(data, options) {
+    if ((0, is_type_1.isIterator)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        const response = data;
+        // Note Since this function is not async, we currently can't load error message, just status
+        await (0, response_utils_1.checkResponse)(response);
+        // TODO - bug in polyfill, body can be a Promise under Node.js
+        // eslint-disable-next-line @typescript-eslint/await-thenable
+        const body = await response.body;
+        // TODO - body can be null?
+        return (0, make_iterator_1.makeIterator)(body, options);
+    }
+    if ((0, is_type_1.isBlob)(data) || (0, is_type_1.isReadableStream)(data)) {
+        return (0, make_iterator_1.makeIterator)(data, options);
+    }
+    if ((0, is_type_1.isAsyncIterable)(data)) {
+        return data[Symbol.asyncIterator]();
+    }
+    return getIterableFromData(data);
+}
+exports.getAsyncIterableFromData = getAsyncIterableFromData;
+async function getReadableStream(data) {
+    if ((0, is_type_1.isReadableStream)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isResponse)(data)) {
+        // @ts-ignore
+        return data.body;
+    }
+    const response = await (0, response_utils_1.makeResponse)(data);
+    // @ts-ignore
+    return response.body;
+}
+exports.getReadableStream = getReadableStream;
+// HELPERS
+function getIterableFromData(data) {
+    // generate an iterator that emits a single chunk
+    if (ArrayBuffer.isView(data)) {
+        return (function* oneChunk() {
+            yield data.buffer;
+        })();
+    }
+    if (data instanceof ArrayBuffer) {
+        return (function* oneChunk() {
+            yield data;
+        })();
+    }
+    if ((0, is_type_1.isIterator)(data)) {
+        return data;
+    }
+    if ((0, is_type_1.isIterable)(data)) {
+        return data[Symbol.iterator]();
+    }
+    throw new Error(ERR_DATA);
+}

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

@@ -0,0 +1,13 @@
+import type { Loader, LoaderOptions, LoaderContext } from '@loaders.gl/loader-utils';
+/**
+ * "sub" loaders invoked by other loaders get a "context" injected on `this`
+ * The context will inject core methods like `parse` and contain information
+ * about loaders and options passed in to the top-level `parse` call.
+ *
+ * @param context
+ * @param options
+ * @param previousContext
+ */
+export declare function getLoaderContext(context: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>, options?: LoaderOptions, previousContext?: LoaderContext | null): LoaderContext;
+export declare function getLoadersFromContext(loaders: Loader[] | Loader | undefined, context?: LoaderContext): any;
+//# sourceMappingURL=loader-context.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loader-context.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/loader-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAGnF;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,aAAa,EAAE,OAAO,CAAC,CAAC,EAC7E,OAAO,CAAC,EAAE,aAAa,EACvB,eAAe,GAAE,aAAa,GAAG,IAAW,GAC3C,aAAa,CAkBf;AAGD,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,GAAG,SAAS,EACtC,OAAO,CAAC,EAAE,aAAa,OAkBxB"}

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLoadersFromContext = exports.getLoaderContext = void 0;
+const option_utils_1 = require("./option-utils");
+/**
+ * "sub" loaders invoked by other loaders get a "context" injected on `this`
+ * The context will inject core methods like `parse` and contain information
+ * about loaders and options passed in to the top-level `parse` call.
+ *
+ * @param context
+ * @param options
+ * @param previousContext
+ */
+function getLoaderContext(context, options, previousContext = null) {
+    // For recursive calls, we already have a context
+    // TODO - add any additional loaders to context?
+    if (previousContext) {
+        return previousContext;
+    }
+    const resolvedContext = {
+        fetch: (0, option_utils_1.getFetchFunction)(options, context),
+        ...context
+    };
+    // Recursive loading does not use single loader
+    if (!Array.isArray(resolvedContext.loaders)) {
+        resolvedContext.loaders = null;
+    }
+    return resolvedContext;
+}
+exports.getLoaderContext = getLoaderContext;
+// eslint-disable-next-line complexity
+function getLoadersFromContext(loaders, context) {
+    // A single non-array loader is force selected, but only on top-level (context === null)
+    if (!context && loaders && !Array.isArray(loaders)) {
+        return loaders;
+    }
+    // Create a merged list
+    let candidateLoaders;
+    if (loaders) {
+        candidateLoaders = Array.isArray(loaders) ? loaders : [loaders];
+    }
+    if (context && context.loaders) {
+        const contextLoaders = Array.isArray(context.loaders) ? context.loaders : [context.loaders];
+        candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
+    }
+    // If no loaders, return null to look in globally registered loaders
+    return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+}
+exports.getLoadersFromContext = getLoadersFromContext;

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

@@ -0,0 +1,16 @@
+export declare const probeLog: any;
+export declare class NullLog {
+    log(): () => void;
+    info(): () => void;
+    warn(): () => void;
+    error(): () => void;
+}
+export declare class ConsoleLog {
+    console: any;
+    constructor();
+    log(...args: any[]): any;
+    info(...args: any[]): any;
+    warn(...args: any[]): any;
+    error(...args: any[]): any;
+}
+//# sourceMappingURL=loggers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"loggers.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/loggers.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,QAAQ,KAA8B,CAAC;AAGpD,qBAAa,OAAO;IAClB,GAAG;IAGH,IAAI;IAGJ,IAAI;IAGJ,KAAK;CAGN;AAGD,qBAAa,UAAU;IACrB,OAAO,MAAC;;IAKR,GAAG,CAAC,GAAG,IAAI,OAAA;IAGX,IAAI,CAAC,GAAG,IAAI,OAAA;IAGZ,IAAI,CAAC,GAAG,IAAI,OAAA;IAGZ,KAAK,CAAC,GAAG,IAAI,OAAA;CAGd"}

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConsoleLog = exports.NullLog = exports.probeLog = void 0;
+// probe.gl Log compatible loggers
+const probe_gl_1 = require("probe.gl");
+exports.probeLog = new probe_gl_1.Log({ id: 'loaders.gl' });
+// Logs nothing
+class NullLog {
+    log() {
+        return () => { };
+    }
+    info() {
+        return () => { };
+    }
+    warn() {
+        return () => { };
+    }
+    error() {
+        return () => { };
+    }
+}
+exports.NullLog = NullLog;
+// Logs to console
+class ConsoleLog {
+    constructor() {
+        this.console = console; // eslint-disable-line
+    }
+    log(...args) {
+        return this.console.log.bind(this.console, ...args);
+    }
+    info(...args) {
+        return this.console.info.bind(this.console, ...args);
+    }
+    warn(...args) {
+        return this.console.warn.bind(this.console, ...args);
+    }
+    error(...args) {
+        return this.console.error.bind(this.console, ...args);
+    }
+}
+exports.ConsoleLog = ConsoleLog;

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

@@ -0,0 +1,4 @@
+import type { Loader } from '@loaders.gl/loader-utils';
+export declare function isLoaderObject(loader?: any): boolean;
+export declare function normalizeLoader(loader: Loader): Loader;
+//# sourceMappingURL=normalize-loader.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-loader.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/normalize-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGrD,wBAAgB,cAAc,CAAC,MAAM,CAAC,EAAE,GAAG,GAAG,OAAO,CAqBpD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAiCtD"}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLoader = exports.isLoaderObject = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+function isLoaderObject(loader) {
+    if (!loader) {
+        return false;
+    }
+    if (Array.isArray(loader)) {
+        loader = loader[0];
+    }
+    const hasExtensions = Array.isArray(loader?.extensions);
+    /* Now handled by types and worker loaders do not have these
+    let hasParser =
+      loader.parseTextSync ||
+      loader.parseSync ||
+      loader.parse ||
+      loader.parseStream || // TODO Remove, Replace with parseInBatches
+      loader.parseInBatches;
+    */
+    return hasExtensions;
+}
+exports.isLoaderObject = isLoaderObject;
+function normalizeLoader(loader) {
+    // This error is fairly easy to trigger by mixing up import statements etc
+    // So we make an exception and add a developer error message for this case
+    // To help new users from getting stuck here
+    (0, loader_utils_1.assert)(loader, 'null loader');
+    (0, loader_utils_1.assert)(isLoaderObject(loader), 'invalid loader');
+    // NORMALIZE [LOADER, OPTIONS] => LOADER
+    // If [loader, options], create a new loaders object with options merged in
+    let options;
+    if (Array.isArray(loader)) {
+        options = loader[1];
+        loader = loader[0];
+        loader = {
+            ...loader,
+            options: { ...loader.options, ...options }
+        };
+    }
+    // NORMALIZE text and binary flags
+    // Ensure at least one of text/binary flags are properly set
+    // @ts-expect-error
+    if (loader?.parseTextSync || loader?.parseText) {
+        loader.text = true;
+    }
+    if (!loader.text) {
+        loader.binary = true;
+    }
+    return loader;
+}
+exports.normalizeLoader = normalizeLoader;

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

@@ -0,0 +1,20 @@
+import type { LoaderOptions } from '@loaders.gl/loader-utils';
+export declare const DEFAULT_LOADER_OPTIONS: LoaderOptions;
+export declare const REMOVED_LOADER_OPTIONS: {
+    throws: string;
+    dataType: string;
+    uri: string;
+    method: string;
+    headers: string;
+    body: string;
+    mode: string;
+    credentials: string;
+    cache: string;
+    redirect: string;
+    referrer: string;
+    referrerPolicy: string;
+    integrity: string;
+    keepalive: string;
+    signal: string;
+};
+//# sourceMappingURL=option-defaults.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"option-defaults.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/option-defaults.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAG5D,eAAO,MAAM,sBAAsB,EAAE,aAoBpC,CAAC;AAEF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;CAiBlC,CAAC"}

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"}