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

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

@@ -1,11 +1,8 @@
-import type {
-  SyncDataType,
-  Loader,
-  LoaderWithParser,
-  LoaderContext,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
-import {assert} from '@loaders.gl/loader-utils';
+// 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 {selectLoaderSync} from './select-loader';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -13,21 +10,45 @@ import {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
 import {getResourceUrl} from '../utils/resource-utils';
 
+// OVERLOADS
+
+/**
+ * Parses `data` synchronously using the specified loader
+ */
+export function parseSync<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+>(
+  data: SyncDataType,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): LoaderReturnType<LoaderT>;
+
+/**
+ * Parses `data` synchronously by matching one of the supplied loaders
+ */
+export function parseSync(
+  data: SyncDataType,
+  loaders: Loader[],
+  options?: LoaderOptions,
+  context?: LoaderContext
+): any;
+
+/**
+ * Parses `data` synchronously by matching a pre=registered loader
+ */
+export function parseSync(data: SyncDataType, options?: LoaderOptions): any;
+
 /**
  * Parses `data` synchronously using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
  */
 export function parseSync(
   data: SyncDataType,
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): any {
-  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url
-
+): unknown {
   // Signature: parseSync(data, options)
   // Uses registered loaders
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -49,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);
@@ -58,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

@@ -1,9 +1,10 @@
 // loaders.gl, MIT license
 
-import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {DataType, LoaderWithParser} from '@loaders.gl/loader-utils';
 import type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';
-import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';
+import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {isResponse} from '../../javascript-utils/is-type';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -14,6 +15,9 @@ import {selectLoader} from './select-loader';
 
 // type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T
 
+/**
+ * Parses `data` asynchronously using the supplied loader
+ */
 export async function parse<
   LoaderT extends Loader,
   OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
@@ -24,6 +28,9 @@ export async function parse<
   context?: LoaderContext
 ): Promise<LoaderReturnType<LoaderT>>;
 
+/**
+ * Parses `data` asynchronously by matching one of the supplied loader
+ */
 export async function parse(
   data: DataType | Promise<DataType>,
   loaders: Loader[],
@@ -31,6 +38,9 @@ export async function parse(
   context?: LoaderContext
 ): Promise<any>;
 
+/**
+ * Parses data asynchronously by matching a pre-registered loader
+ */
 export async function parse(
   data: DataType | Promise<DataType>,
   options?: LoaderOptions
@@ -49,9 +59,7 @@ export async function parse(
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): Promise<any> {
-  assert(!context || typeof context === 'object'); // parse no longer accepts final url
-
+): Promise<unknown> {
   // Signature: parse(data, options, context | url)
   // Uses registered loaders
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -78,17 +86,28 @@ 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);
 }
 
 // TODO: support progress and abort
 // TODO - should accept loader.parseAsyncIterator and concatenate.
-async function parseWithLoader(loader, data, options, context) {
+async function parseWithLoader(
+  loader: Loader,
+  data,
+  options: LoaderOptions,
+  context: LoaderContext
+): Promise<unknown> {
   validateWorkerVersion(loader);
 
   if (isResponse(data)) {
@@ -96,15 +115,17 @@ async function parseWithLoader(loader, data, options, context) {
     const response = data as Response;
     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 getArrayBufferOrStringFromData(data, loader, options);
 
+  const loaderWithParser = loader as LoaderWithParser;
+
   // First check for synchronous text parser, wrap results in promises
-  if (loader.parseTextSync && typeof data === 'string') {
-    options.dataType = 'text';
-    return loader.parseTextSync(data, options, context, loader);
+  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
@@ -113,16 +134,16 @@ async function parseWithLoader(loader, data, options, context) {
   }
 
   // Check for asynchronous parser
-  if (loader.parseText && typeof data === 'string') {
-    return await loader.parseText(data, options, context, loader);
+  if (loaderWithParser.parseText && typeof data === 'string') {
+    return await loaderWithParser.parseText(data, options, context);
   }
 
-  if (loader.parse) {
-    return await loader.parse(data, options, context, loader);
+  if (loaderWithParser.parse) {
+    return await loaderWithParser.parse(data, options, context);
   }
 
   // This should not happen, all sync loaders should also offer `parse` function
-  assert(!loader.parseSync);
+  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/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 = {
@@ -36,9 +38,9 @@ export interface FileSystem {
  * A random access file system
  */
 export interface RandomAccessReadFileSystem extends FileSystem {
-  open(path: string, flags, mode?): Promise<any>;
-  close(fd: any): Promise<void>;
-  fstat(fd: any): Promise<Stat>;
+  open(path: string, flags: unknown, mode?: unknown): Promise<any>;
+  close(fd: unknown): Promise<void>;
+  fstat(fd: unknown): Promise<Stat>;
   read(
     fd: any,
     buffer: ArrayBuffer | ArrayBufferView,

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/get-fetch-function.ts

@@ -1,6 +1,6 @@
 // loaders.gl, MIT license
 
-import type {LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {LoaderContext, LoaderOptions, FetchLike} from '@loaders.gl/loader-utils';
 import {isObject} from '../../javascript-utils/is-type';
 import {fetchFile} from '../fetch/fetch-file';
 import {getGlobalLoaderOptions} from './option-utils';
@@ -13,7 +13,7 @@ import {getGlobalLoaderOptions} from './option-utils';
 export function getFetchFunction(
   options?: LoaderOptions,
   context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>
-) {
+): FetchLike {
   const globalOptions = getGlobalLoaderOptions();
 
   const loaderOptions = options || globalOptions;

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) {