@loaders.gl/core 5.0.0-alpha.12 → 5.0.0-alpha.13

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

@@ -0,0 +1,19 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GetTileDataBatchResult, GetTileDataParameters, TileSource} from './tile-source';
+
+/**
+ * Request tile data in batches when a tile source supports it.
+ */
+export function getTileDataBatch<T = unknown>(
+  source: TileSource,
+  parameters: readonly GetTileDataParameters[]
+): GetTileDataBatchResult<T> {
+  if (source.getTileDataBatch) {
+    return source.getTileDataBatch(parameters) as GetTileDataBatchResult<T>;
+  }
+
+  return parameters.map(parameter => source.getTileData(parameter) as Promise<T | null>);
+}

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

@@ -0,0 +1,198 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {CRSIdentifier} from '@math.gl/geospatial/crs';
+import type {TileMatrixLimits, TileMatrixSet} from '@math.gl/geospatial';
+
+/**
+ * Props for a TileSource
+ */
+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 {
+  /** MIME type of decoded tile payloads, when known. */
+  readonly mimeType?: string | null;
+  /** Whether decoded vector coordinates are local to each tile. */
+  readonly localCoordinates?: boolean;
+  // extends DataSource {
+  getMetadata(): Promise<TileSourceMetadata>;
+  /** Flat parameters */
+  getTile(parameters: GetTileParameters): Promise<unknown | null>;
+  /** Flat parameters, batched */
+  getTileBatch?(parameters: readonly GetTileParameters[]): readonly Promise<unknown | null>[];
+  /** deck.gl compatibility: TileLayer and MTVLayer */
+  getTileData(parameters: GetTileDataParameters): Promise<unknown | null>;
+  /** deck.gl compatibility: batched tile data */
+  getTileDataBatch?(
+    parameters: readonly GetTileDataParameters[]
+  ): readonly Promise<unknown | null>[];
+}
+
+// HELPER TYPES
+
+/**
+ * Normalized capabilities of an tile service
+ * Sources are expected to normalize the response to capabilities
+ */
+export type TileSourceMetadata = {
+  format?: string;
+  formatHeader?: unknown;
+
+  /** Name of the tileset (extracted from JSON metadata if available) */
+  name?: string;
+  title?: string;
+  abstract?: string;
+  keywords?: string[];
+  /** Attribution string (extracted from JSON metadata if available) */
+  attributions?: string[];
+
+  /** Minimal zoom level of tiles in this tileset */
+  minZoom?: number;
+  /** Maximal zoom level of tiles in this tileset */
+  maxZoom?: number;
+  /** Bounding box of tiles in this tileset `[[w, s], [e, n]]`  */
+  boundingBox?: [min: [x: number, y: number], max: [x: number, y: number]];
+  /** Advertised tile grid, when the service exposes matrix or level metadata. */
+  tileGrid?: TileGrid;
+
+  /** Layer information */
+  layer?: {
+    name: string;
+    title?: string;
+    srs?: CRSIdentifier[];
+    boundingBox?: [number, number, number, number];
+    layers: TileSourceLayer[];
+  };
+};
+
+/**
+ * Normalized tile matrix information shared by WMTS and vendor tile services.
+ *
+ * `tileMatrixSet` is the authoritative geometry when present. The grid-wide fields are kept for
+ * compatibility; when `tileMatrixSet` is set they are derived from it and describe its first level.
+ */
+export type TileGrid = {
+  /** Coordinate reference system used by the grid. */
+  crs?: CRSIdentifier;
+  /** Tile width and height in pixels. */
+  tileSize?: [number, number];
+  /** Top-left origin in grid coordinates. */
+  origin?: [number, number];
+  /** Horizontal coordinate units per pixel in matrix order, when CRS units are known. */
+  resolutions?: number[];
+  /** Matrix identifiers in zoom order. */
+  matrixIds?: string[];
+  /** Matrix width and height in tile units in zoom order. */
+  matrixSizes?: Array<[number, number]>;
+  /**
+   * Complete per-level geometry in advertised order, set only when every advertised level has a
+   * resolution, origin, tile size and matrix size that pass math.gl `validateTileMatrix()`. Use it
+   * with the `@math.gl/geospatial` tile-matrix utilities. Origins are in XY order.
+   */
+  tileMatrixSet?: TileMatrixSet;
+  /**
+   * Per-level metadata as the service advertises it, aligned with `matrixIds`. Entries may be
+   * incomplete, for example without a resolution when the CRS unit is unknown, so this is not
+   * usable geometry on its own; prefer `tileMatrixSet`.
+   */
+  matrices?: TileGridMatrix[];
+  /** Inclusive source coverage. Omitted means unrestricted; an empty list allows no tiles. */
+  limits?: TileGridLimits[];
+};
+
+/** Inclusive source coverage for one matrix, independent of its geometric definition. */
+export type TileGridLimits = TileMatrixLimits & {
+  /** Identifier of the covered matrix. Matrices absent from a present limits list are unavailable. */
+  tileMatrix: string;
+};
+
+/** One advertised level of a tile grid. Fields the service does not advertise are omitted. */
+export type TileGridMatrix = {
+  /** Matrix identifier used in tile requests. */
+  id: string;
+  /** Horizontal coordinate units per pixel, also vertical unless resolutionY is supplied. */
+  resolution?: number;
+  /** Vertical coordinate units per pixel; defaults to `resolution` when omitted. */
+  resolutionY?: number;
+  /**
+   * Origin in grid coordinates, at the corner named by `cornerOfOrigin`. Sources swap it to XY
+   * only where they know the axis order; see each source's documentation.
+   */
+  origin?: [number, number];
+  /** Matrix corner that `origin` locates; omitted means top-left. */
+  cornerOfOrigin?: 'topLeft' | 'bottomLeft';
+  /** Tile width and height in pixels. */
+  tileSize?: [number, number];
+  /** Matrix width and height in tile units. */
+  matrixSize?: [number, number];
+};
+
+/**
+ * Description of one data layer in the image source
+ */
+export type TileSourceLayer = {
+  name: string;
+  title?: string;
+  srs?: CRSIdentifier[];
+  boundingBox?: [number, number, number, number];
+  layers: TileSourceLayer[];
+};
+
+/**
+ * Generic parameters for requesting an tile from an tile source
+ */
+export type GetTileParameters = {
+  /** bounding box of the requested map image */
+  z: number;
+  /** tile x coordinate */
+  x: number;
+  /** tile y coordinate */
+  y: number;
+  /**
+   * Identifier of the tile matrix to request, used verbatim. Sources that know their matrix set
+   * reject an unknown identifier. When omitted, `z` selects the matrix whose identifier is that
+   * number, otherwise the matrix at that index.
+   */
+  tileMatrix?: string;
+  /** Coordinate reference system for the tile */
+  crs?: CRSIdentifier;
+  /** Layers to render */
+  layers?: string | string[];
+  /** Styling */
+  styles?: unknown;
+  /** requested format for the return image (in case of bitmap tiles) */
+  format?: 'image/png';
+  /** Abort signal for canceling metadata, range, and tile-content requests. */
+  signal?: AbortSignal;
+};
+
+/** deck.gl compatibility: parameters for TileSource.getTileData() */
+export type GetTileDataParameters = {
+  /** Native matrix identifier, independent of the renderer's numeric index. */
+  tileMatrix?: string;
+  /** Tile index */
+  index: {x: number; y: number; z: number};
+  id: string;
+  /** Bounding Box */
+  bbox: TileBoundingBox;
+  /** Zoom level */
+  zoom?: number;
+  url?: string | null;
+  signal?: AbortSignal;
+  userData?: Record<string, any>;
+};
+
+export type GetTileDataBatchResult<T = unknown> = readonly Promise<T | null>[];
+
+/** deck.gl compatibility: bounding box */
+export type TileBoundingBox = NonGeoBoundingBox | GeoBoundingBox;
+/** deck.gl compatibility: bounding box */
+export type GeoBoundingBox = {west: number; north: number; east: number; south: number};
+/** deck.gl compatibility: bounding box */
+export type NonGeoBoundingBox = {left: number; top: number; right: number; bottom: number};

package/src/loader-utils/lib/sources/utils/image-type.ts

@@ -0,0 +1,14 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Supported Image Types @note duplicates definition in images/schema to avoid circular deps */
+export type ImageType = ImageBitmap | ImageDataType | HTMLImageElement;
+
+/** data images @note duplicates definition in images/schema to avoid circular deps */
+export type ImageDataType = {
+  data: Uint8Array;
+  width: number;
+  height: number;
+  compressed?: boolean;
+};

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

@@ -0,0 +1,31 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderOptions} from '../../../loader-types';
+import {getAuthenticatedFetch} from '../../request-utils/request-credentials';
+
+/**
+ * Gets the current fetch function from options
+ * @todo - move to loader-utils module
+ * @todo - use in core module counterpart
+ * @param options
+ * @param context
+ */
+export function getFetchFunction(options?: LoaderOptions) {
+  return getAuthenticatedFetch(options);
+}
+
+export function mergeImageSourceLoaderProps<Props extends {loadOptions?: any}>(
+  props: Props
+): Required<Props> {
+  // @ts-expect-error
+  return {
+    // Default fetch
+    ...props,
+    loadOptions: {
+      ...props.loadOptions,
+      fetch: getFetchFunction(props.loadOptions)
+    }
+  };
+}

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

@@ -0,0 +1,89 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  ArrowTable,
+  BinaryFeatureCollection,
+  GeoArrowEncodingPreference,
+  GeoJSONTable,
+  Schema
+} from '@loaders.gl/core/schema';
+import type {CRSIdentifier, SpatialReference} from '@math.gl/geospatial/crs';
+
+export type VectorSourceProps = {};
+
+/** Valid vector-source response tables. */
+export type VectorSourceData = GeoJSONTable | BinaryFeatureCollection | ArrowTable;
+
+/**
+ * VectorSource - data sources that allow features to be queried by (geospatial) extents
+ * Coordinates in returned geometry and normalized bounds use `xy` order (x/easting or
+ * longitude first). Service requests may use a different wire-axis order; adapters translate
+ * from the canonical `xy` input according to the requested CRS.
+ */
+export interface VectorSource {
+  getSchema(): Promise<Schema>;
+  getMetadata(options: {formatSpecificMetadata?: boolean}): Promise<VectorSourceMetadata>;
+  getFeatures(parameters: GetFeaturesParameters): Promise<VectorSourceData>;
+}
+
+// PARAMETER TYPES
+
+/**
+ * Normalized capabilities of an Image service
+ * @example
+ *  The WMSSourceLoader will normalize the response to the WMS `GetCapabilities`
+ *  data structure extracted from WMS XML response into an VectorSourceMetadata.
+ */
+export type VectorSourceMetadata = {
+  name: string;
+  title?: string;
+  abstract?: string;
+  keywords: string[];
+  layers: VectorSourceLayer[];
+  /**
+   * Attempts to preserve the original format specific metadata from the underlying source,
+   * May be an approximate representation
+   */
+  formatSpecificMetadata?: Record<string, any>;
+};
+
+/** Description of one data layer in the image source */
+export type VectorSourceLayer = {
+  /** Name of this layer */
+  name?: string;
+  /** Human readable title of this layer */
+  title?: string;
+  /** Coordinate systems supported by this layer */
+  crs?: CRSIdentifier[];
+  /** Normalized source CRS discovery, including representation and unknown/default state. */
+  spatialReference?: SpatialReference;
+  /** layer limits in unspecified CRS:84-like lng/lat, for quick access w/o CRS calculations. */
+  boundingBox?: [min: [x: number, y: number], max: [x: number, y: number]];
+  /** Sub layers of this layer */
+  layers?: VectorSourceLayer[];
+};
+
+/** Generic parameters for requesting an image from an image source */
+export type GetFeaturesParameters = {
+  /** Map zoom for scale-dependent sources such as clustering. Fractional values are allowed. */
+  zoom?: number;
+  /** Layers to render */
+  layers: string | string[];
+  /** bounding box on the map (only return features within this bbox) */
+  boundingBox: [min: [x: number, y: number], max: [x: number, y: number]];
+  /** CRS for returned feature coordinates. */
+  crs?: CRSIdentifier;
+  /** CRS in which `boundingBox` is expressed. Defaults to the service's native request CRS. */
+  requestCrs?: CRSIdentifier;
+  /**
+   * Requested feature encoding for the returned table.
+   * `arrow` returns a loaders.gl `ArrowTable` with `shape: 'arrow-table'`.
+   */
+  format?: 'geojson' | 'binary' | 'arrow';
+  /** Preferred GeoArrow encoding when `format` is `arrow`. */
+  geoarrow?: {encodingPreference?: GeoArrowEncodingPreference};
+  /** Abort signal for canceling in-flight requests. */
+  signal?: AbortSignal;
+};

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

@@ -0,0 +1,29 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {
+  Schema,
+  Feature,
+  GeoJSONTable,
+  BinaryFeatureCollection,
+  ArrowTable
+} from '@loaders.gl/core/schema';
+import {TileSource, TileSourceProps, GetTileParameters} from './tile-source';
+import type {GetTileDataParameters} from './tile-source';
+
+export type VectorTile = Feature[] | GeoJSONTable | BinaryFeatureCollection | ArrowTable;
+
+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 extends TileSource {
+  getSchema(): Promise<Schema>;
+  getVectorTile(parameters: GetTileParameters): Promise<VectorTile | null>;
+  getTileData(
+    parameters: GetTileDataParameters
+  ): Promise<Feature[] | GeoJSONTable | BinaryFeatureCollection | ArrowTable | null>;
+}

package/src/loader-utils/lib/sources/xyz-grid.ts

@@ -0,0 +1,82 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GetTileParameters, TileGrid, TileGridMatrix} from './tile-source';
+import {createTileGrid, getRequestedTileMatrix} from './tile-grid';
+
+/** Half the circumference of the EPSG:3857 projected world, in metres. */
+const WEB_MERCATOR_HALF_WORLD = 20037508.342789244;
+
+/**
+ * Creates the canonical XYZ world grid for an explicitly established Web Mercator source.
+ * `tileSize` defines the logical pixel frame, independently of encoded raster size or vector extent.
+ */
+export function createWebMercatorTileGrid(
+  minZoom: number,
+  maxZoom: number,
+  tileSize = 256
+): TileGrid {
+  if (
+    !Number.isInteger(minZoom) ||
+    !Number.isInteger(maxZoom) ||
+    minZoom < 0 ||
+    maxZoom < minZoom ||
+    maxZoom > 31 ||
+    !Number.isSafeInteger(tileSize) ||
+    tileSize <= 0
+  ) {
+    throw new RangeError('XYZ grids require integer zooms 0–31 and a positive integer tile size.');
+  }
+  return createTileGrid(
+    'EPSG:3857',
+    Array.from({length: maxZoom - minZoom + 1}, (_, index): TileGridMatrix => {
+      const zoom = minZoom + index;
+      const count = 2 ** zoom;
+      return {
+        id: String(zoom),
+        resolution: (WEB_MERCATOR_HALF_WORLD * 2) / (tileSize * count),
+        origin: [-WEB_MERCATOR_HALF_WORLD, WEB_MERCATOR_HALF_WORLD],
+        tileSize: [tileSize, tileSize],
+        matrixSize: [count, count]
+      };
+    })
+  );
+}
+
+/** Resolves a canonical XYZ matrix identifier/index and rejects coordinates outside its world. */
+export function resolveXYZTileParameters(
+  grid: TileGrid | undefined,
+  parameters: GetTileParameters
+): GetTileParameters | null {
+  if (!grid?.matrices) {
+    if (parameters.tileMatrix !== undefined)
+      throw new RangeError('Tile matrix selection requires an established XYZ grid.');
+    return parameters;
+  }
+  const matrix = getRequestedTileMatrix(grid.matrices, level => level.id, parameters);
+  if (!matrix) return null;
+  const size = matrix.matrixSize;
+  const zoom = Number(matrix.id);
+  if (
+    !size ||
+    !Number.isInteger(zoom) ||
+    zoom < 0 ||
+    zoom > 31 ||
+    String(zoom) !== matrix.id ||
+    size[0] !== 2 ** zoom ||
+    size[1] !== 2 ** zoom
+  ) {
+    throw new RangeError('XYZ matrices require canonical zoom IDs and world dimensions.');
+  }
+  if (
+    !Number.isSafeInteger(parameters.x) ||
+    !Number.isSafeInteger(parameters.y) ||
+    parameters.x < 0 ||
+    parameters.y < 0 ||
+    parameters.x >= size[0] ||
+    parameters.y >= size[1]
+  )
+    return null;
+  return {...parameters, z: zoom, tileMatrix: matrix.id};
+}

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

@@ -0,0 +1,233 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/* eslint-disable no-restricted-globals */
+import type {CoreAPI} from '../sources/data-source';
+import type {LoaderWithParser, LoaderOptions, LoaderContext, Loader} from '../../loader-types';
+import {createWorker} from '@loaders.gl/core/worker-utils';
+// import {validateLoaderVersion} from './validate-loader-version';
+
+/**
+ * Set up a WebWorkerGlobalScope to talk with the main thread
+ * @param loader
+ * @param selectLoader Selects the parser used for each worker request.
+ */
+export async function createLoaderWorker(
+  loader: LoaderWithParser,
+  selectLoader: (options: {[key: string]: any}) => LoaderWithParser = () => loader
+) {
+  await createWorker(
+    (input, options, workerContext, loaderContext) =>
+      processLoaderWorkerData(
+        selectLoader(options || {}),
+        input,
+        options,
+        workerContext,
+        loaderContext
+      ),
+    (inputIterator, options, workerContext, loaderContext) =>
+      processLoaderWorkerBatches(
+        selectLoader(options || {}),
+        inputIterator,
+        options,
+        workerContext,
+        loaderContext
+      )
+  );
+}
+
+/** Processes one loader request using the same context installed inside a worker. */
+export async function processLoaderWorkerData(
+  loader: LoaderWithParser,
+  input: ArrayBuffer,
+  options: {[key: string]: any} = {},
+  workerContext?: {
+    process?: (data: any, options?: LoaderOptions, context?: Record<string, any>) => any;
+  },
+  loaderContext: Record<string, any> = {}
+) {
+  const result = await parseData({
+    loader,
+    arrayBuffer: input,
+    options,
+    context: {
+      ...loaderContext,
+      coreApi: createWorkerCoreApi(),
+      _parse: createParseOnMainThread(workerContext?.process)
+    } as LoaderContext
+  });
+
+  return loader.serializeWorkerResult
+    ? loader.serializeWorkerResult(result, options, loaderContext as LoaderContext)
+    : result;
+}
+
+/** Processes a complete input stream using the loader's stateful batch parser. */
+export async function* processLoaderWorkerBatches(
+  loader: LoaderWithParser,
+  inputIterator:
+    | AsyncIterable<ArrayBufferLike | ArrayBufferView>
+    | Iterable<ArrayBufferLike | ArrayBufferView>,
+  options: {[key: string]: any} = {},
+  workerContext?: {
+    process?: (data: any, options?: LoaderOptions, context?: Record<string, any>) => any;
+  },
+  loaderContext: Record<string, any> = {}
+): AsyncIterable<unknown> {
+  if (!loader.parseInBatches) {
+    throw new Error(`${loader.id} loader does not support batched parsing`);
+  }
+
+  const resultIterator = loader.parseInBatches(inputIterator, options, {
+    ...loaderContext,
+    coreApi: createWorkerCoreApi(),
+    _parse: createParseOnMainThread(workerContext?.process)
+  } as LoaderContext);
+
+  for await (const batch of resultIterator) {
+    yield loader.serializeWorkerBatch
+      ? loader.serializeWorkerBatch(batch, options, loaderContext as LoaderContext)
+      : batch;
+  }
+}
+
+/**
+ * Create a minimal core API implementation available inside worker loaders.
+ */
+function createWorkerCoreApi(): CoreAPI {
+  const unavailable = (methodName: keyof CoreAPI) => () => {
+    throw new Error(`context.coreApi.${methodName} is unavailable inside worker loaders.`);
+  };
+
+  return {
+    fetchFile: async (urlOrData, fetchOptions) =>
+      await fetch(urlOrData as RequestInfo | URL, fetchOptions),
+    parseSync: unavailable('parseSync'),
+    parse: unavailable('parse'),
+    parseFile: unavailable('parseFile'),
+    parseInBatches: unavailable('parseInBatches'),
+    load: unavailable('load'),
+    loadInBatches: unavailable('loadInBatches')
+  };
+}
+
+/**
+ * Create a loader context parse callback that redirects subloader parsing to the main thread.
+ * @param processOnMainThread
+ */
+function createParseOnMainThread(
+  processOnMainThread?: (data: any, options?: LoaderOptions, context?: Record<string, any>) => any
+) {
+  return (
+    arrayBuffer: ArrayBuffer,
+    loaders?: Loader | Loader[] | LoaderOptions,
+    options?: LoaderOptions,
+    context?: LoaderContext
+  ) => {
+    if (!processOnMainThread) {
+      throw new Error('Worker not set up to parse on main thread');
+    }
+
+    const parseArguments = getMainThreadParseArguments(loaders, options, context);
+    return processOnMainThread(arrayBuffer, parseArguments.options, {
+      ...parseArguments.context,
+      ...(Array.isArray(loaders) || (loaders && isLoaderObject(loaders))
+        ? {
+            _loaderIsArray: Array.isArray(loaders),
+            _loaderIds: (Array.isArray(loaders) ? loaders : [loaders]).map(loader => loader.id)
+          }
+        : {})
+    });
+  };
+}
+
+/**
+ * Extract parse options and context from the overloaded loader context parse signature.
+ * @param loaders
+ * @param options
+ * @param context
+ */
+function getMainThreadParseArguments(
+  loaders?: Loader | Loader[] | LoaderOptions,
+  options?: LoaderOptions,
+  context?: LoaderContext
+): {options?: LoaderOptions; context?: Record<string, any>} {
+  if (options) {
+    return {options, context: getSerializableLoaderContext(context)};
+  }
+  if (Array.isArray(loaders) || (loaders && isLoaderObject(loaders))) {
+    return {options: undefined, context: getSerializableLoaderContext(context)};
+  }
+  if (loaders && !Array.isArray(loaders)) {
+    return {options: loaders};
+  }
+  return {options: undefined, context: getSerializableLoaderContext(context)};
+}
+
+/**
+ * Checks whether a value is a loader object.
+ * @param value
+ */
+function isLoaderObject(value: Loader | LoaderOptions): value is Loader {
+  return 'id' in value && 'extensions' in value;
+}
+
+/**
+ * Create a serializable loader context for a main-thread parse request.
+ * @param context
+ */
+function getSerializableLoaderContext(context?: LoaderContext) {
+  if (!context) {
+    return undefined;
+  }
+  const {fetch, loaders, coreApi, _parse, _parseSync, _parseInBatches, ...serializableContext} =
+    context;
+  return JSON.parse(JSON.stringify(serializableContext));
+}
+
+// TODO - Support byteOffset and byteLength (enabling parsing of embedded binaries without copies)
+// TODO - Why not support async loader.parse* funcs here?
+// TODO - Why not reuse a common function instead of reimplementing loader.parse* selection logic? Keeping loader small?
+// TODO - Lack of appropriate parser functions can be detected when we create worker, no need to wait until parse
+async function parseData({
+  loader,
+  arrayBuffer,
+  options,
+  context
+}: {
+  loader: LoaderWithParser;
+  arrayBuffer: ArrayBuffer;
+  options: LoaderOptions;
+  context: LoaderContext;
+}) {
+  let data;
+  let parser;
+  if (loader.parse || loader.parseSync) {
+    data = arrayBuffer;
+    parser = loader.parse || loader.parseSync;
+  } else if (loader.parseTextSync) {
+    const textDecoder = new TextDecoder();
+    data = textDecoder.decode(arrayBuffer);
+    parser = loader.parseTextSync;
+  } else {
+    throw new Error(`Could not load data with ${loader.name} loader`);
+  }
+
+  // Preserve worker-supplied module overrides (for example a caller-provided
+  // Draco URL) while still applying the loader's defaults. Functions cannot be
+  // structured-cloned, but URL strings and other serializable options can.
+  options = {
+    ...options,
+    modules: {
+      ...((loader && loader.options && loader.options.modules) || {}),
+      ...(options.modules || {})
+    },
+    core: {
+      ...options.core,
+      worker: false
+    }
+  };
+
+  return await parser(data, {...options}, context, loader);
+}