@loaders.gl/core 4.0.0-alpha.21 → 4.0.0-alpha.22

package/dist/null-worker-node.js

@@ -143,7 +143,7 @@ function createLoaderWorker(loader) {
             arrayBuffer: input,
             options,
             context: __spreadProps(__spreadValues({}, context), {
-              parse: parseOnMainThread
+              _parse: parseOnMainThread
             })
           });
           WorkerBody.postMessage("done", { result });
@@ -156,7 +156,7 @@ function createLoaderWorker(loader) {
     }
   };
 }
-function parseOnMainThread(arrayBuffer, options) {
+function parseOnMainThread(arrayBuffer, loader, options, context) {
   return new Promise((resolve, reject) => {
     const id = requestId++;
     const onMessage = (type, payload2) => {
@@ -180,7 +180,12 @@ function parseOnMainThread(arrayBuffer, options) {
     WorkerBody.postMessage("process", payload);
   });
 }
-async function parseData({ loader, arrayBuffer, options, context }) {
+async function parseData({
+  loader,
+  arrayBuffer,
+  options,
+  context
+}) {
   let data;
   let parser;
   if (loader.parseSync || loader.parse) {
@@ -201,7 +206,7 @@ async function parseData({ loader, arrayBuffer, options, context }) {
 }
 
 // src/null-loader.ts
-var VERSION = true ? "4.0.0-alpha.21" : "latest";
+var VERSION = true ? "4.0.0-alpha.22" : "latest";
 var NullLoader = {
   name: "Null loader",
   id: "null",

package/dist/null-worker.js

@@ -125,7 +125,7 @@
               options,
               context: {
                 ...context,
-                parse: parseOnMainThread
+                _parse: parseOnMainThread
               }
             });
             WorkerBody.postMessage("done", { result });
@@ -138,7 +138,7 @@
       }
     };
   }
-  function parseOnMainThread(arrayBuffer, options) {
+  function parseOnMainThread(arrayBuffer, loader, options, context) {
     return new Promise((resolve, reject) => {
       const id = requestId++;
       const onMessage = (type, payload2) => {
@@ -162,7 +162,12 @@
       WorkerBody.postMessage("process", payload);
     });
   }
-  async function parseData({ loader, arrayBuffer, options, context }) {
+  async function parseData({
+    loader,
+    arrayBuffer,
+    options,
+    context
+  }) {
     let data;
     let parser;
     if (loader.parseSync || loader.parse) {
@@ -184,7 +189,7 @@
   }
 
   // src/null-loader.ts
-  var VERSION = true ? "4.0.0-alpha.21" : "latest";
+  var VERSION = true ? "4.0.0-alpha.22" : "latest";
   var NullLoader = {
     name: "Null loader",
     id: "null",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/core",
-  "version": "4.0.0-alpha.21",
+  "version": "4.0.0-alpha.22",
   "description": "The core API for working with loaders.gl loaders and writers",
   "license": "MIT",
   "publishConfig": {
@@ -47,9 +47,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.21",
-    "@loaders.gl/worker-utils": "4.0.0-alpha.21",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.22",
+    "@loaders.gl/worker-utils": "4.0.0-alpha.22",
     "@probe.gl/log": "^4.0.2"
   },
-  "gitHead": "df5d670b136192b26941396e944f9c46be788e83"
+  "gitHead": "0da838c506d1275383f2fd3d244d9c72b25397d2"
 }

package/src/index.ts

@@ -55,7 +55,7 @@ export {JSONLoader} from '@loaders.gl/loader-utils';
 // EXPERIMENTAL
 export {default as _fetchProgress} from './lib/progress/fetch-progress';
 export {default as _BrowserFileSystem} from './lib/filesystems/browser-filesystem';
-export {FileSystem} from './lib/filesystems/filesystem';
+export type {FileSystem} from './lib/filesystems/filesystem';
 
 // FOR TESTING
 export {_unregisterLoaders} from './lib/api/register-loaders';

package/src/iterators/make-stream/make-node-stream.ts

@@ -13,9 +13,12 @@ export function makeStream<ArrayBuffer>(
   source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,
   options?: ReadableOptions
 ): ReadableType {
+  // @ts-ignore AsyncGenerator
   const iterator = source[Symbol.asyncIterator]
-    ? source[Symbol.asyncIterator]()
-    : source[Symbol.iterator]();
+    ? // @ts-ignore AsyncGenerator
+    source[Symbol.asyncIterator]()
+    : // @ts-ignore AsyncGenerator
+    source[Symbol.iterator]();
   return new AsyncIterableReadable(iterator, options);
 }
 

package/src/lib/api/parse-in-batches.ts

@@ -4,7 +4,7 @@ import type {Batch} from '@loaders.gl/schema';
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import type {LoaderContext, BatchableDataType} from '@loaders.gl/loader-utils';
 import type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';
-import {assert, concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
+import {concatenateArrayBuffersAsync} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
 import {getLoaderContext} from '../loader-utils/loader-context';
@@ -59,8 +59,6 @@ export async function parseInBatches(
   options?: LoaderOptions,
   context?: LoaderContext
 ): Promise<AsyncIterable<unknown>> {
-  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url
-
   const loaderArray = Array.isArray(loaders) ? loaders : undefined;
 
   // Signature: parseInBatches(data, options, url) - Uses registered loaders
@@ -88,7 +86,7 @@ export async function parseInBatches(
   // Normalize options
   options = normalizeOptions(options, loader, loaderArray, url);
   context = getLoaderContext(
-    {url, parseInBatches, parse, loaders: loaderArray},
+    {url, _parseInBatches: parseInBatches, _parse: parse, loaders: loaderArray},
     options,
     context || null
   );
@@ -123,7 +121,9 @@ async function parseWithLoaderInBatches(
     bytesUsed: 0
   };
 
-  async function* makeMetadataBatchIterator(iterator) {
+  async function* makeMetadataBatchIterator(
+    iterator: Iterable<unknown> | AsyncIterable<unknown>
+  ): AsyncIterable<unknown> {
     yield metadataBatch;
     yield* iterator;
   }

package/src/lib/api/parse-sync.ts

@@ -1,7 +1,8 @@
+// loaders.gl, MIT license
+
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import type {LoaderContext, SyncDataType} from '@loaders.gl/loader-utils';
 import type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';
-import {assert} from '@loaders.gl/loader-utils';
 import {selectLoaderSync} from './select-loader';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -48,8 +49,6 @@ export function parseSync(
   options?: LoaderOptions,
   context?: LoaderContext
 ): unknown {
-  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url
-
   // Signature: parseSync(data, options)
   // Uses registered loaders
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -71,7 +70,7 @@ export function parseSync(
   }
 
   // Normalize options
-  options = normalizeOptions(options, loader, candidateLoaders);
+  options = normalizeOptions(options, loader, candidateLoaders as Loader[] | undefined);
 
   // Extract a url for auto detection
   const url = getResourceUrl(data);
@@ -80,7 +79,7 @@ export function parseSync(
     throw new Error('parseSync called parse (which is async');
   };
   context = getLoaderContext(
-    {url, parseSync, parse, loaders: loaders as Loader[]},
+    {url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},
     options,
     context || null
   );

package/src/lib/api/parse.ts

@@ -16,7 +16,7 @@ import {selectLoader} from './select-loader';
 // type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T
 
 /**
- * Parses `data` asynchronously using the supplied loaders
+ * Parses `data` asynchronously using the supplied loader
  */
 export async function parse<
   LoaderT extends Loader,
@@ -29,7 +29,7 @@ export async function parse<
 ): Promise<LoaderReturnType<LoaderT>>;
 
 /**
- * Parses `data` asynchronously by matching one of the supplied loaders
+ * Parses `data` asynchronously by matching one of the supplied loader
  */
 export async function parse(
   data: DataType | Promise<DataType>,
@@ -60,8 +60,6 @@ export async function parse(
   options?: LoaderOptions,
   context?: LoaderContext
 ): Promise<unknown> {
-  assert(!context || typeof context === 'object'); // parse no longer accepts final url
-
   // Signature: parse(data, options, context | url)
   // Uses registered loaders
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -88,10 +86,16 @@ export async function parse(
   }
 
   // Normalize options
+  // @ts-expect-error
   options = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
 
   // Get a context (if already present, will be unchanged)
-  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context || null);
+  context = getLoaderContext(
+    // @ts-expect-error
+    {url, _parse: parse, loaders: candidateLoaders},
+    options,
+    context || null
+  );
 
   return await parseWithLoader(loader, data, options, context);
 }

package/src/lib/api/save.ts

@@ -2,12 +2,12 @@ import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
 import {encode, encodeSync} from './encode';
 import {writeFile, writeFileSync} from '../fetch/write-file';
 
-export async function save(data, url, writer: Writer, options: WriterOptions) {
+export async function save(data: unknown, url: string, writer: Writer, options: WriterOptions) {
   const encodedData = await encode(data, writer, options);
   return await writeFile(url, encodedData);
 }
 
-export function saveSync(data, url, writer, options) {
+export function saveSync(data: unknown, url: string, writer: Writer, options: WriterOptions) {
   const encodedData = encodeSync(data, writer, options);
   return writeFileSync(url, encodedData);
 }

package/src/lib/api/select-loader.ts

@@ -6,6 +6,7 @@ import {getResourceUrl, getResourceMIMEType} from '../utils/resource-utils';
 import {getRegisteredLoaders} from './register-loaders';
 import {isBlob} from '../../javascript-utils/is-type';
 import {stripQueryString} from '../utils/url-utils';
+import {TypedArray} from '@loaders.gl/schema';
 
 const EXT_PATTERN = /\.([^.]+)$/;
 
@@ -135,12 +136,16 @@ function selectLoaderInternal(
   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
-  loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-  reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
+  if (options?.fallbackMimeType) {
+    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
+  }
 
   if (reason) {
     log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
@@ -150,7 +155,7 @@ function selectLoaderInternal(
 }
 
 /** Check HTTP Response */
-function validHTTPResponse(data: any): boolean {
+function validHTTPResponse(data: unknown): boolean {
   // 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
@@ -162,7 +167,7 @@ function validHTTPResponse(data: any): boolean {
 }
 
 /** Generate a helpful message to help explain why loader selection failed. */
-function getNoValidLoaderMessage(data): string {
+function getNoValidLoaderMessage(data: string | ArrayBuffer | Response | Blob): string {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
 
@@ -170,6 +175,7 @@ function getNoValidLoaderMessage(data): string {
   message += url ? `${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: string = data ? getFirstCharacters(data) : '';
   message += firstCharacters ? ` first bytes: "${firstCharacters}"` : 'first bytes: not available';
   message += ')';
@@ -204,7 +210,7 @@ function findLoaderByExtension(loaders: Loader[], extension: string): Loader | n
   return null;
 }
 
-function findLoaderByMIMEType(loaders, mimeType) {
+function findLoaderByMIMEType(loaders: Loader[], mimeType: string): Loader | null {
   for (const loader of loaders) {
     if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
       return loader;
@@ -219,7 +225,7 @@ function findLoaderByMIMEType(loaders, mimeType) {
   return null;
 }
 
-function findLoaderByInitialBytes(loaders, data) {
+function findLoaderByInitialBytes(loaders: Loader[], data: string | ArrayBuffer): Loader | null {
   if (!data) {
     return null;
   }
@@ -245,27 +251,32 @@ function findLoaderByInitialBytes(loaders, data) {
   return null;
 }
 
-function testDataAgainstText(data, loader) {
+function testDataAgainstText(data: string, loader: Loader): boolean {
   if (loader.testText) {
     return loader.testText(data);
   }
 
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-  return tests.some((test) => data.startsWith(test));
+  return tests.some((test) => data.startsWith(test as string));
 }
 
-function testDataAgainstBinary(data, byteOffset, loader) {
+function testDataAgainstBinary(data: ArrayBuffer, byteOffset: number, loader: Loader): boolean {
   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) {
+function testBinary(
+  data: ArrayBuffer,
+  byteOffset: number,
+  loader: Loader,
+  test?: ArrayBuffer | string | ((b: ArrayBuffer) => boolean)
+): boolean {
   if (test instanceof ArrayBuffer) {
     return compareArrayBuffers(test, data, test.byteLength);
   }
   switch (typeof test) {
     case 'function':
-      return test(data, loader);
+      return test(data);
 
     case 'string':
       // Magic bytes check: If `test` is a string, check if binary data starts with that strings
@@ -277,7 +288,7 @@ function testBinary(data, byteOffset, loader, test) {
   }
 }
 
-function getFirstCharacters(data, length: number = 5) {
+function getFirstCharacters(data: string | ArrayBuffer | TypedArray, length: number = 5) {
   if (typeof data === 'string') {
     return data.slice(0, length);
   } else if (ArrayBuffer.isView(data)) {
@@ -290,7 +301,7 @@ function getFirstCharacters(data, length: number = 5) {
   return '';
 }
 
-function getMagicString(arrayBuffer, byteOffset, length) {
+function getMagicString(arrayBuffer: ArrayBuffer, byteOffset: number, length: number): string {
   if (arrayBuffer.byteLength < byteOffset + length) {
     return '';
   }

package/src/lib/filesystems/browser-filesystem.ts

@@ -109,7 +109,7 @@ export default class BrowserFileSystem implements FileSystem {
   // implements IRandomAccessFileSystem
 
   // RANDOM ACCESS
-  async open(pathname: string, flags, mode?): Promise<any> {
+  async open(pathname: string, flags: unknown, mode?: unknown): Promise<any> {
     return this.files[pathname];
   }
 
@@ -144,8 +144,8 @@ export default class BrowserFileSystem implements FileSystem {
   // PRIVATE
 
   // Supports case independent paths, and file usage tracking
-  _getFile(path, used) {
-    // Prefer case match, but fall back to case indepent.
+  _getFile(path: string, used: boolean): File {
+    // Prefer case match, but fall back to case independent.
     const file = this.files[path] || this.lowerCaseFiles[path];
     if (file && used) {
       this.usedFiles[path] = true;

package/src/lib/filesystems/filesystem.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 export type ReadOptions = {};
 
 export type Stat = {

package/src/lib/init.ts

@@ -8,6 +8,7 @@ const version = typeof __VERSION__ !== 'undefined' ? __VERSION__ : '';
 if (!globalThis.loaders) {
   log.log(1, `loaders.gl ${version}`)();
 
+  // @ts-ignore TS2339: Property 'loaders' does not exist on type 'Window & typeof globalThis'.
   globalThis.loaders = Object.assign(globalThis.loaders || {}, {
     VERSION: version,
     log

package/src/lib/loader-utils/get-data.ts

@@ -127,6 +127,7 @@ export async function getAsyncIterableFromData(
   }
 
   if (isAsyncIterable(data)) {
+    // @ts-ignore
     return data[Symbol.asyncIterator]();
   }
 

package/src/lib/loader-utils/loader-context.ts

@@ -3,6 +3,9 @@ import {getFetchFunction} from './get-fetch-function';
 import {extractQueryString, stripQueryString} from '../utils/url-utils';
 import {path} from '@loaders.gl/loader-utils';
 
+/** Properties for creating an updated context */
+type LoaderContextProps = Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>;
+
 /**
  * "sub" loaders invoked by other loaders get a "context" injected on `this`
  * The context will inject core methods like `parse` and contain information
@@ -13,7 +16,7 @@ import {path} from '@loaders.gl/loader-utils';
  * @param previousContext
  */
 export function getLoaderContext(
-  context: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>,
+  context: LoaderContextProps,
   options: LoaderOptions,
   parentContext: LoaderContext | null
 ): LoaderContext {
@@ -49,9 +52,9 @@ export function getLoaderContext(
 export function getLoadersFromContext(
   loaders: Loader[] | Loader | undefined,
   context?: LoaderContext
-) {
-  // A single non-array loader is force selected, but only on top-level (context === null)
-  if (!context && loaders && !Array.isArray(loaders)) {
+): Loader | Loader[] | undefined {
+  // A single loader (non-array) indicates no selection desired. Force select.
+  if (loaders && !Array.isArray(loaders)) {
     return loaders;
   }
 
@@ -65,5 +68,5 @@ export function getLoadersFromContext(
     candidateLoaders = candidateLoaders ? [...candidateLoaders, ...contextLoaders] : contextLoaders;
   }
   // If no loaders, return null to look in globally registered loaders
-  return candidateLoaders && candidateLoaders.length ? candidateLoaders : null;
+  return candidateLoaders && candidateLoaders.length ? candidateLoaders : undefined;
 }

package/src/lib/loader-utils/loggers.ts

@@ -3,18 +3,20 @@ import {Log} from '@probe.gl/log';
 
 export const probeLog = new Log({id: 'loaders.gl'});
 
+type LogFunction = () => void;
+
 // Logs nothing
 export class NullLog {
-  log() {
+  log(): LogFunction {
     return () => {};
   }
-  info() {
+  info(): LogFunction {
     return () => {};
   }
-  warn() {
+  warn(): LogFunction {
     return () => {};
   }
-  error() {
+  error(): LogFunction {
     return () => {};
   }
 }
@@ -26,16 +28,16 @@ export class ConsoleLog {
   constructor() {
     this.console = console; // eslint-disable-line
   }
-  log(...args) {
+  log(...args: unknown[]): LogFunction {
     return this.console.log.bind(this.console, ...args);
   }
-  info(...args) {
+  info(...args: unknown[]): LogFunction {
     return this.console.info.bind(this.console, ...args);
   }
-  warn(...args) {
+  warn(...args: unknown[]): LogFunction {
     return this.console.warn.bind(this.console, ...args);
   }
-  error(...args) {
+  error(...args: unknown[]): LogFunction {
     return this.console.error.bind(this.console, ...args);
   }
 }

package/src/lib/loader-utils/option-utils.ts

@@ -33,12 +33,12 @@ export function getGlobalLoaderState(): GlobalLoaderState {
  * NOTE: This use case is not reliable but can help when testing new versions of loaders.gl with existing frameworks
  * @returns global loader options merged with default loader options
  */
-export const getGlobalLoaderOptions = (): LoaderOptions => {
+export function getGlobalLoaderOptions(): LoaderOptions {
   const state = getGlobalLoaderState();
   // Ensure all default loader options from this library are mentioned
   state.globalOptions = state.globalOptions || {...DEFAULT_LOADER_OPTIONS};
   return state.globalOptions;
-};
+}
 
 /**
  * Set global loader options
@@ -47,6 +47,7 @@ export const getGlobalLoaderOptions = (): LoaderOptions => {
 export function setGlobalOptions(options: LoaderOptions): void {
   const state = getGlobalLoaderState();
   const globalOptions = getGlobalLoaderOptions();
+  // @ts-expect-error First param looks incorrect
   state.globalOptions = normalizeOptionsInternal(globalOptions, options);
 }
 
@@ -77,12 +78,15 @@ export function normalizeOptions(
  * @param options
  * @param loaders
  */
-function validateOptions(options: LoaderOptions, loaders: Loader[]) {
+function validateOptions(options: LoaderOptions, loaders: Loader[]): void {
   // Check top level options
   validateOptionsObject(options, null, DEFAULT_LOADER_OPTIONS, 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]) || {};
+    const idOptions: Record<string, unknown> = ((options && options[loader.id]) || {}) as Record<
+      string,
+      unknown
+    >;
 
     // Get scoped, loader specific default and deprecated options from the selected loader
     const loaderOptions = (loader.options && loader.options[loader.id]) || {};
@@ -90,18 +94,19 @@ function validateOptions(options: LoaderOptions, loaders: Loader[]) {
       (loader.deprecatedOptions && loader.deprecatedOptions[loader.id]) || {};
 
     // Validate loader specific options
+    // @ts-ignore
     validateOptionsObject(idOptions, loader.id, loaderOptions, deprecatedOptions, loaders);
   }
 }
 
 // eslint-disable-next-line max-params, complexity
 function validateOptionsObject(
-  options,
+  options: LoaderOptions,
   id: string | null,
-  defaultOptions,
-  deprecatedOptions,
+  defaultOptions: Record<string, unknown>,
+  deprecatedOptions: Record<string, unknown>,
   loaders: Loader[]
-) {
+): void {
   const loaderName = id || 'Top level';
   const prefix = id ? `${id}.` : '';
 
@@ -127,7 +132,7 @@ function validateOptionsObject(
   }
 }
 
-function findSimilarOption(optionKey, loaders) {
+function findSimilarOption(optionKey: string, loaders: Loader[]): string {
   const lowerCaseOptionKey = optionKey.toLowerCase();
   let bestSuggestion = '';
   for (const loader of loaders) {
@@ -146,7 +151,11 @@ function findSimilarOption(optionKey, loaders) {
   return bestSuggestion;
 }
 
-function normalizeOptionsInternal(loader, options, url?: string) {
+function normalizeOptionsInternal(
+  loader: Loader,
+  options: LoaderOptions,
+  url?: string
+): LoaderOptions {
   const loaderDefaultOptions = loader.options || {};
 
   const mergedOptions = {...loaderDefaultOptions};
@@ -165,7 +174,7 @@ function normalizeOptionsInternal(loader, options, url?: string) {
 }
 
 // Merge nested options objects
-function mergeNestedFields(mergedOptions, options) {
+function mergeNestedFields(mergedOptions: LoaderOptions, options: LoaderOptions): void {
   for (const key in options) {
     // Check for nested options
     // object in options => either no key in defaultOptions or object in defaultOptions
@@ -173,8 +182,8 @@ function mergeNestedFields(mergedOptions, options) {
       const value = options[key];
       if (isPureObject(value) && isPureObject(mergedOptions[key])) {
         mergedOptions[key] = {
-          ...mergedOptions[key],
-          ...options[key]
+          ...(mergedOptions[key] as object),
+          ...(options[key] as object)
         };
       } else {
         mergedOptions[key] = options[key];
@@ -192,7 +201,7 @@ function mergeNestedFields(mergedOptions, options) {
  * TODO - extract query parameters?
  * TODO - should these be injected on context instead of options?
  */
-function addUrlOptions(options, url?: string) {
+function addUrlOptions(options: LoaderOptions, url?: string): void {
   if (url && !('baseUri' in options)) {
     options.baseUri = url;
   }

package/src/lib/progress/fetch-progress.ts

@@ -43,7 +43,15 @@ export default async function 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) {
+async function read(
+  controller: any,
+  reader: any,
+  loadedBytes: number,
+  totalBytes: number,
+  onProgress: Function,
+  onDone: Function,
+  onError: Function
+): Promise<void> {
   try {
     const {done, value} = await reader.read();
     if (done) {

package/src/null-loader.ts

@@ -3,7 +3,7 @@
 const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
 
 import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {LoaderContext} from 'modules/loader-utils/dist';
+import {LoaderContext} from '@loaders.gl/loader-utils';
 
 export type NullLoaderOptions = LoaderOptions & {
   null?: {};