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

package/dist/lib/filesystems/filesystem.d.ts

@@ -35,9 +35,9 @@ export interface FileSystem {
  * A random access file system
  */
 export interface RandomAccessReadFileSystem extends FileSystem {
-    open(path: string, flags: any, mode?: any): 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, offset?: number, length?: number, position?: number): Promise<{
         bytesRead: number;
         buffer: ArrayBuffer;

package/dist/lib/filesystems/filesystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/lib/filesystems/filesystem.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,EAAE,CAAC;AAE7B,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE9E;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAElE;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,UAAU;IAC5D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,KAAA,EAAE,IAAI,CAAC,KAAA,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAC/C,KAAK,CAAC,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,KAAK,CAAC,EAAE,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC9B,IAAI,CACF,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,WAAW,GAAG,eAAe,EACrC,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,CAAC,CAAC;CACtD"}
+{"version":3,"file":"filesystem.d.ts","sourceRoot":"","sources":["../../../src/lib/filesystems/filesystem.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,EAAE,CAAC;AAE7B,MAAM,MAAM,IAAI,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,OAAO,CAAC;CAC5B,CAAC;AAEF;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;OAGG;IACH,OAAO,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAE9E;;;;;OAKG;IACH,IAAI,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAElE;;;;OAIG;IACH,KAAK,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;CACxE;AAED;;GAEG;AACH,MAAM,WAAW,0BAA2B,SAAQ,UAAU;IAC5D,IAAI,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACjE,KAAK,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,KAAK,CAAC,EAAE,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC,IAAI,CACF,EAAE,EAAE,GAAG,EACP,MAAM,EAAE,WAAW,GAAG,eAAe,EACrC,MAAM,CAAC,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAC,CAAC,CAAC;CACtD"}

package/dist/lib/loader-utils/get-fetch-function.d.ts

@@ -1,8 +1,8 @@
-import type { LoaderContext, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { LoaderContext, LoaderOptions, FetchLike } from '@loaders.gl/loader-utils';
 /**
  * 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'>>): (url: string, options?: RequestInit | undefined) => Promise<Response>;
+export declare function getFetchFunction(options?: LoaderOptions, context?: Omit<LoaderContext, 'fetch'> & Partial<Pick<LoaderContext, 'fetch'>>): FetchLike;
 //# sourceMappingURL=get-fetch-function.d.ts.map

package/dist/lib/loader-utils/get-fetch-function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-fetch-function.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/get-fetch-function.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAK3E;;;;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,yEAuB/E"}
+{"version":3,"file":"get-fetch-function.d.ts","sourceRoot":"","sources":["../../../src/lib/loader-utils/get-fetch-function.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAKtF;;;;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,GAC7E,SAAS,CAsBX"}

package/dist/null-loader.d.ts

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

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

@@ -1 +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;AAYF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAoBxB,CAAC"}
+{"version":3,"file":"null-loader.d.ts","sourceRoot":"","sources":["../src/null-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAGtF,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAAG;IAC9C,IAAI,CAAC,EAAE,EAAE,CAAC;CACX,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,iBAAiB,CAYnE,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,UAAU,EAAE,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE,iBAAiB,CAmBtE,CAAC"}

package/dist/null-loader.js

@@ -20,16 +20,6 @@ exports.NullWorkerLoader = {
         null: {}
     }
 };
-/**
- * Returns arguments passed to the parse API in a format that can be transfered to a
- * web worker. The `context` parameter is stripped using JSON.stringify & parse.
- */
-function parseSync(arrayBuffer, options, context) {
-    if (!options.null.echoParameters)
-        return null;
-    context = context && JSON.parse(JSON.stringify(context));
-    return { arrayBuffer, options, context };
-}
 /**
  * Loads any data and returns null (or optionally passes through data unparsed)
  */
@@ -40,7 +30,7 @@ exports.NullLoader = {
     version: VERSION,
     mimeTypes: ['application/x.empty'],
     extensions: ['null'],
-    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options || {}, context),
     parseSync,
     parseInBatches: async function* generator(asyncIterator, options, context) {
         for await (const batch of asyncIterator) {
@@ -49,8 +39,13 @@ exports.NullLoader = {
     },
     tests: [() => false],
     options: {
-        null: {
-            echoParameters: false
-        }
+        null: {}
     }
 };
+/**
+ * Returns arguments passed to the parse API in a format that can be transferred to a
+ * web worker. The `context` parameter is stripped using JSON.stringify & parse.
+ */
+function parseSync(arrayBuffer, options, context) {
+    return null;
+}

package/dist/null-worker-node.js

@@ -201,13 +201,7 @@ async function parseData({ loader, arrayBuffer, options, context }) {
 }
 
 // src/null-loader.ts
-var VERSION = true ? "4.0.0-alpha.20" : "latest";
-function parseSync(arrayBuffer, options, context) {
-  if (!options.null.echoParameters)
-    return null;
-  context = context && JSON.parse(JSON.stringify(context));
-  return { arrayBuffer, options, context };
-}
+var VERSION = true ? "4.0.0-alpha.21" : "latest";
 var NullLoader = {
   name: "Null loader",
   id: "null",
@@ -215,7 +209,7 @@ var NullLoader = {
   version: VERSION,
   mimeTypes: ["application/x.empty"],
   extensions: ["null"],
-  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+  parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options || {}, context),
   parseSync,
   parseInBatches: async function* generator(asyncIterator, options, context) {
     for await (const batch of asyncIterator) {
@@ -224,11 +218,12 @@ var NullLoader = {
   },
   tests: [() => false],
   options: {
-    null: {
-      echoParameters: false
-    }
+    null: {}
   }
 };
+function parseSync(arrayBuffer, options, context) {
+  return null;
+}
 
 // src/workers/null-worker.ts
 createLoaderWorker(NullLoader);

package/dist/null-worker.js

@@ -184,13 +184,7 @@
   }
 
   // src/null-loader.ts
-  var VERSION = true ? "4.0.0-alpha.20" : "latest";
-  function parseSync(arrayBuffer, options, context) {
-    if (!options.null.echoParameters)
-      return null;
-    context = context && JSON.parse(JSON.stringify(context));
-    return { arrayBuffer, options, context };
-  }
+  var VERSION = true ? "4.0.0-alpha.21" : "latest";
   var NullLoader = {
     name: "Null loader",
     id: "null",
@@ -198,7 +192,7 @@
     version: VERSION,
     mimeTypes: ["application/x.empty"],
     extensions: ["null"],
-    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options, context),
+    parse: async (arrayBuffer, options, context) => parseSync(arrayBuffer, options || {}, context),
     parseSync,
     parseInBatches: async function* generator(asyncIterator, options, context) {
       for await (const batch of asyncIterator) {
@@ -207,11 +201,12 @@
     },
     tests: [() => false],
     options: {
-      null: {
-        echoParameters: false
-      }
+      null: {}
     }
   };
+  function parseSync(arrayBuffer, options, context) {
+    return null;
+  }
 
   // src/workers/null-worker.ts
   createLoaderWorker(NullLoader);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/core",
-  "version": "4.0.0-alpha.20",
+  "version": "4.0.0-alpha.21",
   "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.20",
-    "@loaders.gl/worker-utils": "4.0.0-alpha.20",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.21",
+    "@loaders.gl/worker-utils": "4.0.0-alpha.21",
     "@probe.gl/log": "^4.0.2"
   },
-  "gitHead": "ac122e83102657c38207d59c631a5ce4e7aa46bd"
+  "gitHead": "df5d670b136192b26941396e944f9c46be788e83"
 }

package/src/index.ts

@@ -55,6 +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';
 
 // FOR TESTING
 export {_unregisterLoaders} from './lib/api/register-loaders';

package/src/iterators/batch-iterators/timed-batch-iterator.ts

@@ -1,7 +1,10 @@
 /**
  * "Debounces" batches and returns them in groups
  */
-export async function* timedBatchIterator<Batch>(batchIterator: AsyncIterable<Batch>, timeout) {
+export async function* timedBatchIterator<Batch>(
+  batchIterator: AsyncIterable<Batch>,
+  timeout: number
+): AsyncIterable<Batch[]> {
   let start = Date.now();
   let batches: Batch[] = [];
   for await (const batch of batchIterator) {

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

@@ -15,7 +15,8 @@ export function makeStream<ArrayBuffer>(
   source: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer>,
   options?: MakeStreamOptions
 ): ReadableStream {
-  const iterator = source[Symbol.asyncIterator]
+  // TODO - add AsyncGenerator to parameter types?
+  const iterator = (source as AsyncGenerator<ArrayBuffer>)[Symbol.asyncIterator]
     ? (source as AsyncIterable<ArrayBuffer>)[Symbol.asyncIterator]()
     : (source as Iterable<ArrayBuffer>)[Symbol.iterator]();
 

package/src/javascript-utils/is-type.ts

@@ -1,17 +1,19 @@
+// luma.gl, MIT license
 import type {Readable} from 'stream';
 
 /** A DOM or Node readable stream */
 export type ReadableStreamType = ReadableStream | Readable;
 
-const isBoolean: (x: any) => boolean = (x) => typeof x === 'boolean';
-const isFunction: (x: any) => boolean = (x) => typeof x === 'function';
+const isBoolean: (x: unknown) => boolean = (x) => typeof x === 'boolean';
+const isFunction: (x: unknown) => boolean = (x) => typeof x === 'function';
 
-export const isObject: (x: any) => boolean = (x) => x !== null && typeof x === 'object';
+export const isObject: (x: unknown) => boolean = (x) => x !== null && typeof x === 'object';
 export const isPureObject: (x: any) => boolean = (x) =>
   isObject(x) && x.constructor === {}.constructor;
 export const isPromise: (x: any) => boolean = (x) => isObject(x) && isFunction(x.then);
 
-export const isIterable: (x: any) => boolean = (x) => x && typeof x[Symbol.iterator] === 'function';
+export const isIterable: (x: any) => boolean = (x) =>
+  Boolean(x) && typeof x[Symbol.iterator] === 'function';
 export const isAsyncIterable: (x: any) => boolean = (x) =>
   x && typeof x[Symbol.asyncIterator] === 'function';
 export const isIterator: (x: any) => boolean = (x) => x && isFunction(x.next);
@@ -20,8 +22,10 @@ export const isResponse: (x: any) => boolean = (x) =>
   (typeof Response !== 'undefined' && x instanceof Response) ||
   (x && x.arrayBuffer && x.text && x.json);
 
-export const isFile: (x: any) => boolean = (x) => typeof File !== 'undefined' && x instanceof File;
-export const isBlob: (x: any) => boolean = (x) => typeof Blob !== 'undefined' && x instanceof Blob;
+export const isFile: (x: unknown) => boolean = (x) =>
+  typeof File !== 'undefined' && x instanceof File;
+export const isBlob: (x: unknown) => boolean = (x) =>
+  typeof Blob !== 'undefined' && x instanceof Blob;
 
 /** Check for Node.js `Buffer` without triggering bundler to include buffer polyfill */
 export const isBuffer: (x: any) => boolean = (x) => x && typeof x === 'object' && x.isBuffer;
@@ -38,7 +42,7 @@ export const isWritableNodeStream: (x: any) => boolean = (x) =>
   isObject(x) && isFunction(x.end) && isFunction(x.write) && isBoolean(x.writable);
 export const isReadableNodeStream: (x: any) => boolean = (x) =>
   isObject(x) && isFunction(x.read) && isFunction(x.pipe) && isBoolean(x.readable);
-export const isReadableStream: (x: any) => boolean = (x) =>
+export const isReadableStream: (x: unknown) => boolean = (x) =>
   isReadableDOMStream(x) || isReadableNodeStream(x);
-export const isWritableStream: (x: any) => boolean = (x) =>
+export const isWritableStream: (x: unknown) => boolean = (x) =>
   isWritableDOMStream(x) || isWritableNodeStream(x);

package/src/lib/api/encode-table.ts

@@ -65,7 +65,7 @@ export function encodeTableInBatches<WriterT extends Writer = Writer>(
   throw new Error('Writer could not encode data in batches');
 }
 
-function getIterator(data) {
+function getIterator(data: any): Iterable<{table: any; start: number; end: number}> {
   const dataIterator = [{table: data, start: 0, end: data.length}];
   return dataIterator;
 }

package/src/lib/api/encode.ts

@@ -10,7 +10,7 @@ import {getLoaderOptions} from './loader-options';
  * Encode loaded data into a binary ArrayBuffer using the specified Writer.
  */
 export async function encode(
-  data: any,
+  data: unknown,
   writer: Writer,
   options?: WriterOptions
 ): Promise<ArrayBuffer> {
@@ -40,7 +40,7 @@ export async function encode(
     const batches = encodeInBatches(data, writer, options);
 
     // Concatenate the output
-    const chunks: any[] = [];
+    const chunks: unknown[] = [];
     for await (const batch of batches) {
       chunks.push(batch);
     }
@@ -51,7 +51,7 @@ export async function encode(
   if (!isBrowser && writer.encodeURLtoURL) {
     // TODO - how to generate filenames with correct extensions?
     const tmpInputFilename = getTemporaryFilename('input');
-    await writeFile(tmpInputFilename, data);
+    await writeFile(tmpInputFilename, data as ArrayBuffer);
 
     const tmpOutputFilename = getTemporaryFilename('output');
 
@@ -72,7 +72,7 @@ export async function encode(
 /**
  * Encode loaded data into a binary ArrayBuffer using the specified Writer.
  */
-export function encodeSync(data: any, writer: Writer, options?: WriterOptions): ArrayBuffer {
+export function encodeSync(data: unknown, writer: Writer, options?: WriterOptions): ArrayBuffer {
   if (writer.encodeSync) {
     return writer.encodeSync(data, options);
   }
@@ -86,7 +86,7 @@ export function encodeSync(data: any, writer: Writer, options?: WriterOptions):
  * @throws if the writer does not generate text output
  */
 export async function encodeText(
-  data: any,
+  data: unknown,
   writer: Writer,
   options?: WriterOptions
 ): Promise<string> {
@@ -106,7 +106,7 @@ export async function encodeText(
  * Encode loaded data into a sequence (iterator) of binary ArrayBuffers using the specified Writer.
  */
 export function encodeInBatches(
-  data: any,
+  data: unknown,
   writer: Writer,
   options?: WriterOptions
 ): AsyncIterable<ArrayBuffer> {
@@ -124,10 +124,10 @@ export function encodeInBatches(
  * @note Node.js only. This function enables using command-line converters as "writers".
  */
 export async function encodeURLtoURL(
-  inputUrl,
-  outputUrl,
+  inputUrl: string,
+  outputUrl: string,
   writer: Writer,
-  options
+  options?: WriterOptions
 ): Promise<string> {
   inputUrl = resolvePath(inputUrl);
   outputUrl = resolvePath(outputUrl);
@@ -141,7 +141,7 @@ export async function encodeURLtoURL(
 /**
  * @todo TODO - this is an unacceptable hack!!!
  */
-function getIterator(data) {
+function getIterator(data: any): Iterable<{table: any; start: number; end: number}> {
   const dataIterator = [{table: data, start: 0, end: data.length}];
   return dataIterator;
 }

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

@@ -1,4 +1,12 @@
-import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {
+  LoaderWithParser,
+  LoaderOptions,
+  LoaderContext,
+  FetchLike
+} from '@loaders.gl/loader-utils';
+import type {LoaderBatchType, LoaderOptionsType} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {getFetchFunction} from '../loader-utils/get-fetch-function';
 
@@ -6,6 +14,19 @@ import {parseInBatches} from './parse-in-batches';
 
 type FileType = string | File | Blob | Response | (string | File | Blob | Response)[] | FileList;
 
+/**
+ * Parses `data` synchronously using a specified loader
+ */
+export async function loadInBatches<
+  LoaderT extends LoaderWithParser,
+  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+>(
+  files: FileType,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;
+
 /**
  * Parses `data` using a specified loader
  * @param data
@@ -27,12 +48,20 @@ export function loadInBatches(
   context?: LoaderContext
 ): Promise<AsyncIterable<any>>;
 
-export function loadInBatches(files, loaders, options, context) {
+export function loadInBatches(
+  files: FileType | FileType[] | FileList,
+  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,
+  options?: LoaderOptions,
+  context?: LoaderContext
+) {
+  let loadersArray: LoaderWithParser | LoaderWithParser[] | undefined;
   // Signature: load(url, options)
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = undefined; // context not supported in short signature
-    options = loaders;
-    loaders = null;
+    options = loaders as LoaderOptions;
+    loadersArray = undefined;
+  } else {
+    loadersArray = loaders as LoaderWithParser | LoaderWithParser[] | undefined;
   }
 
   // Select fetch function
@@ -40,21 +69,30 @@ export function loadInBatches(files, loaders, options, context) {
 
   // Single url/file
   if (!Array.isArray(files)) {
-    return loadOneFileInBatches(files, loaders, options, fetch);
+    return loadOneFileInBatches(files, loadersArray!, options || {}, fetch);
   }
 
   // Multiple URLs / files
-  const promises = files.map((file) => loadOneFileInBatches(file, loaders, options, fetch));
+  const promises = files.map((file) =>
+    loadOneFileInBatches(file, loadersArray!, options || {}, fetch)
+  );
 
   // No point in waiting here for all responses before starting to stream individual streams?
   return promises;
 }
 
-async function loadOneFileInBatches(file, loaders, options, fetch) {
+async function loadOneFileInBatches(
+  file: FileType,
+  loaders: LoaderWithParser | LoaderWithParser[],
+  options: LoaderOptions,
+  fetch: FetchLike
+) {
   if (typeof file === 'string') {
     const url = file;
     const response = await fetch(url);
+    // @ts-expect-error
     return await parseInBatches(response, loaders, options);
   }
+  // @ts-expect-error TODO
   return await parseInBatches(file, loaders, options);
 }

package/src/lib/api/load.ts

@@ -25,10 +25,7 @@ export async function load<LoaderT extends Loader>(
   context?: LoaderContext
 ): Promise<LoaderReturnType<LoaderT>>;
 
-export async function load<
-  LoaderT extends Loader, // eslint-disable-line  @typescript-eslint/no-unused-vars
-  LoaderOptionsT extends LoaderOptions = LoaderOptions
->(
+export async function load<LoaderOptionsT extends LoaderOptions = LoaderOptions>(
   url: string | DataType,
   loaders: Loader[] | LoaderOptions,
   options?: LoaderOptionsT,
@@ -36,7 +33,7 @@ export async function load<
 ): Promise<any>;
 
 // implementation signature
-export async function load<LoaderOptionsT extends LoaderOptions>(
+export async function load<LoaderOptionsT extends LoaderOptions = LoaderOptions>(
   url: string | DataType,
   loaders?: Loader[] | LoaderOptions,
   options?: LoaderOptionsT,

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

@@ -1,11 +1,9 @@
+// loaders.gl, MIT license
+
 import type {Batch} from '@loaders.gl/schema';
-import type {
-  BatchableDataType,
-  Loader,
-  LoaderWithParser,
-  LoaderContext,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
+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 {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -17,6 +15,37 @@ import {selectLoader} from './select-loader';
 // Ensure `parse` is available in context if loader falls back to `parse`
 import {parse} from './parse';
 
+/**
+ * Parses `data` synchronously using a specified loader
+ */
+export async function parseInBatches<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+>(
+  data: BatchableDataType,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<AsyncIterable<LoaderBatchType<LoaderT>>>;
+
+/**
+ * Parses `data` using one of the supplied loaders
+ */
+export async function parseInBatches(
+  data: BatchableDataType,
+  loaders: Loader[],
+  options?: LoaderOptions,
+  context?: LoaderContext
+): Promise<AsyncIterable<any>>;
+
+/**
+ * Parses `data` in batches by selecting a pre-registered loader
+ */
+export async function parseInBatches(
+  data: BatchableDataType,
+  options?: LoaderOptions
+): Promise<AsyncIterable<any>>;
+
 /**
  * Parses `data` using a specified loader
  * @param data
@@ -29,7 +58,7 @@ export async function parseInBatches(
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): Promise<AsyncIterable<any>> {
+): Promise<AsyncIterable<unknown>> {
   assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url
 
   const loaderArray = Array.isArray(loaders) ? loaders : undefined;
@@ -75,7 +104,7 @@ async function parseWithLoaderInBatches(
   data: BatchableDataType,
   options: LoaderOptions,
   context: LoaderContext
-): Promise<AsyncIterable<any>> {
+): Promise<AsyncIterable<unknown>> {
   const outputIterator = await parseToOutputIterator(loader, data, options, context);
 
   // Generate metadata batch if requested
@@ -112,7 +141,7 @@ async function parseToOutputIterator(
   data: BatchableDataType,
   options: LoaderOptions,
   context: LoaderContext
-): Promise<AsyncIterable<any>> {
+): Promise<AsyncIterable<unknown>> {
   // Get an iterator from the input
   const inputIterator = await getAsyncIterableFromData(data, options);
 

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

@@ -1,10 +1,6 @@
-import type {
-  SyncDataType,
-  Loader,
-  LoaderWithParser,
-  LoaderContext,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
+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';
@@ -13,19 +9,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 {
+): unknown {
   assert(!context || typeof context === 'object'); // parseSync no longer accepts final url
 
   // Signature: parseSync(data, options)