@loaders.gl/core 4.4.5 → 5.0.0-alpha.2

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

@@ -43,30 +43,68 @@ async function* makeBrowserStreamIterator(
   const reader = stream.getReader();
 
   let nextBatchPromise: Promise<{done?: boolean; value?: Uint8Array}> | undefined;
+  let streamFinished = false;
+  let streamReadFailed = false;
+  let iteratorFailed = false;
 
   try {
     // eslint-disable-next-line no-constant-condition
     while (true) {
       const currentBatchPromise = nextBatchPromise || reader.read();
-      // Issue a read for an additional batch, while we await the next batch
-      // Idea is to make fetching happen in parallel with processing / parsing
-      if (options?._streamReadAhead) {
-        nextBatchPromise = reader.read();
-      }
+      nextBatchPromise = undefined;
       // Read from the stream
       // value is a Uint8Array
-      const {done, value} = await currentBatchPromise;
+      let batch;
+      try {
+        batch = await currentBatchPromise;
+      } catch (error) {
+        streamReadFailed = true;
+        throw error;
+      }
+      const {done, value} = batch;
       // Exit if we're done
       if (done) {
+        streamFinished = true;
         return;
       }
+      // Issue a read for an additional batch while the current batch is processed
+      if (options?._streamReadAhead) {
+        nextBatchPromise = reader.read();
+        // Observe a prefetched rejection even if the consumer stops before requesting it
+        void nextBatchPromise.catch(() => {});
+      }
       // Else yield the chunk
       yield toArrayBuffer(value);
     }
   } catch (error) {
-    // TODO - examples makes it look like this should always be called,
-    // but that generates exceptions so only call it if we do not reach the end
-    reader.releaseLock();
+    iteratorFailed = true;
+    throw error;
+  } finally {
+    let cleanupFailed = false;
+    let cleanupError: unknown;
+
+    if (!streamFinished && !streamReadFailed) {
+      try {
+        await reader.cancel();
+      } catch (error) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+
+    try {
+      reader.releaseLock();
+    } catch (error) {
+      if (!cleanupFailed) {
+        cleanupFailed = true;
+        cleanupError = error;
+      }
+    }
+
+    // Preserve errors from iteration instead of replacing them with cleanup errors
+    if (!iteratorFailed && cleanupFailed) {
+      throw cleanupError;
+    }
   }
 }
 

package/src/lib/api/core-api.ts

@@ -0,0 +1,25 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {CoreAPI} from '@loaders.gl/loader-utils';
+import {fetchFile} from '../fetch/fetch-file';
+import {parse} from './parse';
+import {parseFile} from './parse-file';
+import {parseSync} from './parse-sync';
+import {parseInBatches} from './parse-in-batches';
+import {load} from './load';
+import {loadInBatches} from './load-in-batches';
+
+/**
+ * Shared Core API surface that can be injected into contexts and sources.
+ */
+export const coreApi: CoreAPI = Object.freeze({
+  fetchFile,
+  parse,
+  parseFile,
+  parseSync,
+  parseInBatches,
+  load,
+  loadInBatches
+});

package/src/lib/api/create-data-source.ts

@@ -2,7 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Source, SourceArrayOptionsType, SourceArrayDataSourceType} from '@loaders.gl/loader-utils';
+import {
+  SourceLoader,
+  SourceArrayOptionsType,
+  SourceArrayDataSourceType
+} from '@loaders.gl/loader-utils';
+import {coreApi} from './core-api';
+import {selectLoaderSync} from './select-loader';
 
 /**
  * Creates a source from a service
@@ -13,39 +19,33 @@ import {Source, SourceArrayOptionsType, SourceArrayDataSourceType} from '@loader
  */
 // DataSourceOptionsT extends DataSourceOptions = DataSourceOptions,
 // DataSourceT extends DataSource = DataSource
-export function createDataSource<SourceArrayT extends Source[]>(
-  data: string | Blob,
+export function createDataSource<SourceArrayT extends SourceLoader[]>(
+  data: unknown,
   sources: Readonly<SourceArrayT>,
   options: Readonly<SourceArrayOptionsType<SourceArrayT>>
 ): SourceArrayDataSourceType<SourceArrayT> {
-  const type = options?.core?.type || (options.type as unknown as string) || 'auto';
-  const source = type === 'auto' ? selectSource(data, sources) : getSourceOfType(type, sources);
+  const resolvedOptions = (options || {}) as SourceArrayOptionsType<SourceArrayT>;
+  const type = resolvedOptions?.core?.type || (resolvedOptions.type as unknown as string) || 'auto';
+  const source =
+    sources.length === 1
+      ? sources[0]
+      : type === 'auto'
+        ? (selectLoaderSync(data as never, sources as unknown as SourceLoader[], {
+            // `createDataSource` supports non-fetch inputs such as in-memory tables.
+            // Selection remains best-effort for those cases.
+            ...resolvedOptions,
+            core: {...resolvedOptions?.core, type: 'auto'}
+          }) as SourceArrayT[number] | null)
+        : getSourceOfType(type, sources);
 
   if (!source) {
     throw new Error('Not a valid source type');
   }
-  return source.createDataSource(data, options);
-}
-
-// TODO - use selectSource...
-
-/** Guess service type from URL */
-function selectSource<SourceArrayT extends Source[]>(
-  url: string | Blob,
-  sources: Readonly<SourceArrayT>
-): SourceArrayT[number] | null {
-  for (const service of sources) {
-    // @ts-expect-error
-    if (service.testURL && service.testURL(url)) {
-      return service;
-    }
-  }
-
-  return null;
+  return source.createDataSource(data as string | Blob, resolvedOptions, coreApi);
 }
 
 /** Guess service type from URL */
-function getSourceOfType(type: string, sources: Readonly<Source[]>): Source | null {
+function getSourceOfType(type: string, sources: Readonly<SourceLoader[]>): SourceLoader | null {
   for (const service of sources) {
     if (service.type === type) {
       return service;

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

@@ -3,13 +3,15 @@
 // Copyright (c) vis.gl contributors
 
 import type {
-  LoaderWithParser,
+  Loader,
   LoaderOptions,
   LoaderContext,
   FetchLike,
   BatchableDataType,
   LoaderBatchType,
-  LoaderOptionsType
+  LoaderOptionsType,
+  LoaderOptionsWithShape,
+  LoaderShapeType
 } from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {getFetchFunction} from '../loader-utils/get-fetch-function';
@@ -22,8 +24,11 @@ type FileType = string | File | Blob | Response | (string | File | Blob | Respon
  * Parses `data` synchronously using a specified loader
  */
 export async function loadInBatches<
-  LoaderT extends LoaderWithParser,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
 >(
   files: FileType,
   loader: LoaderT,
@@ -40,32 +45,32 @@ export async function loadInBatches<
  */
 export function loadInBatches(
   files: FileType,
-  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,
+  loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
 ): Promise<AsyncIterable<unknown>>;
 
 export function loadInBatches(
   files: FileType[] | FileList,
-  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,
+  loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
 ): Promise<AsyncIterable<unknown>>[];
 
 export function loadInBatches(
   files: FileType | FileType[] | FileList,
-  loaders?: LoaderWithParser | LoaderWithParser[] | LoaderOptions,
+  loaders?: Loader | Loader[] | LoaderOptions,
   options?: LoaderOptions,
   context?: LoaderContext
 ): Promise<AsyncIterable<unknown>> | Promise<AsyncIterable<unknown>>[] {
-  let loadersArray: LoaderWithParser | LoaderWithParser[] | undefined;
+  let loadersArray: Loader | Loader[] | undefined;
   // Signature: load(url, options)
   if (!Array.isArray(loaders) && !isLoaderObject(loaders)) {
     context = undefined; // context not supported in short signature
     options = loaders as LoaderOptions;
     loadersArray = undefined;
   } else {
-    loadersArray = loaders as LoaderWithParser | LoaderWithParser[] | undefined;
+    loadersArray = loaders as Loader | Loader[] | undefined;
   }
 
   // Select fetch function
@@ -77,7 +82,7 @@ export function loadInBatches(
   }
 
   // Multiple URLs / files
-  const promises = files.map((file) =>
+  const promises = files.map(file =>
     loadOneFileInBatches(file, loadersArray!, options || {}, fetch)
   );
 
@@ -87,7 +92,7 @@ export function loadInBatches(
 
 async function loadOneFileInBatches(
   file: FileType,
-  loaders: LoaderWithParser | LoaderWithParser[],
+  loaders: Loader | Loader[],
   options: LoaderOptions,
   fetch: FetchLike
 ): Promise<AsyncIterable<unknown>> {

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

@@ -0,0 +1,152 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader, LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+
+const loaderImplementationPromises = new Map<Loader, Map<string, Promise<LoaderWithParser>>>();
+const loaderImplementations = new Map<Loader, Map<string, LoaderWithParser>>();
+
+/** Gets a parser-bearing implementation for a loader, loading it if needed. */
+export async function getLoaderImplementation(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser> {
+  if (isLoaderWithParser(loader)) {
+    return loader;
+  }
+
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader, options);
+  const loaderImplementation = loaderImplementations.get(loader)?.get(implementationCacheKey);
+  if (loaderImplementation) {
+    return loaderImplementation;
+  }
+
+  let loaderImplementationPromisesForLoader = loaderImplementationPromises.get(loader);
+  if (!loaderImplementationPromisesForLoader) {
+    loaderImplementationPromisesForLoader = new Map();
+    loaderImplementationPromises.set(loader, loaderImplementationPromisesForLoader);
+  }
+
+  let loaderImplementationPromise =
+    loaderImplementationPromisesForLoader.get(implementationCacheKey);
+  if (!loaderImplementationPromise) {
+    loaderImplementationPromise = resolveLoaderImplementation(loader, options, url)
+      .then(implementation => {
+        let loaderImplementationsForLoader = loaderImplementations.get(loader);
+        if (!loaderImplementationsForLoader) {
+          loaderImplementationsForLoader = new Map();
+          loaderImplementations.set(loader, loaderImplementationsForLoader);
+        }
+        loaderImplementationsForLoader.set(implementationCacheKey, implementation);
+        return implementation;
+      })
+      .catch(error => {
+        loaderImplementationPromisesForLoader.delete(implementationCacheKey);
+        if (loaderImplementationPromisesForLoader.size === 0) {
+          loaderImplementationPromises.delete(loader);
+        }
+        throw error;
+      });
+    loaderImplementationPromisesForLoader.set(implementationCacheKey, loaderImplementationPromise);
+  }
+
+  return await loaderImplementationPromise;
+}
+
+/** Gets a cached parser-bearing implementation for a loader without loading it. */
+export function getLoaderImplementationSync(loader: Loader): LoaderWithParser | null {
+  if (isLoaderWithParser(loader)) {
+    return loader;
+  }
+
+  const implementationCacheKey = getLoaderImplementationCacheKey(loader);
+  return loaderImplementations.get(loader)?.get(implementationCacheKey) || null;
+}
+
+/** Returns true when a loader object already includes parser methods. */
+export function isLoaderWithParser(loader: Loader): loader is LoaderWithParser {
+  const candidate = loader as LoaderWithParser;
+  return Boolean(
+    candidate.parse ||
+      candidate.parseSync ||
+      candidate.parseInBatches ||
+      candidate.parseText ||
+      candidate.parseTextSync ||
+      candidate.parseFile ||
+      candidate.parseFileInBatches
+  );
+}
+
+/** Resolves a parser-bearing implementation through loader preload or the test import fallback. */
+async function resolveLoaderImplementation(
+  loader: Loader,
+  options?: LoaderOptions,
+  url?: string
+): Promise<LoaderWithParser> {
+  if (loader.preload) {
+    const preloadedLoader = await loader.preload(url || '', options);
+    if (isLoaderWithParser(preloadedLoader as Loader)) {
+      return preloadedLoader as LoaderWithParser;
+    }
+
+    throw new Error(`${loader.id} loader preload() did not return a parser-bearing loader`);
+  }
+
+  const implementationSpecifier = getLoaderImplementationSpecifier(loader, options);
+  return await importLoaderImplementation(implementationSpecifier, loader.id);
+}
+
+/** Gets the dynamic implementation specifier for the test worker fallback path. */
+function getLoaderImplementationSpecifier(loader: Loader, options?: LoaderOptions): string {
+  const workerType = options?._workerType || options?.core?._workerType;
+  if (workerType === 'test') {
+    const sourcePath = `modules/${loader.module}/src/${loader.id}-loader.ts`;
+    if (typeof window !== 'undefined') {
+      return `/${sourcePath}`;
+    }
+
+    if (typeof process !== 'undefined' && process.cwd) {
+      return new URL(sourcePath, `file://${process.cwd()}/`).toString();
+    }
+
+    return sourcePath;
+  }
+
+  throw new Error(
+    `${loader.id} loader does not provide a parser implementation. Import a parser-bearing loader directly, or use preload() before parse/load.`
+  );
+}
+
+/** Gets the cache key for option-selected parser implementations. */
+function getLoaderImplementationCacheKey(loader: Loader, options?: LoaderOptions): string {
+  const loaderOptions = options?.[loader.id] as {backend?: unknown} | undefined;
+  const defaultLoaderOptions = loader.options?.[loader.id] as {backend?: unknown} | undefined;
+  return String(loaderOptions?.backend || defaultLoaderOptions?.backend || '');
+}
+
+/** Imports a module and finds the parser-bearing loader implementation with the requested id. */
+async function importLoaderImplementation(
+  implementationSpecifier: string,
+  loaderId: string
+): Promise<LoaderWithParser> {
+  const moduleExports = await import(
+    /* webpackIgnore: true */ /* @vite-ignore */ implementationSpecifier
+  );
+
+  for (const exportValue of Object.values(moduleExports)) {
+    if (
+      exportValue &&
+      typeof exportValue === 'object' &&
+      (exportValue as Loader).id === loaderId &&
+      isLoaderWithParser(exportValue as Loader)
+    ) {
+      return exportValue as LoaderWithParser;
+    }
+  }
+
+  throw new Error(
+    `Could not find parser implementation for ${loaderId} in ${implementationSpecifier}`
+  );
+}

package/src/lib/api/load.ts

@@ -7,17 +7,26 @@ import type {
   Loader,
   LoaderContext,
   LoaderOptions,
+  LoaderOptionsWithShape,
   LoaderOptionsType,
+  LoaderShapeType,
   LoaderReturnType,
   LoaderArrayOptionsType,
-  LoaderArrayReturnType
+  LoaderArrayReturnType,
+  SourceLoader
 } from '@loaders.gl/loader-utils';
-import {isBlob} from '@loaders.gl/loader-utils';
+import {isBlob, isSourceLoader} from '@loaders.gl/loader-utils';
 import {isLoaderObject} from '../loader-utils/normalize-loader';
 import {getFetchFunction} from '../loader-utils/get-fetch-function';
 import {normalizeLoaderOptions} from '../loader-utils/option-utils';
+import {fetchFile} from '../fetch/fetch-file';
 
 import {parse} from './parse';
+import {parseFile} from './parse-file';
+import {parseSync} from './parse-sync';
+import {parseInBatches} from './parse-in-batches';
+import {loadInBatches} from './load-in-batches';
+import {selectLoader} from './select-loader';
 
 /**
  * Parses `data` using a specified loader
@@ -31,7 +40,10 @@ import {parse} from './parse';
 
 export async function load<
   LoaderT extends Loader,
-  OptionsT extends LoaderOptions = LoaderOptionsType<LoaderT>
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
 >(
   url: string | DataType,
   loader: LoaderT,
@@ -81,6 +93,70 @@ export async function load(
     resolvedOptions = options as LoaderOptions;
   }
 
+  if (!Array.isArray(resolvedLoaders) && isSourceLoader(resolvedLoaders)) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders, url, resolvedOptions);
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(
+      url as string | Blob,
+      (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
+      runtimeCoreApi
+    );
+  }
+
+  if (
+    Array.isArray(resolvedLoaders) &&
+    resolvedLoaders.length === 1 &&
+    isSourceLoader(resolvedLoaders[0])
+  ) {
+    const sourceLoader = await resolveSourceLoader(resolvedLoaders[0], url, resolvedOptions);
+    const runtimeCoreApi = {
+      fetchFile,
+      parse,
+      parseFile,
+      parseSync,
+      parseInBatches,
+      load,
+      loadInBatches
+    };
+    return sourceLoader.createDataSource(
+      url as string | Blob,
+      (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
+      runtimeCoreApi
+    );
+  }
+
+  if (typeof url === 'string' || isBlob(url)) {
+    const selectedLoader = await selectLoader(url, resolvedLoaders as Loader | Loader[], {
+      ...resolvedOptions,
+      core: {...resolvedOptions?.core, nothrow: true}
+    });
+
+    if (selectedLoader && isSourceLoader(selectedLoader)) {
+      const sourceLoader = await resolveSourceLoader(selectedLoader, url, resolvedOptions);
+      return sourceLoader.createDataSource(
+        url,
+        (resolvedOptions || {}) as LoaderOptionsType<SourceLoader>,
+        {
+          fetchFile,
+          parse,
+          parseFile,
+          parseSync,
+          parseInBatches,
+          load,
+          loadInBatches
+        }
+      );
+    }
+  }
+
   // Select fetch function
   const fetch = getFetchFunction(resolvedOptions);
 
@@ -114,6 +190,23 @@ export async function load(
   // Data is loaded (at least we have a `Response` object) so time to hand over to `parse`
   // return await parse(data, loaders as Loader[], options);
   return Array.isArray(resolvedLoaders)
-    ? await parse(data, resolvedLoaders, resolvedOptions) // loader array overload
-    : await parse(data, resolvedLoaders, resolvedOptions); // single loader overload
+    ? await parse(data, resolvedLoaders, resolvedOptions, context) // loader array overload
+    : await parse(data, resolvedLoaders, resolvedOptions, context); // single loader overload
+}
+
+/** Resolves a lightweight source loader into its runtime implementation when necessary. */
+async function resolveSourceLoader(
+  loader: SourceLoader,
+  url: string | DataType,
+  options?: LoaderOptions
+): Promise<SourceLoader> {
+  if (!loader.preload) {
+    return loader;
+  }
+
+  const sourceLoader = await loader.preload(typeof url === 'string' ? url : '', options);
+  if (!isSourceLoader(sourceLoader)) {
+    throw new Error(`${loader.id} source loader preload() did not return a runtime source loader`);
+  }
+  return sourceLoader;
 }

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

@@ -0,0 +1,143 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Loader,
+  LoaderContext,
+  LoaderOptions,
+  LoaderOptionsWithShape,
+  LoaderOptionsType,
+  LoaderShapeType,
+  LoaderReturnType,
+  LoaderArrayOptionsType,
+  LoaderArrayReturnType,
+  LoaderWithParser,
+  ReadableFile,
+  StrictLoaderOptions
+} from '@loaders.gl/loader-utils';
+import {isSourceLoader, mergeOptions} from '@loaders.gl/loader-utils';
+import {validateWorkerVersion} from '@loaders.gl/worker-utils';
+import {isLoaderObject} from '../loader-utils/normalize-loader';
+import {normalizeOptions} from '../loader-utils/option-utils';
+import {getLoaderContext, getLoadersFromContext} from '../loader-utils/loader-context';
+import {getLoaderImplementation} from './load-loader';
+import {parse} from './parse';
+import {selectLoader} from './select-loader';
+
+/**
+ * Parses a random access readable file asynchronously using the supplied loader.
+ */
+export async function parseFile<
+  LoaderT extends Loader,
+  OptionsT extends LoaderOptions = LoaderOptionsWithShape<
+    LoaderOptionsType<LoaderT>,
+    LoaderShapeType<LoaderT>
+  >
+>(
+  file: ReadableFile,
+  loader: LoaderT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<LoaderReturnType<LoaderT>>;
+
+/**
+ * Parses a random access readable file asynchronously by matching one of the supplied loaders.
+ */
+export async function parseFile<
+  LoaderArrayT extends Loader[],
+  OptionsT extends LoaderOptions = LoaderArrayOptionsType<LoaderArrayT>
+>(
+  file: ReadableFile,
+  loaders: LoaderArrayT,
+  options?: OptionsT,
+  context?: LoaderContext
+): Promise<LoaderArrayReturnType<LoaderArrayT>>;
+
+/**
+ * Parses a random access readable file asynchronously by matching a pre-registered loader.
+ * @deprecated Loader registration is deprecated, use parseFile(file, loaders, options) instead.
+ */
+export async function parseFile(file: ReadableFile, options?: LoaderOptions): Promise<unknown>;
+
+/**
+ * Parses a random access readable file using a specified loader.
+ * @param file readable file
+ * @param loaders loader or loaders to use
+ * @param options loader options
+ * @param context loader context
+ * @returns parsed data
+ */
+export async function parseFile(
+  file: ReadableFile,
+  loaders?: Loader | Loader[] | LoaderOptions,
+  options?: LoaderOptions,
+  context?: LoaderContext
+): Promise<unknown> {
+  if (loaders && !Array.isArray(loaders) && !isLoaderObject(loaders)) {
+    context = undefined;
+    options = loaders as LoaderOptions;
+    loaders = undefined;
+  }
+
+  options = options || {};
+  const url = file.url || '';
+  const typedLoaders = loaders as Loader | Loader[] | undefined;
+  const candidateLoaders = getLoadersFromContext(typedLoaders, context);
+  const loader = await selectLoader(url, candidateLoaders, options);
+  if (!loader) {
+    return null;
+  }
+
+  if (isSourceLoader(loader)) {
+    throw new Error(
+      `${loader.id} is a SourceLoader. Use load() to create a runtime source object instead of parseFile().`
+    );
+  }
+
+  // @ts-expect-error candidateLoaders may be a single forced loader
+  const strictOptions = normalizeOptions(options, loader, candidateLoaders, url);
+  context = getLoaderContext(
+    // @ts-expect-error candidateLoaders may be a single forced loader
+    {url, _parse: parse, loaders: candidateLoaders},
+    strictOptions,
+    context || null
+  );
+
+  return await parseFileWithLoader(loader, file, strictOptions, context);
+}
+
+/**
+ * Parses a readable file after a loader has been selected.
+ * @param loader selected loader
+ * @param file readable file
+ * @param options strict loader options
+ * @param context loader context
+ * @returns parsed data
+ */
+async function parseFileWithLoader(
+  loader: Loader,
+  file: ReadableFile,
+  options: StrictLoaderOptions,
+  context: LoaderContext
+): Promise<unknown> {
+  validateWorkerVersion(loader);
+  options = mergeOptions(loader.options, options);
+
+  const loaderWithParser = await getLoaderImplementation(loader, options, context.url);
+  if (loaderWithParser.parseFile) {
+    return await loaderWithParser.parseFile(file, options, context);
+  }
+
+  const parseFunction = (loaderWithParser as {parse?: LoaderWithParser['parse']}).parse;
+  if (parseFunction) {
+    const length = file.bigsize > 0n ? Number(file.bigsize) : file.size;
+    if (!length) {
+      throw new Error(`${loader.id} loader - cannot fall back to parse without a file size`);
+    }
+    const data = await file.read(0n, length);
+    return await parse(data, loaderWithParser, options, context);
+  }
+
+  throw new Error(`${loader.id} loader - no file parser found`);
+}