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

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

@@ -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,13 +206,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.22" : "latest";
 var NullLoader = {
   name: "Null loader",
   id: "null",
@@ -215,7 +214,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 +223,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

@@ -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,13 +189,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.22" : "latest";
   var NullLoader = {
     name: "Null loader",
     id: "null",
@@ -198,7 +197,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 +206,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.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.20",
-    "@loaders.gl/worker-utils": "4.0.0-alpha.20",
+    "@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": "ac122e83102657c38207d59c631a5ce4e7aa46bd"
+  "gitHead": "0da838c506d1275383f2fd3d244d9c72b25397d2"
 }

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 type {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/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/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,12 +1,10 @@
+// loaders.gl, MIT license
+
 import type {Batch} from '@loaders.gl/schema';
-import type {
-  BatchableDataType,
-  Loader,
-  LoaderWithParser,
-  LoaderContext,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
-import {assert, concatenateArrayBuffersAsync} 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 {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';
@@ -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,9 +58,7 @@ export async function parseInBatches(
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): Promise<AsyncIterable<any>> {
-  assert(!context || typeof context === 'object'); // parseInBatches no longer accepts final url
-
+): Promise<AsyncIterable<unknown>> {
   const loaderArray = Array.isArray(loaders) ? loaders : undefined;
 
   // Signature: parseInBatches(data, options, url) - Uses registered loaders
@@ -59,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
   );
@@ -75,7 +102,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
@@ -94,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;
   }
@@ -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);