@loaders.gl/loader-utils 4.4.0-alpha.1 → 4.4.0-alpha.9

package/src/index.ts

@@ -9,6 +9,7 @@ export type {
   DataType,
   SyncDataType,
   BatchableDataType,
+  TransformBatches,
   // numeric array types
   TypedArray,
   BigTypedArray,
@@ -30,6 +31,7 @@ export type {
   Loader,
   LoaderWithParser,
   LoaderContext,
+  StrictLoaderOptions,
   LoaderOptions,
   LoaderOptionsType,
   LoaderReturnType,
@@ -66,6 +68,27 @@ export {
 
 export {log} from './lib/log-utils/log';
 
+export type {ReadableStreamType} from './lib/javascript-utils/is-type';
+export {
+  isObject,
+  isPureObject,
+  isArrayBuffer,
+  isArrayBufferLike,
+  isPromise,
+  isIterable,
+  isAsyncIterable,
+  isIterator,
+  isResponse,
+  isFile,
+  isBlob,
+  isWritableDOMStream,
+  isReadableDOMStream,
+  isWritableNodeStream,
+  isReadableNodeStream,
+  isReadableStream,
+  isWritableStream
+} from './lib/javascript-utils/is-type';
+
 // Options and modules
 export type {RequiredOptions} from './lib/option-utils/merge-options';
 export {mergeOptions, getRequiredOptions} from './lib/option-utils/merge-options';
@@ -107,7 +130,11 @@ export {
   makeLineIterator,
   makeNumberedLineIterator
 } from './lib/iterators/text-iterators';
-export {forEach, concatenateArrayBuffersAsync} from './lib/iterators/async-iteration';
+export {
+  forEach,
+  concatenateArrayBuffersAsync,
+  toArrayBufferIterator
+} from './lib/iterators/async-iteration';
 
 // REQUEST UTILS
 export {default as RequestScheduler} from './lib/request-utils/request-scheduler';
@@ -124,7 +151,14 @@ export {JSONLoader} from './json-loader';
 // Node.js emulation (can be used in browser)
 
 // Avoid direct use of `Buffer` which pulls in 50KB polyfill
-export {isBuffer, toBuffer, toArrayBuffer} from './lib/binary-utils/memory-conversion-utils';
+export {
+  isBuffer,
+  toBuffer,
+  toArrayBuffer,
+  toArrayBufferView,
+  copyToArrayBuffer,
+  ensureArrayBuffer
+} from './lib/binary-utils/memory-conversion-utils';
 
 // Note.js wrappers (can be safely imported, but not used in browser)
 
@@ -149,13 +183,6 @@ export {NodeFileFacade as NodeFile} from './lib/files/node-file-facade';
 export type {FileSystem, RandomAccessFileSystem} from './lib/filesystems/filesystem';
 export {NodeFileSystemFacade as NodeFilesystem} from './lib/filesystems/node-filesystem-facade';
 
-// TODO - replace with ReadableFile
-export type {FileProviderInterface} from './lib/file-provider/file-provider-interface';
-export {isFileProvider} from './lib/file-provider/file-provider-interface';
-export {FileProvider} from './lib/file-provider/file-provider';
-export {FileHandleFile} from './lib/file-provider/file-handle-file';
-export {DataViewFile} from './lib/file-provider/data-view-file';
-
 // EXPERIMENTAL: DATA SOURCES
 export type {Source, SourceArrayOptionsType, SourceArrayDataSourceType} from './source-types';
 

package/src/lib/binary-utils/array-buffer-utils.ts

@@ -7,8 +7,8 @@ import {TypedArray} from '../../types';
  * @param byteLength
  */
 export function compareArrayBuffers(
-  arrayBuffer1: ArrayBuffer,
-  arrayBuffer2: ArrayBuffer,
+  arrayBuffer1: ArrayBufferLike,
+  arrayBuffer2: ArrayBufferLike,
   byteLength?: number
 ): boolean {
   byteLength = byteLength || arrayBuffer1.byteLength;
@@ -97,7 +97,7 @@ export function concatenateTypedArrays<T>(...typedArrays: T[]): T {
  * @param byteLength
  */
 export function sliceArrayBuffer(
-  arrayBuffer: ArrayBuffer,
+  arrayBuffer: ArrayBufferLike,
   byteOffset: number,
   byteLength?: number
 ): ArrayBuffer {

package/src/lib/binary-utils/get-first-characters.ts

@@ -30,7 +30,7 @@ export function getFirstCharacters(data: string | ArrayBuffer, length: number =
  * @returns
  */
 export function getMagicString(
-  arrayBuffer: ArrayBuffer,
+  arrayBuffer: ArrayBufferLike,
   byteOffset: number,
   length: number
 ): string {

package/src/lib/binary-utils/memory-conversion-utils.ts

@@ -2,12 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import {isSharedArrayBuffer} from '../javascript-utils/is-type';
 import * as node from '../node/buffer';
 
 /**
  * Check for Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
  */
-export function isBuffer(value: any): boolean {
+export function isBuffer(value: any): value is Buffer {
   return value && typeof value === 'object' && value.isBuffer;
 }
 
@@ -15,14 +16,16 @@ export function isBuffer(value: any): boolean {
  * Converts to Node.js `Buffer` (without triggering bundler to include Buffer polyfill on browser)
  * @todo better data type
  */
-export function toBuffer(data: any): Buffer {
-  return node.toBuffer ? node.toBuffer(data) : data;
+export function toBuffer(data: unknown): Buffer {
+  return node.toBuffer ? node.toBuffer(data as any) : (data as Buffer);
 }
 
 /**
- * Convert an object to an array buffer
+ * Convert an object to an array buffer. Handles SharedArrayBuffers.
  */
-export function toArrayBuffer(data: unknown): ArrayBuffer {
+export function toArrayBuffer(
+  data: Buffer | ArrayBufferLike | ArrayBufferView | string | Blob
+): ArrayBuffer {
   // Note: Should be called first, Buffers can trigger other detections below
   if (isBuffer(data)) {
     return node.toArrayBuffer(data);
@@ -32,12 +35,18 @@ export function toArrayBuffer(data: unknown): ArrayBuffer {
     return data;
   }
 
-  // Careful - Node Buffers look like Uint8Arrays (keep after isBuffer)
+  if (isSharedArrayBuffer(data)) {
+    return copyToArrayBuffer(data);
+  }
+
+  // Node Buffers look like Uint8Arrays (Check isBuffer first)
   if (ArrayBuffer.isView(data)) {
+    // TODO - ArrayBufferLike type mess
+    const buffer = data.buffer as ArrayBuffer;
     if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-      return data.buffer;
+      return buffer;
     }
-    return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    return buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
   }
 
   if (typeof data === 'string') {
@@ -53,3 +62,44 @@ export function toArrayBuffer(data: unknown): ArrayBuffer {
 
   throw new Error('toArrayBuffer');
 }
+
+/** Ensure that SharedArrayBuffers are copied into ArrayBuffers */
+export function ensureArrayBuffer(bufferSource: ArrayBufferLike | ArrayBufferView): ArrayBuffer {
+  if (bufferSource instanceof ArrayBuffer) {
+    return bufferSource;
+  }
+
+  if (isSharedArrayBuffer(bufferSource)) {
+    return copyToArrayBuffer(bufferSource);
+  }
+
+  const {buffer, byteOffset, byteLength} = bufferSource;
+  if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+    return buffer;
+  }
+  return copyToArrayBuffer(buffer, byteOffset, byteLength);
+}
+
+/** Copies an ArrayBuffer or a section of an ArrayBuffer to a new ArrayBuffer, handles SharedArrayBuffers */
+export function copyToArrayBuffer(
+  buffer: ArrayBufferLike,
+  byteOffset = 0,
+  byteLength = buffer.byteLength - byteOffset
+): ArrayBuffer {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+
+/** Convert an object to an ArrayBufferView, handles SharedArrayBuffers */
+export function toArrayBufferView(
+  data: ArrayBufferLike | ArrayBufferView
+): ArrayBuffer | ArrayBufferView {
+  if (ArrayBuffer.isView(data)) {
+    return data;
+  }
+
+  // Create a view to support ArrayBufferLike sources such as SharedArrayBuffer
+  return new Uint8Array(data);
+}

package/src/lib/file-provider/data-view-file.ts

@@ -1,4 +1,5 @@
 import {FileProviderInterface} from './file-provider-interface';
+import {copyToArrayBuffer} from '../binary-utils/memory-conversion-utils';
 
 /**
  * Checks if bigint can be converted to number and convert it if possible
@@ -64,7 +65,11 @@ export class DataViewFile implements FileProviderInterface {
    * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
    */
   async slice(startOffset: bigint, endOffset: bigint): Promise<ArrayBuffer> {
-    return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    return copyToArrayBuffer(
+      this.file.buffer,
+      toNumber(startOffset + BigInt(this.file.byteOffset)),
+      toNumber(endOffset - startOffset)
+    );
   }
 
   /** the length (in bytes) of the data. */

package/src/lib/iterators/async-iteration.ts

@@ -3,23 +3,22 @@ import {concatenateArrayBuffers} from '../binary-utils/array-buffer-utils';
 // GENERAL UTILITIES
 
 /**
- * Iterate over async iterator, without resetting iterator if end is not reached
- * - forEach intentionally does not reset iterator if exiting loop prematurely
- *   so that iteration can continue in a second loop
- * - It is recommended to use a standard for-await as last loop to ensure
- *   iterator gets properly reset
- *
- * TODO - optimize using sync iteration if argument is an Iterable?
- *
- * @param iterator
- * @param visitor
+ * Iterates over an {@link AsyncIterable} or {@link Iterable}, invoking `visitor` for each yielded
+ * value without rewinding the iterator when exiting early. This enables the caller to continue
+ * iterating in another loop after `visitor` signals cancellation.
  */
-export async function forEach(iterator, visitor) {
+export async function forEach<TValue>(
+  iterable: AsyncIterable<TValue> | Iterable<TValue> | AsyncIterator<TValue>,
+  visitor: (value: TValue) => any
+) {
+  const iterator = toAsyncIterator(iterable);
   // eslint-disable-next-line
   while (true) {
     const {done, value} = await iterator.next();
     if (done) {
-      iterator.return();
+      if (iterator.return) {
+        iterator.return();
+      }
       return;
     }
     const cancel = visitor(value);
@@ -29,19 +28,19 @@ export async function forEach(iterator, visitor) {
   }
 }
 
-// Breaking big data into iterable chunks, concatenating iterable chunks into big data objects
-
 /**
- * Concatenates all data chunks yielded by an (async) iterator
- * This function can e.g. be used to enable atomic parsers to work on (async) iterator inputs
+ * Concatenates all binary chunks yielded by an async or sync iterator.
+ * Supports `ArrayBuffer`, typed array views, and `ArrayBufferLike` sources (e.g. `SharedArrayBuffer`).
+ * This allows atomic parsers to operate on iterator inputs by materializing them into a single buffer.
  */
-
 export async function concatenateArrayBuffersAsync(
-  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>
+  asyncIterator:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>
 ): Promise<ArrayBuffer> {
   const arrayBuffers: ArrayBuffer[] = [];
   for await (const chunk of asyncIterator) {
-    arrayBuffers.push(chunk);
+    arrayBuffers.push(copyToArrayBuffer(chunk));
   }
   return concatenateArrayBuffers(...arrayBuffers);
 }
@@ -55,3 +54,79 @@ export async function concatenateStringsAsync(
   }
   return strings.join('');
 }
+
+/**
+ * Normalizes binary chunk iterators to yield `ArrayBuffer` instances.
+ * Accepts `ArrayBuffer`, `ArrayBufferView`, and `ArrayBufferLike` sources
+ * (e.g. `SharedArrayBuffer`) and returns a copied `ArrayBuffer` for each chunk.
+ */
+export async function* toArrayBufferIterator(
+  asyncIterator:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>
+): AsyncIterable<ArrayBuffer> {
+  for await (const chunk of asyncIterator) {
+    yield copyToArrayBuffer(chunk);
+  }
+}
+
+function copyToArrayBuffer(chunk: ArrayBufferLike | ArrayBufferView | ArrayBuffer): ArrayBuffer {
+  if (chunk instanceof ArrayBuffer) {
+    return chunk;
+  }
+
+  if (ArrayBuffer.isView(chunk)) {
+    const {buffer, byteOffset, byteLength} = chunk;
+    return copyFromBuffer(buffer, byteOffset, byteLength);
+  }
+
+  return copyFromBuffer(chunk as ArrayBufferLike);
+}
+
+function copyFromBuffer(
+  buffer: ArrayBufferLike,
+  byteOffset = 0,
+  byteLength = buffer.byteLength - byteOffset
+): ArrayBuffer {
+  const view = new Uint8Array(buffer, byteOffset, byteLength);
+  const copy = new Uint8Array(view.length);
+  copy.set(view);
+  return copy.buffer;
+}
+
+function toAsyncIterator<TValue>(
+  iterable: AsyncIterable<TValue> | Iterable<TValue> | AsyncIterator<TValue>
+): AsyncIterator<TValue> {
+  if (typeof iterable[Symbol.asyncIterator] === 'function') {
+    return iterable[Symbol.asyncIterator]();
+  }
+
+  if (typeof iterable[Symbol.iterator] === 'function') {
+    const iterator = iterable[Symbol.iterator]();
+    return iteratorToAsyncIterator(iterator);
+  }
+
+  return iterable as AsyncIterator<TValue>;
+}
+
+function iteratorToAsyncIterator<T>(iterator: Iterator<T>): AsyncIterator<T> {
+  return {
+    next(value?: any) {
+      return Promise.resolve(iterator.next(value));
+    },
+
+    return(value?: any) {
+      if (typeof iterator.return === 'function') {
+        return Promise.resolve(iterator.return(value));
+      }
+      return Promise.resolve({done: true, value});
+    },
+
+    throw(error?: any) {
+      if (typeof iterator.throw === 'function') {
+        return Promise.resolve(iterator.throw(error));
+      }
+      return Promise.reject(error);
+    }
+  };
+}

package/src/lib/iterators/text-iterators.ts

@@ -23,7 +23,7 @@ export async function* makeTextEncoderIterator(
 ): AsyncIterable<ArrayBuffer> {
   const textEncoder = new TextEncoder();
   for await (const text of textIterator) {
-    yield typeof text === 'string' ? textEncoder.encode(text) : text;
+    yield typeof text === 'string' ? textEncoder.encode(text).buffer : text;
   }
 }
 

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

@@ -0,0 +1,130 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable @typescript-eslint/unbound-method */
+
+import type {Readable} from 'stream';
+
+/** Minimal shape for Node.js Buffer-like values */
+type NodeBufferLike = {buffer: ArrayBufferLike; isBuffer: true};
+
+/** Minimal shape for Node.js writable streams */
+type NodeWritableStream = {
+  end: (...args: unknown[]) => unknown;
+  write: (...args: unknown[]) => unknown;
+  writable: boolean;
+};
+
+/** Minimal shape for WritableStream-like DOM implementations */
+type WritableDOMStreamLike = WritableStream | {abort: () => unknown; getWriter: () => unknown};
+
+/** A DOM or Node readable stream */
+export type ReadableStreamType = ReadableStream | Readable;
+
+/** Checks whether a value is a boolean */
+const isBoolean = (value: unknown): value is boolean => typeof value === 'boolean';
+
+/** Checks whether a value is a function */
+const isFunction = (value: unknown): value is (...args: unknown[]) => unknown =>
+  typeof value === 'function';
+
+/** Checks whether a value is a non-null object */
+export const isObject = (value: unknown): value is object =>
+  value !== null && typeof value === 'object';
+
+/** Checks whether a value is a plain object (created by the Object constructor) */
+export const isPureObject = (value: unknown): value is Record<string, unknown> =>
+  isObject(value) && value.constructor === {}.constructor;
+
+/** Checks whether a value is an ArrayBuffer */
+export const isArrayBuffer = (value: unknown): value is ArrayBuffer =>
+  typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer;
+
+/** Checks whether a value is an ArrayBuffer */
+export const isSharedArrayBuffer = (value: unknown): value is SharedArrayBuffer =>
+  typeof SharedArrayBuffer !== 'undefined' && value instanceof SharedArrayBuffer;
+
+/** Checks whether a value is ArrayBuffer-like */
+export const isArrayBufferLike = (value: unknown): value is ArrayBufferLike =>
+  isObject(value) &&
+  typeof (value as ArrayBufferLike).byteLength === 'number' &&
+  typeof (value as ArrayBufferLike).slice === 'function';
+
+/** Checks whether a value behaves like a promise */
+export const isPromise = (value: unknown): value is Promise<unknown> =>
+  isObject(value) && 'then' in value && isFunction((value as {then: unknown}).then);
+
+/** Checks whether a value implements the iterable protocol */
+export const isIterable = (value: unknown): value is Iterable<unknown> =>
+  Boolean(value) && isFunction((value as Iterable<unknown>)[Symbol.iterator]);
+
+/** Checks whether a value implements the async iterable protocol */
+export const isAsyncIterable = (value: unknown): value is AsyncIterable<unknown> =>
+  Boolean(value) && isFunction((value as AsyncIterable<unknown>)[Symbol.asyncIterator]);
+
+/** Checks whether a value is an iterator (has a next function) */
+export const isIterator = (value: unknown): value is Iterator<unknown> =>
+  Boolean(value) && isFunction((value as Iterator<unknown>).next);
+
+/** Checks whether a value is a fetch Response or a duck-typed equivalent */
+export const isResponse = (value: unknown): value is Response =>
+  (typeof Response !== 'undefined' && value instanceof Response) ||
+  (isObject(value) &&
+    isFunction((value as {arrayBuffer?: unknown}).arrayBuffer) &&
+    isFunction((value as {text?: unknown}).text) &&
+    isFunction((value as {json?: unknown}).json));
+
+/** Checks whether a value is a File */
+export const isFile = (value: unknown): value is File =>
+  typeof File !== 'undefined' && value instanceof File;
+
+/** Checks whether a value is a Blob */
+export const isBlob = (value: unknown): value is Blob =>
+  typeof Blob !== 'undefined' && value instanceof Blob;
+
+/** Checks for Node.js Buffers without triggering bundlers to include the Buffer polyfill */
+export const isBuffer = (value: unknown): value is NodeBufferLike =>
+  Boolean(
+    value &&
+      typeof value === 'object' &&
+      (value as Partial<NodeBufferLike>).isBuffer &&
+      'buffer' in (value as NodeBufferLike)
+  );
+
+/** Checks whether a value looks like a DOM WritableStream */
+export const isWritableDOMStream = (value: unknown): value is WritableDOMStreamLike =>
+  isObject(value) &&
+  isFunction((value as WritableDOMStreamLike).abort) &&
+  isFunction((value as WritableDOMStreamLike).getWriter);
+
+/** Checks whether a value looks like a DOM ReadableStream */
+export const isReadableDOMStream = (value: unknown): value is ReadableStream =>
+  (typeof ReadableStream !== 'undefined' && value instanceof ReadableStream) ||
+  (isObject(value) &&
+    isFunction((value as ReadableStream).tee) &&
+    isFunction((value as ReadableStream).cancel) &&
+    isFunction((value as ReadableStream).getReader));
+// Not implemented in Firefox: && isFunction(x.pipeTo)
+
+/** Checks whether a value looks like a Node.js writable stream */
+export const isWritableNodeStream = (value: unknown): value is NodeWritableStream =>
+  isObject(value) &&
+  isFunction((value as NodeWritableStream).end) &&
+  isFunction((value as NodeWritableStream).write) &&
+  isBoolean((value as NodeWritableStream).writable);
+
+/** Checks whether a value looks like a Node.js readable stream */
+export const isReadableNodeStream = (value: unknown): value is Readable =>
+  isObject(value) &&
+  isFunction((value as Readable).read) &&
+  isFunction((value as Readable).pipe) &&
+  isBoolean((value as Readable).readable);
+
+/** Checks whether a value is any readable stream (DOM or Node.js) */
+export const isReadableStream = (value: unknown): value is ReadableStreamType =>
+  isReadableDOMStream(value) || isReadableNodeStream(value);
+
+/** Checks whether a value is any writable stream (DOM or Node.js) */
+export const isWritableStream = (value: unknown): value is WritableStream | NodeWritableStream =>
+  isWritableDOMStream(value) || isWritableNodeStream(value);

package/src/lib/node/buffer.ts

@@ -28,7 +28,7 @@ export function toBuffer(binaryData: ArrayBuffer | Buffer): Buffer {
   }
 
   if (ArrayBuffer.isView(binaryData)) {
-    binaryData = binaryData.buffer;
+    binaryData = binaryData.buffer as ArrayBuffer;
   }
 
   // TODO - move to loaders.gl/polyfills

package/src/lib/path-utils/path.ts

@@ -8,7 +8,7 @@ import {getCWD} from './get-cwd';
  */
 export function filename(url: string): string {
   const slashIndex = url ? url.lastIndexOf('/') : -1;
-  return slashIndex >= 0 ? url.substr(slashIndex + 1) : '';
+  return slashIndex >= 0 ? url.substr(slashIndex + 1) : url;
 }
 
 /**

package/src/lib/request-utils/request-scheduler.ts

@@ -68,6 +68,21 @@ export default class RequestScheduler {
     this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
   }
 
+  /**
+   * Update scheduler props. Preserves active and queued requests.
+   */
+  setProps(props: Omit<RequestSchedulerProps, 'id'>): void {
+    if (props.throttleRequests !== undefined) {
+      this.props.throttleRequests = props.throttleRequests;
+    }
+    if (props.maxRequests !== undefined) {
+      this.props.maxRequests = props.maxRequests;
+    }
+    if (props.debounceTime !== undefined) {
+      this.props.debounceTime = props.debounceTime;
+    }
+  }
+
   /**
    * Called by an application that wants to issue a request, without having it deeply queued by the browser
    *

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

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {LoaderOptions, Loader} from '../../loader-types';
+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';
@@ -15,7 +15,7 @@ export type DataSourceOptions = Partial<{
     /** 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?: LoaderOptions;
+    loadOptions?: StrictLoaderOptions;
     /** Make additional loaders available to the data source */
     loaders?: Loader[];
   };
@@ -39,7 +39,7 @@ export abstract class DataSource<DataT, OptionsT extends DataSourceOptions> {
   readonly url: string;
 
   /** The actual load options, if calling a loaders.gl loader */
-  loadOptions: LoaderOptions;
+  loadOptions: StrictLoaderOptions;
   /** A resolved fetch function extracted from loadOptions prop */
   fetch: (url: string, options?: RequestInit) => Promise<Response>;
   _needsRefresh: boolean = true;
@@ -93,8 +93,8 @@ export abstract class DataSource<DataT, OptionsT extends DataSourceOptions> {
  * @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/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/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