@loaders.gl/core 4.0.0-alpha.8 → 4.0.0-beta.1

package/src/lib/api/load.ts

@@ -18,37 +18,45 @@ import {parse} from './parse';
  * @param context
  */
 
-export async function load<LoaderT extends Loader>(
+export async function load<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+>(
   url: string | DataType,
   loader: LoaderT,
-  options?: LoaderOptionsType<LoaderT>,
+  options?: OptionsT,
   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(
   url: string | DataType,
-  loaders: Loader[] | LoaderOptions,
-  options?: LoaderOptionsT,
+  loaders: Loader[],
+  options?: LoaderOptions,
   context?: LoaderContext
-): Promise<any>;
+): Promise<unknown>;
+
+export async function load(
+  url: string | DataType,
+  loaders?: LoaderOptions,
+  context?: LoaderContext
+): Promise<unknown>;
+
+export async function load(url: string | DataType, loaders: LoaderOptions): Promise<any>;
 
 // implementation signature
-export async function load<LoaderOptionsT extends LoaderOptions>(
+export async function load(
   url: string | DataType,
   loaders?: Loader[] | LoaderOptions,
-  options?: LoaderOptionsT,
+  options?: LoaderOptions,
   context?: LoaderContext
-): Promise<any> {
+): Promise<unknown> {
   let resolvedLoaders: Loader | Loader[];
-  let resolvedOptions: LoaderOptionsT | undefined;
+  let resolvedOptions: LoaderOptions | undefined;
 
   // Signature: load(url, options)
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     resolvedLoaders = [];
-    resolvedOptions = loaders as LoaderOptionsT;
+    resolvedOptions = loaders as LoaderOptions;
     context = undefined; // context not supported in short signature
   } else {
     resolvedLoaders = loaders as Loader | Loader[];

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<unknown>>;
+
+/**
+ * Parses `data` in batches by selecting a pre-registered loader
+ */
+export async function parseInBatches(
+  data: BatchableDataType,
+  options?: LoaderOptions
+): Promise<AsyncIterable<unknown>>;
+
 /**
  * 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> | Iterable<unknown>> {
   const loaderArray = Array.isArray(loaders) ? loaders : undefined;
 
   // Signature: parseInBatches(data, options, url) - Uses registered loaders
@@ -52,14 +79,13 @@ export async function parseInBatches(
   const loader = await selectLoader(data as ArrayBuffer, loaders as Loader | Loader[], options);
   // Note: if options.nothrow was set, it is possible that no loader was found, if so just return null
   if (!loader) {
-    // @ts-ignore
-    return null;
+    return [];
   }
 
   // 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 +101,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 +120,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 +140,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,11 +1,8 @@
-import type {
-  SyncDataType,
-  Loader,
-  LoaderWithParser,
-  LoaderContext,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
-import {assert} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {LoaderContext, SyncDataType} from '@loaders.gl/loader-utils';
+import type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';
 import {selectLoaderSync} from './select-loader';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {normalizeOptions} from '../loader-utils/option-utils';
@@ -13,21 +10,45 @@ import {getArrayBufferOrStringFromDataSync} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
 import {getResourceUrl} from '../utils/resource-utils';
 
+// OVERLOADS
+
+/**
+ * Parses `data` synchronously using the specified loader
+ */
+export function parseSync<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+>(
+  data: SyncDataType,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): LoaderReturnType<LoaderT>;
+
+/**
+ * Parses `data` synchronously by matching one of the supplied loaders
+ */
+export function parseSync(
+  data: SyncDataType,
+  loaders: Loader[],
+  options?: LoaderOptions,
+  context?: LoaderContext
+): unknown;
+
+/**
+ * Parses `data` synchronously by matching a pre=registered loader
+ */
+export function parseSync(data: SyncDataType, options?: LoaderOptions): unknown;
+
 /**
  * Parses `data` synchronously using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
  */
 export function parseSync(
   data: SyncDataType,
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): any {
-  assert(!context || typeof context === 'object'); // parseSync no longer accepts final url
-
+): unknown {
   // Signature: parseSync(data, options)
   // Uses registered loaders
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -49,7 +70,7 @@ export function parseSync(
   }
 
   // Normalize options
-  options = normalizeOptions(options, loader, candidateLoaders);
+  options = normalizeOptions(options, loader, candidateLoaders as Loader[] | undefined);
 
   // Extract a url for auto detection
   const url = getResourceUrl(data);
@@ -58,7 +79,7 @@ export function parseSync(
     throw new Error('parseSync called parse (which is async');
   };
   context = getLoaderContext(
-    {url, parseSync, parse, loaders: loaders as Loader[]},
+    {url, _parseSync: parse, _parse: parse, loaders: loaders as Loader[]},
     options,
     context || null
   );

package/src/lib/api/parse.ts

@@ -1,12 +1,14 @@
 // loaders.gl, MIT license
 
-import type {DataType, Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {Loader, LoaderContext, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {DataType, LoaderWithParser} from '@loaders.gl/loader-utils';
 import type {LoaderOptionsType, LoaderReturnType} from '@loaders.gl/loader-utils';
-import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {parseWithWorker, canParseWithWorker} from '@loaders.gl/loader-utils';
+import {assert, validateWorkerVersion} from '@loaders.gl/worker-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {isResponse} from '../../javascript-utils/is-type';
 import {normalizeOptions} from '../loader-utils/option-utils';
+import {mergeLoaderOptions} from '@loaders.gl/loader-utils';
 import {getArrayBufferOrStringFromData} from '../loader-utils/get-data';
 import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
 import {getResourceUrl} from '../utils/resource-utils';
@@ -14,6 +16,9 @@ import {selectLoader} from './select-loader';
 
 // type LoaderArrayType<T> = T extends (infer Loader)[] ? LoaderOptionsType<Loader> : T
 
+/**
+ * Parses `data` asynchronously using the supplied loader
+ */
 export async function parse<
   LoaderT extends Loader,
   OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
@@ -24,17 +29,23 @@ export async function parse<
   context?: LoaderContext
 ): Promise<LoaderReturnType<LoaderT>>;
 
+/**
+ * Parses `data` asynchronously by matching one of the supplied loader
+ */
 export async function parse(
   data: DataType | Promise<DataType>,
   loaders: Loader[],
   options?: LoaderOptions,
   context?: LoaderContext
-): Promise<any>;
+): Promise<unknown>;
 
+/**
+ * Parses data asynchronously by matching a pre-registered loader
+ */
 export async function parse(
   data: DataType | Promise<DataType>,
   options?: LoaderOptions
-): Promise<any>;
+): Promise<unknown>;
 
 /**
  * Parses `data` using a specified loader
@@ -49,9 +60,7 @@ export async function parse(
   loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
-): Promise<any> {
-  assert(!context || typeof context === 'object'); // parse no longer accepts final url
-
+): Promise<unknown> {
   // Signature: parse(data, options, context | url)
   // Uses registered loaders
   if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
@@ -78,33 +87,48 @@ export async function parse(
   }
 
   // Normalize options
+  // @ts-expect-error
   options = normalizeOptions(options, loader, candidateLoaders, url); // Could be invalid...
 
   // Get a context (if already present, will be unchanged)
-  context = getLoaderContext({url, parse, loaders: candidateLoaders}, options, context || null);
+  context = getLoaderContext(
+    // @ts-expect-error
+    {url, _parse: parse, loaders: candidateLoaders},
+    options,
+    context || null
+  );
 
   return await parseWithLoader(loader, data, options, context);
 }
 
 // TODO: support progress and abort
 // TODO - should accept loader.parseAsyncIterator and concatenate.
-async function parseWithLoader(loader, data, options, context) {
+async function parseWithLoader(
+  loader: Loader,
+  data,
+  options: LoaderOptions,
+  context: LoaderContext
+): Promise<unknown> {
   validateWorkerVersion(loader);
 
+  options = mergeLoaderOptions(loader.options, options);
+
   if (isResponse(data)) {
     // Serialize to support passing the response to web worker
     const response = data as Response;
     const {ok, redirected, status, statusText, type, url} = response;
     const headers = Object.fromEntries(response.headers.entries());
+    // @ts-expect-error TODO - fix this
     context.response = {headers, ok, redirected, status, statusText, type, url};
   }
 
   data = await getArrayBufferOrStringFromData(data, loader, options);
 
+  const loaderWithParser = loader as LoaderWithParser;
+
   // First check for synchronous text parser, wrap results in promises
-  if (loader.parseTextSync && typeof data === 'string') {
-    options.dataType = 'text';
-    return loader.parseTextSync(data, options, context, loader);
+  if (loaderWithParser.parseTextSync && typeof data === 'string') {
+    return loaderWithParser.parseTextSync(data, options, context);
   }
 
   // If we have a workerUrl and the loader can parse the given options efficiently in a worker
@@ -113,16 +137,16 @@ async function parseWithLoader(loader, data, options, context) {
   }
 
   // Check for asynchronous parser
-  if (loader.parseText && typeof data === 'string') {
-    return await loader.parseText(data, options, context, loader);
+  if (loaderWithParser.parseText && typeof data === 'string') {
+    return await loaderWithParser.parseText(data, options, context);
   }
 
-  if (loader.parse) {
-    return await loader.parse(data, options, context, loader);
+  if (loaderWithParser.parse) {
+    return await loaderWithParser.parse(data, options, context);
   }
 
   // This should not happen, all sync loaders should also offer `parse` function
-  assert(!loader.parseSync);
+  assert(!loaderWithParser.parseSync);
 
   // TBD - If asynchronous parser not available, return null
   throw new Error(`${loader.id} loader - no parser found and worker is disabled`);

package/src/lib/api/save.ts

@@ -2,12 +2,12 @@ import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
 import {encode, encodeSync} from './encode';
 import {writeFile, writeFileSync} from '../fetch/write-file';
 
-export async function save(data, url, writer: Writer, options: WriterOptions) {
+export async function save(data: unknown, url: string, writer: Writer, options: WriterOptions) {
   const encodedData = await encode(data, writer, options);
   return await writeFile(url, encodedData);
 }
 
-export function saveSync(data, url, writer, options) {
+export function saveSync(data: unknown, url: string, writer: Writer, options: WriterOptions) {
   const encodedData = encodeSync(data, writer, options);
   return writeFileSync(url, encodedData);
 }

package/src/lib/api/select-loader.ts

@@ -6,6 +6,7 @@ import {getResourceUrl, getResourceMIMEType} from '../utils/resource-utils';
 import {getRegisteredLoaders} from './register-loaders';
 import {isBlob} from '../../javascript-utils/is-type';
 import {stripQueryString} from '../utils/url-utils';
+import {TypedArray} from '@loaders.gl/schema';
 
 const EXT_PATTERN = /\.([^.]+)$/;
 
@@ -135,12 +136,16 @@ function selectLoaderInternal(
   reason = reason || (loader ? `matched MIME type ${type}` : '');
 
   // Look for loader via initial bytes (Note: not always accessible (e.g. Response, stream, async iterator)
+  // @ts-ignore Blob | Response
   loader = loader || findLoaderByInitialBytes(loaders, data);
+  // @ts-ignore Blob | Response
   reason = reason || (loader ? `matched initial data ${getFirstCharacters(data)}` : '');
 
   // Look up loader by fallback mime type
-  loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
-  reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
+  if (options?.fallbackMimeType) {
+    loader = loader || findLoaderByMIMEType(loaders, options?.fallbackMimeType);
+    reason = reason || (loader ? `matched fallback MIME type ${type}` : '');
+  }
 
   if (reason) {
     log.log(1, `selectLoader selected ${loader?.name}: ${reason}.`);
@@ -150,7 +155,7 @@ function selectLoaderInternal(
 }
 
 /** Check HTTP Response */
-function validHTTPResponse(data: any): boolean {
+function validHTTPResponse(data: unknown): boolean {
   // HANDLE HTTP status
   if (data instanceof Response) {
     // 204 - NO CONTENT. This handles cases where e.g. a tile server responds with 204 for a missing tile
@@ -162,7 +167,7 @@ function validHTTPResponse(data: any): boolean {
 }
 
 /** Generate a helpful message to help explain why loader selection failed. */
-function getNoValidLoaderMessage(data): string {
+function getNoValidLoaderMessage(data: string | ArrayBuffer | Response | Blob): string {
   const url = getResourceUrl(data);
   const type = getResourceMIMEType(data);
 
@@ -170,6 +175,7 @@ function getNoValidLoaderMessage(data): string {
   message += url ? `${path.filename(url)}, ` : 'no url provided, ';
   message += `MIME type: ${type ? `"${type}"` : 'not provided'}, `;
   // First characters are only accessible when called on data (string or arrayBuffer).
+  // @ts-ignore Blob | Response
   const firstCharacters: string = data ? getFirstCharacters(data) : '';
   message += firstCharacters ? ` first bytes: "${firstCharacters}"` : 'first bytes: not available';
   message += ')';
@@ -204,7 +210,7 @@ function findLoaderByExtension(loaders: Loader[], extension: string): Loader | n
   return null;
 }
 
-function findLoaderByMIMEType(loaders, mimeType) {
+function findLoaderByMIMEType(loaders: Loader[], mimeType: string): Loader | null {
   for (const loader of loaders) {
     if (loader.mimeTypes && loader.mimeTypes.includes(mimeType)) {
       return loader;
@@ -219,7 +225,7 @@ function findLoaderByMIMEType(loaders, mimeType) {
   return null;
 }
 
-function findLoaderByInitialBytes(loaders, data) {
+function findLoaderByInitialBytes(loaders: Loader[], data: string | ArrayBuffer): Loader | null {
   if (!data) {
     return null;
   }
@@ -245,27 +251,32 @@ function findLoaderByInitialBytes(loaders, data) {
   return null;
 }
 
-function testDataAgainstText(data, loader) {
+function testDataAgainstText(data: string, loader: Loader): boolean {
   if (loader.testText) {
     return loader.testText(data);
   }
 
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
-  return tests.some((test) => data.startsWith(test));
+  return tests.some((test) => data.startsWith(test as string));
 }
 
-function testDataAgainstBinary(data, byteOffset, loader) {
+function testDataAgainstBinary(data: ArrayBuffer, byteOffset: number, loader: Loader): boolean {
   const tests = Array.isArray(loader.tests) ? loader.tests : [loader.tests];
   return tests.some((test) => testBinary(data, byteOffset, loader, test));
 }
 
-function testBinary(data, byteOffset, loader, test) {
+function testBinary(
+  data: ArrayBuffer,
+  byteOffset: number,
+  loader: Loader,
+  test?: ArrayBuffer | string | ((b: ArrayBuffer) => boolean)
+): boolean {
   if (test instanceof ArrayBuffer) {
     return compareArrayBuffers(test, data, test.byteLength);
   }
   switch (typeof test) {
     case 'function':
-      return test(data, loader);
+      return test(data);
 
     case 'string':
       // Magic bytes check: If `test` is a string, check if binary data starts with that strings
@@ -277,7 +288,7 @@ function testBinary(data, byteOffset, loader, test) {
   }
 }
 
-function getFirstCharacters(data, length: number = 5) {
+function getFirstCharacters(data: string | ArrayBuffer | TypedArray, length: number = 5) {
   if (typeof data === 'string') {
     return data.slice(0, length);
   } else if (ArrayBuffer.isView(data)) {
@@ -290,7 +301,7 @@ function getFirstCharacters(data, length: number = 5) {
   return '';
 }
 
-function getMagicString(arrayBuffer, byteOffset, length) {
+function getMagicString(arrayBuffer: ArrayBuffer, byteOffset: number, length: number): string {
   if (arrayBuffer.byteLength < byteOffset + length) {
     return '';
   }

package/src/lib/fetch/fetch-file.node.ts

@@ -0,0 +1,61 @@
+// loaders.gl, MIT license
+
+import {fs} from '@loaders.gl/loader-utils';
+
+/**
+ * Enables
+ * @param url
+ * @param options
+ * @returns
+ */
+export async function fetchFileNode(url: string, options): Promise<Response> {
+  // Support `file://` protocol
+  const FILE_PROTOCOL_REGEX = /^file:\/\//;
+  url.replace(FILE_PROTOCOL_REGEX, '/');
+
+  const noqueryUrl = url.split('?')[0];
+
+  try {
+    // Now open the stream
+    const body = await new Promise<fs.ReadStream>((resolve, reject) => {
+      // @ts-ignore
+      const stream = fs.createReadStream(noqueryUrl, {encoding: null});
+      stream.once('readable', () => resolve(stream));
+      stream.on('error', (error) => reject(error));
+    });
+
+    const status = 200;
+    const statusText = 'OK';
+    const headers = getHeadersForFile(noqueryUrl);
+    // @ts-expect-error
+    const response = new Response(body, {headers, status, statusText});
+    Object.defineProperty(response, 'url', {value: url});
+    return response;
+  } catch (error) {
+    const errorMessage = (error as Error).message;
+    const status = 400;
+    const statusText = errorMessage;
+    const headers = {};
+    const response = new Response(errorMessage, {headers, status, statusText});
+    Object.defineProperty(response, 'url', {value: url});
+    return response;
+  }
+}
+
+function getHeadersForFile(noqueryUrl: string): Headers {
+  const headers = {};
+
+  // Fix up content length if we can for best progress experience
+  if (!headers['content-length']) {
+    const stats = fs.statSync(noqueryUrl);
+    headers['content-length'] = stats.size;
+  }
+
+  // Automatically decompress gzipped files with .gz extension
+  if (noqueryUrl.endsWith('.gz')) {
+    noqueryUrl = noqueryUrl.slice(0, -3);
+    headers['content-encoding'] = 'gzip';
+  }
+
+  return new Headers(headers);
+}

package/src/lib/fetch/fetch-file.ts

@@ -1,30 +1,42 @@
+// loaders.gl, MIT license
+
 import {resolvePath} from '@loaders.gl/loader-utils';
 import {makeResponse} from '../utils/response-utils';
-// import {getErrorMessageFromResponse} from './fetch-error-message';
+import * as node from './fetch-file.node';
+
+export function isNodePath(url: string): boolean {
+  return !isRequestURL(url) && !isDataURL(url);
+}
+
+export function isRequestURL(url: string): boolean {
+  return url.startsWith('http:') || url.startsWith('https:');
+}
+
+export function isDataURL(url: string): boolean {
+  return url.startsWith('data:');
+}
 
 /**
- * fetch compatible function
- * Reads file data from:
- * - http/http urls
- * - data urls
- * - File/Blob objects
- * Leverages `@loaders.gl/polyfills` for Node.js support
- * Respects pathPrefix and file aliases
+ * fetch API compatible function
+ * - Supports fetching from Node.js local file system paths
+ * - Respects pathPrefix and file aliases
  */
 export async function fetchFile(
-  url: string | Blob,
-  options?: RequestInit & {fetch?: RequestInit | Function}
+  urlOrData: string | Blob,
+  fetchOptions?: RequestInit
 ): Promise<Response> {
-  if (typeof url === 'string') {
-    url = resolvePath(url);
+  if (typeof urlOrData === 'string') {
+    const url = resolvePath(urlOrData);
 
-    let fetchOptions: RequestInit = options as RequestInit;
-    if (options?.fetch && typeof options?.fetch !== 'function') {
-      fetchOptions = options.fetch;
+    // Support fetching from local file system
+    if (isNodePath(url) && node?.fetchFileNode) {
+      return node.fetchFileNode(url, fetchOptions);
     }
 
+    // Call global fetch
     return await fetch(url, fetchOptions);
   }
 
-  return await makeResponse(url);
+  // TODO - should we still call fetch on non-URL inputs?
+  return await makeResponse(urlOrData);
 }