@loaders.gl/loader-utils 4.3.4 → 4.4.0-alpha.10

package/src/lib/sources/data-source.ts

@@ -2,34 +2,68 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {LoaderOptions} from '@loaders.gl/loader-utils';
+import type {Loader, StrictLoaderOptions} from '../../loader-types';
+import type {RequiredOptions} from '../option-utils/merge-options';
+import {mergeOptions} from '../option-utils/merge-options';
+import {resolvePath} from '../path-utils/file-aliases';
 
 /** Common properties for all data sources */
-export type DataSourceProps = {
-  url?: string | Blob;
-  /** LoaderOptions provide an option to override `fetch`. Will also be passed to any sub loaders */
-  loadOptions?: LoaderOptions;
-};
+export type DataSourceOptions = Partial<{
+  core: {
+    /** Allows application to specify which source should be selected. Matches `Source.type`. Defaults to 'auto' */
+    type?: string;
+    /** Any dataset attributions (in case underlying metadata does not include attributions) */
+    attributions?: string[];
+    /** LoaderOptions provide an option to override `fetch`. Will also be passed to any sub loaders */
+    loadOptions?: StrictLoaderOptions;
+    /** Make additional loaders available to the data source */
+    loaders?: Loader[];
+  };
+  [key: string]: Record<string, unknown>;
+}>;
 
 /** base class of all data sources */
-export abstract class DataSource<PropsT extends DataSourceProps = DataSourceProps> {
-  abstract data: unknown;
+export abstract class DataSource<DataT, OptionsT extends DataSourceOptions> {
+  static defaultOptions: Required<DataSourceOptions> = {
+    core: {
+      type: 'auto',
+      attributions: [],
+      loadOptions: {},
+      loaders: []
+    }
+  };
+
+  optionsType?: OptionsT & DataSourceOptions;
+  options: Required<OptionsT & DataSourceOptions>;
+  readonly data: DataT;
+  readonly url: string;
+
+  /** The actual load options, if calling a loaders.gl loader */
+  loadOptions: StrictLoaderOptions;
   /** A resolved fetch function extracted from loadOptions prop */
   fetch: (url: string, options?: RequestInit) => Promise<Response>;
-  /** The actual load options, if calling a loaders.gl loader */
-  loadOptions: LoaderOptions;
   _needsRefresh: boolean = true;
 
-  props: PropsT;
-
-  constructor(props: PropsT) {
-    this.props = {...props};
-    this.loadOptions = {...props.loadOptions};
+  constructor(
+    data: DataT,
+    options: OptionsT,
+    defaultOptions?: Omit<RequiredOptions<OptionsT>, 'core'>
+  ) {
+    if (defaultOptions) {
+      // @ts-expect-error Typescript gets confused
+      this.options = mergeOptions({...defaultOptions, core: DataSource.defaultOptions}, options);
+    } else {
+      // @ts-expect-error
+      this.options = {...options};
+    }
+    this.data = data;
+    this.url = typeof data === 'string' ? resolvePath(data) : '';
+    this.loadOptions = {...this.options.core?.loadOptions};
     this.fetch = getFetchFunction(this.loadOptions);
   }
 
-  setProps(props: PropsT) {
-    this.props = Object.assign(this.props, props);
+  setProps(options: OptionsT) {
+    this.options = Object.assign(this.options, options);
     // TODO - add a shallow compare to avoid setting refresh if no change?
     this.setNeedsRefresh();
   }
@@ -59,8 +93,8 @@ export abstract class DataSource<PropsT extends DataSourceProps = DataSourceProp
  * @param options
  * @param context
  */
-export function getFetchFunction(options?: LoaderOptions) {
-  const fetchFunction = options?.fetch;
+export function getFetchFunction(options?: StrictLoaderOptions) {
+  const fetchFunction = options?.core?.fetch;
 
   // options.fetch can be a function
   if (fetchFunction && typeof fetchFunction === 'function') {

package/src/lib/sources/image-source.ts

@@ -2,19 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {DataSourceProps} from './data-source';
-import {DataSource} from './data-source';
 // TODO - can we import from schema?
 import {ImageType} from './utils/image-type';
-
-export type ImageSourceProps = DataSourceProps;
+// TODO - remove (this breaks WMS layer)
 
 /**
  * ImageSource - data sources that allow images to be queried by (geospatial) extents
  */
-export abstract class ImageSource<
-  PropsT extends ImageSourceProps = ImageSourceProps
-> extends DataSource<PropsT> {
+export abstract class ImageSource {
   static type: string = 'template';
   static testURL = (url: string): boolean => false;
 

package/src/lib/sources/image-tile-source.ts

@@ -16,9 +16,7 @@ export type ImageTileSourceProps = TileSourceProps;
  * MapTileSource - data sources that allow data to be queried by (geospatial) tile
  * @note If geospatial, bounding box is expected to be in web mercator coordinates
  */
-export interface ImageTileSource<
-  PropsT extends TileSourceProps = TileSourceProps,
-  MetadataT extends TileSourceMetadata = TileSourceMetadata
-> extends TileSource<PropsT, MetadataT> {
+export interface ImageTileSource extends TileSource {
+  getMetadata(): Promise<TileSourceMetadata>;
   getImageTile(parameters: GetTileParameters): Promise<ImageType | null>;
 }

package/src/lib/sources/tile-source-adapter.ts

@@ -9,12 +9,12 @@ import {ImageSource, ImageSourceMetadata} from './image-source';
  * @note
  * - If geospatial, bounding box is expected to be in web mercator coordinates
  */
-// @ts-expect-error TODO - does not implement all DataSource members
-export class TileSourceAdapter implements TileSource<ImageSourceMetadata> {
-  readonly viewportSource: ImageSource;
-  constructor(source: ImageSource) {
+export class TileSourceAdapter<ImageSourceT extends ImageSource> implements TileSource {
+  readonly viewportSource: ImageSourceT;
+  constructor(source: ImageSourceT) {
     this.viewportSource = source;
   }
+
   async getMetadata(): Promise<ImageSourceMetadata> {
     return await this.viewportSource.getMetadata();
   }

package/src/lib/sources/tile-source.ts

@@ -2,25 +2,19 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {DataSourceProps} from './data-source';
-import {DataSource} from './data-source';
-
 /**
  * Props for a TileSource
  */
-export type TileSourceProps = DataSourceProps;
+export type TileSourceProps = {};
 
 /**
  * MapTileSource - data sources that allow data to be queried by (geospatial) extents
  * @note
  * - If geospatial, bounding box is expected to be in web mercator coordinates
  */
-export interface TileSource<
-  PropsT extends TileSourceProps = TileSourceProps,
-  MetadataT extends TileSourceMetadata = TileSourceMetadata
-> extends DataSource<PropsT> {
+export interface TileSource {
   // extends DataSource {
-  getMetadata(): Promise<MetadataT>;
+  getMetadata(): Promise<TileSourceMetadata>;
   /** Flat parameters */
   getTile(parameters: GetTileParameters): Promise<unknown | null>;
   /** deck.gl compatibility: TileLayer and MTVLayer */

package/src/lib/sources/utils/utils.ts

@@ -12,7 +12,7 @@ import type {LoaderOptions} from '@loaders.gl/loader-utils';
  * @param context
  */
 export function getFetchFunction(options?: LoaderOptions) {
-  const fetchFunction = options?.fetch;
+  const fetchFunction = options?.core?.fetch;
 
   // options.fetch can be a function
   if (fetchFunction && typeof fetchFunction === 'function') {

package/src/lib/sources/vector-source.ts

@@ -3,19 +3,15 @@
 // Copyright (c) vis.gl contributors
 
 import type {Schema, GeoJSONTable, BinaryFeatureCollection} from '@loaders.gl/schema';
-import type {DataSourceProps} from './data-source';
-import {DataSource} from './data-source';
 
-export type VectorSourceProps = DataSourceProps;
+export type VectorSourceProps = {};
 
 /**
  * VectorSource - data sources that allow features to be queried by (geospatial) extents
  * @note
  * - If geospatial, bounding box is expected to be in web mercator coordinates
  */
-export abstract class VectorSource<
-  PropsT extends VectorSourceProps = VectorSourceProps
-> extends DataSource<PropsT> {
+export abstract class VectorSource {
   static type: string = 'template';
   static testURL = (url: string): boolean => false;
 

package/src/lib/sources/vector-tile-source.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {Schema, Feature, BinaryFeatureCollection} from '@loaders.gl/schema';
-import {TileSource, TileSourceProps, TileSourceMetadata, GetTileParameters} from './tile-source';
+import {TileSource, TileSourceProps, GetTileParameters} from './tile-source';
 import type {GetTileDataParameters} from './tile-source';
 
 export type VectorTile = unknown;
@@ -14,10 +14,7 @@ export type VectorTileSourceProps = TileSourceProps;
  * VectorTileSource - data sources that allow data to be queried by (geospatial) tile
  * @note If geospatial, bounding box is expected to be in web mercator coordinates
  */
-export interface VectorTileSource<
-  PropsT extends VectorTileSourceProps = VectorTileSourceProps,
-  MetadataT extends TileSourceMetadata = TileSourceMetadata
-> extends TileSource<PropsT, MetadataT> {
+export interface VectorTileSource extends TileSource {
   getSchema(): Promise<Schema>;
   getVectorTile(parameters: GetTileParameters): Promise<VectorTile | null>;
   getTileData(

package/src/lib/worker-loader-utils/create-loader-worker.ts

@@ -117,7 +117,10 @@ async function parseData({
   options = {
     ...options,
     modules: (loader && loader.options && loader.options.modules) || {},
-    worker: false
+    core: {
+      ...options.core,
+      worker: false
+    }
   };
 
   return await parser(data, {...options}, context, loader);

package/src/lib/worker-loader-utils/encode-with-worker.ts

@@ -12,10 +12,13 @@ export function canEncodeWithWorker(writer: Writer, options?: WriterOptions) {
     return false;
   }
 
+  const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
+  const useWorkers = options?.worker ?? options?.core?.worker;
+
   // Node workers are still experimental
-  if (!isBrowser && !options?._nodeWorkers) {
+  if (!isBrowser && !nodeWorkers) {
     return false;
   }
 
-  return writer.worker && options?.worker;
+  return Boolean(writer.worker && useWorkers);
 }

package/src/lib/worker-loader-utils/parse-with-worker.ts

@@ -19,11 +19,13 @@ export function canParseWithWorker(loader: Loader, options?: LoaderOptions) {
   }
 
   // Node workers are still experimental
-  if (!isBrowser && !options?._nodeWorkers) {
+  const nodeWorkers = options?._nodeWorkers ?? options?.core?._nodeWorkers;
+  if (!isBrowser && !nodeWorkers) {
     return false;
   }
 
-  return loader.worker && options?.worker;
+  const useWorkers = options?.worker ?? options?.core?.worker;
+  return Boolean(loader.worker && useWorkers);
 }
 
 /**
@@ -40,7 +42,7 @@ export async function parseWithWorker(
   const name = loader.id; // TODO
   const url = getWorkerURL(loader, options);
 
-  const workerFarm = WorkerFarm.getWorkerFarm(options);
+  const workerFarm = WorkerFarm.getWorkerFarm(options?.core);
   const workerPool = workerFarm.getWorkerPool({name, url});
 
   // options.log object contains functions which cannot be transferred

package/src/loader-types.ts

@@ -2,105 +2,132 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {
-  FetchLike,
-  TransformBatches /* , DataType, SyncDataType, BatchableDataType */
-} from './types';
+import type {Format} from './format-types';
+import {FetchLike, TransformBatches} from './types';
 import {ReadableFile} from './lib/files/file';
 
 // LOADERS
 
+/**
+ * Core Loader Options
+ */
+export type StrictLoaderOptions = {
+  core?: {
+    /** Base URI for resolving relative paths */
+    baseUri?: string;
+    /** fetch options or a custom fetch function */
+    fetch?: typeof fetch | FetchLike | RequestInit | null;
+    /** Do not throw on errors */
+    nothrow?: boolean;
+
+    /** loader selection, search first for supplied mimeType */
+    mimeType?: string;
+    /** loader selection, provide fallback mimeType is server does not provide */
+    fallbackMimeType?: string;
+    /** loader selection, avoid searching registered loaders */
+    ignoreRegisteredLoaders?: boolean;
+
+    // general
+    /** Experimental: Supply a logger to the parser */
+    log?: any;
+
+    // batched parsing
+
+    /** Size of each batch. `auto` matches batches to size of incoming chunks */
+    batchSize?: number | 'auto';
+    /** Minimal amount of time between batches */
+    batchDebounceMs?: number;
+    /** Stop loading after a given number of rows (compare SQL limit clause) */
+    limit?: 0;
+    /** Experimental: Stop loading after reaching */
+    _limitMB?: 0;
+    /** Generate metadata batches */
+    metadata?: boolean;
+    /** Transforms to run on incoming batches */
+    transforms?: TransformBatches[];
+
+    // module loading
+
+    /** Force to load WASM libraries from local file system in NodeJS or from loaders.gl CDN in a web browser */
+    useLocalLibraries?: boolean;
+
+    // workers
+
+    /** CDN load workers from */
+    CDN?: string | null;
+    /** Set to `false` to disable workers */
+    worker?: boolean;
+    /** Number of concurrent workers (per loader) on desktop browser */
+    maxConcurrency?: number;
+    /** Number of concurrent workers (per loader) on mobile browsers */
+    maxMobileConcurrency?: number;
+    /** Set to `false` to prevent reuse workers */
+    reuseWorkers?: boolean;
+    /** Whether to use workers under Node.js (experimental) */
+    _nodeWorkers?: boolean;
+    /** set to 'test' to run local worker */
+    _workerType?: string;
+  };
+
+  /** Any additional JS libraries */
+  modules?: Record<string, unknown>;
+
+  // Accept other keys (loader options objects, e.g. `options.csv`, `options.json` ...)
+  [loaderId: string]: Record<string, unknown> | undefined;
+};
+
 /**
  * Core Loader Options
  */
 export type LoaderOptions = {
-  /** fetch options or a custom fetch function */
-  fetch?: typeof fetch | FetchLike | RequestInit | null;
-  /** Do not throw on errors */
-  nothrow?: boolean;
+  core?: StrictLoaderOptions['core'];
+  modules?: StrictLoaderOptions['modules'];
 
-  /** loader selection, search first for supplied mimeType */
+  // Deprecated top-level aliases for core options
+  /** @deprecated Use options.core.baseUri */
+  baseUri?: string;
+  /** @deprecated Use options.core.fetch */
+  fetch?: typeof fetch | FetchLike | RequestInit | null;
+  /** @deprecated Use options.core.mimeType */
   mimeType?: string;
-  /** loader selection, provide fallback mimeType is server does not provide */
+  /** @deprecated Use options.core.fallbackMimeType */
   fallbackMimeType?: string;
-  /** loader selection, avoid searching registered loaders */
+  /** @deprecated Use options.core.ignoreRegisteredLoaders */
   ignoreRegisteredLoaders?: boolean;
-
-  // general
-  /** Experimental: Supply a logger to the parser */
+  /** @deprecated Use options.core.nothrow */
+  nothrow?: boolean;
+  /** @deprecated Use options.core.log */
   log?: any;
-
-  // batched parsing
-
-  /** Size of each batch. `auto` matches batches to size of incoming chunks */
-  batchSize?: number | 'auto';
-  /** Minimal amount of time between batches */
-  batchDebounceMs?: number;
-  /** Stop loading after a given number of rows (compare SQL limit clause) */
-  limit?: 0;
-  /** Experimental: Stop loading after reaching */
-  _limitMB?: 0;
-  /** Generate metadata batches */
-  metadata?: boolean;
-  /** Transforms to run on incoming batches */
-  transforms?: TransformBatches[];
-
-  // module loading
-
-  /** Any additional JS libraries */
-  modules?: Record<string, any>;
-  /** Force to load WASM libraries from local file system in NodeJS or from loaders.gl CDN in a web browser */
+  /** @deprecated Use options.core.useLocalLibraries */
   useLocalLibraries?: boolean;
-
-  // workers
-
-  /** CDN load workers from */
+  /** @deprecated Use options.core.CDN */
   CDN?: string | null;
-  /** Set to `false` to disable workers */
+  /** @deprecated Use options.core.worker */
   worker?: boolean;
-  /** Number of concurrent workers (per loader) on desktop browser */
+  /** @deprecated Use options.core.maxConcurrency */
   maxConcurrency?: number;
-  /** Number of concurrent workers (per loader) on mobile browsers */
+  /** @deprecated Use options.core.maxMobileConcurrency */
   maxMobileConcurrency?: number;
-  /** Set to `false` to prevent reuse workers */
+  /** @deprecated Use options.core.reuseWorkers */
   reuseWorkers?: boolean;
-  /** Whether to use workers under Node.js (experimental) */
+  /** @deprecated Use options.core._nodeWorkers */
   _nodeWorkers?: boolean;
-  /** set to 'test' to run local worker */
+  /** @deprecated Use options.core._workerType */
   _workerType?: string;
-
-  /** @deprecated `options.batchType` removed, Use `options.<loader>.type` instead */
-  batchType?: 'row' | 'columnar' | 'arrow';
-  /** @deprecated `options.throw removed`, Use `options.nothrow` instead */
-  throws?: boolean;
-  /** @deprecated `options.dataType` no longer used */
-  dataType?: never;
-  /** @deprecated `options.uri` no longer used */
-  uri?: never;
-  /** @deprecated Use `options.fetch.method` */
-  method?: never;
-  /** @deprecated Use `options.fetch.headers` */
-  headers?: never;
-  /** @deprecated Use `options.fetch.body` */
-  body?: never;
-  /** @deprecated Use `options.fetch.mode` */
-  mode?: never;
-  /** @deprecated Use `options.fetch.credentials` */
-  credentials?: never;
-  /** @deprecated Use `options.fetch.cache` */
-  cache?: never;
-  /** @deprecated Use `options.fetch.redirect` */
-  redirect?: never;
-  /** @deprecated Use `options.fetch.referrer` */
-  referrer?: never;
-  /** @deprecated Use `options.fetch.referrerPolicy` */
-  referrerPolicy?: never;
-  /** @deprecated Use `options.fetch.integrity` */
-  integrity?: never;
-  /** @deprecated Use `options.fetch.keepalive` */
-  keepalive?: never;
-  /** @deprecated Use `options.fetch.signal` */
-  signal?: never;
+  /** @deprecated Use options.core._workerType */
+  _worker?: string;
+  /** @deprecated Use options.core.limit */
+  limit?: 0;
+  /** @deprecated Use options.core._limitMB */
+  _limitMB?: 0;
+  /** @deprecated Use options.core.batchSize */
+  batchSize?: number | 'auto';
+  /** @deprecated Use options.core.batchDebounceMs */
+  batchDebounceMs?: number;
+  /** @deprecated Use options.core.metadata */
+  metadata?: boolean;
+  /** @deprecated Use options.core.transforms */
+  transforms?: TransformBatches[];
 
   // Accept other keys (loader options objects, e.g. `options.csv`, `options.json` ...)
   [loaderId: string]: unknown;
@@ -113,7 +140,7 @@ type PreloadOptions = {
 /**
  * A worker loader definition that can be used with `@loaders.gl/core` functions
  */
-export type Loader<DataT = any, BatchT = any, LoaderOptionsT = LoaderOptions> = {
+export type Loader<DataT = any, BatchT = any, LoaderOptionsT = StrictLoaderOptions> = Format & {
   /** The result type of this loader  */
   dataType?: DataT;
   /** The batched result type of this loader  */
@@ -123,6 +150,11 @@ export type Loader<DataT = any, BatchT = any, LoaderOptionsT = LoaderOptions> =
   options: LoaderOptionsT;
   /** Deprecated Options */
   deprecatedOptions?: Record<string, string | Record<string, string>>;
+  /** Version should be injected by build tools */
+  version: string;
+  /** A boolean, or a URL */
+  worker?: string | boolean;
+  // end Worker
 
   /** Human readable name */
   name: string;
@@ -130,19 +162,12 @@ export type Loader<DataT = any, BatchT = any, LoaderOptionsT = LoaderOptions> =
   id: string;
   /** module is used to generate worker threads, need to be the module directory name */
   module: string;
-  /** Version should be injected by build tools */
-  version: string;
-  /** A boolean, or a URL */
-  worker?: string | boolean;
-  // end Worker
-
   /** Which category does this loader belong to */
   category?: string;
   /** File extensions that are potential matches with this loader. */
   extensions: string[];
   /** MIMETypes that indicate a match with this loader. @note Some MIMETypes are generic and supported by many loaders */
   mimeTypes: string[];
-
   /** Is the input of this loader binary */
   binary?: boolean;
   /** Is the input of this loader text */
@@ -161,11 +186,11 @@ export type Loader<DataT = any, BatchT = any, LoaderOptionsT = LoaderOptions> =
  * A "bundled" loader definition that can be used with `@loaders.gl/core` functions
  * If a worker loader is supported it will also be supported.
  */
-export type LoaderWithParser<DataT = any, BatchT = any, LoaderOptionsT = LoaderOptions> = Loader<
-  DataT,
-  BatchT,
-  LoaderOptionsT
-> & {
+export type LoaderWithParser<
+  DataT = any,
+  BatchT = any,
+  LoaderOptionsT = StrictLoaderOptions
+> = Loader<DataT, BatchT, LoaderOptionsT> & {
   /** Perform actions before load. @deprecated Not officially supported. */
   preload?: Preload;
   /** Parse asynchronously and atomically from an arraybuffer */
@@ -188,7 +213,9 @@ export type LoaderWithParser<DataT = any, BatchT = any, LoaderOptionsT = LoaderO
   ) => DataT;
   /** Parse batches of data from an iterator (e.g. fetch stream), return an iterator that yield parsed batches. */
   parseInBatches?: (
-    iterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
+    iterator:
+      | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+      | Iterable<ArrayBufferLike | ArrayBufferView>,
     options?: LoaderOptionsT,
     context?: LoaderContext
   ) => AsyncIterable<BatchT>;
@@ -295,12 +322,13 @@ type Preload = (url: string, options?: PreloadOptions) => any;
 
 /** Typescript helper to extract options type from a loader type */
 export type LoaderOptionsType<T = Loader> =
-  T extends Loader<any, any, infer Options> ? Options : never;
+  T extends Loader<unknown, unknown, infer Options> ? Options : never;
 /** Typescript helper to extract data type from a loader type */
 export type LoaderReturnType<T = Loader> =
-  T extends Loader<infer Return, any, any> ? Return : never;
+  T extends Loader<infer Return, unknown, unknown> ? Return : never;
 /** Typescript helper to extract batch type from a loader type */
-export type LoaderBatchType<T = Loader> = T extends Loader<any, infer Batch, any> ? Batch : never;
+export type LoaderBatchType<T = Loader> =
+  T extends Loader<unknown, infer Batch, unknown> ? Batch : never;
 
 /** Typescript helper to extract options type from an array of loader types */
 export type LoaderArrayOptionsType<LoadersT extends Loader[] = Loader[]> =
@@ -317,7 +345,7 @@ export type LoaderArrayBatchType<LoadersT extends Loader[] = Loader[]> =
  */
 export async function parseFromContext<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends StrictLoaderOptions = LoaderOptionsType<LoaderT>
 >(
   data: ArrayBuffer,
   loader: LoaderT,
@@ -357,7 +385,7 @@ export async function parseFromContext(
  */
 export function parseSyncFromContext<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends StrictLoaderOptions = LoaderOptionsType<LoaderT>
 >(
   data: ArrayBuffer,
   loader: LoaderT,
@@ -375,7 +403,7 @@ export function parseSyncFromContext<
  */
 export async function parseInBatchesFromContext<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends StrictLoaderOptions = LoaderOptionsType<LoaderT>
 >(
   data: Iterable<ArrayBuffer> | AsyncIterable<ArrayBuffer> | Response,
   loader: LoaderT,