@loaders.gl/services 5.0.0-alpha.6 → 5.0.0-alpha.8

package/src/arcgis/arcgis-scene-server-source-loader.ts

@@ -1,258 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {CoreAPI, DataSourceOptions, SourceLoader} from '@loaders.gl/loader-utils';
-import {DataSource} from '@loaders.gl/loader-utils';
-import {
-  createI3SLayerSource,
-  normalizeI3SServiceMetadata,
-  parseI3SSceneLayerMetadata
-} from '@loaders.gl/i3s';
-import type {I3SLayerSource, I3SServiceMetadata, SceneLayer3D} from '@loaders.gl/i3s';
-import {buildArcGISResourceURL} from './arcgis-url-utils';
-
-/** Parameters accepted by the ArcGIS SceneServer query endpoint. */
-export type ArcGISSceneQueryOptions = {
-  /** SQL where clause. */
-  where?: string;
-  /** Object IDs to include. */
-  objectIds?: number[] | string;
-  /** Geometry filter encoded using ArcGIS REST geometry syntax. */
-  geometry?: unknown;
-  /** Geometry type for the geometry filter. */
-  geometryType?: string;
-  /** Spatial relationship for the geometry filter. */
-  spatialRel?: string;
-  /** Fields to return. */
-  outFields?: string | string[];
-  /** Whether feature geometry should be included. */
-  returnGeometry?: boolean;
-  /** Input spatial reference. */
-  inSR?: string | number | object;
-  /** Output spatial reference. */
-  outSR?: string | number | object;
-  /** ArcGIS result type. */
-  resultType?: string;
-  /** Result page offset. */
-  resultOffset?: number;
-  /** Maximum records in one page. */
-  resultRecordCount?: number;
-  /** Response format. */
-  f?: 'json' | 'pjson';
-  /** Abort signal for the request. */
-  signal?: AbortSignal;
-};
-
-/** Normalized result returned by a SceneServer query. */
-export type ArcGISSceneQueryResult = {
-  /** Returned SceneServer features. */
-  features: unknown[];
-  /** Field metadata advertised by the layer. */
-  fields?: unknown[];
-  /** Whether another page is available. */
-  exceededTransferLimit?: boolean;
-  /** Original response metadata for advanced consumers. */
-  rawMetadata?: unknown;
-};
-
-/** Error raised when a SceneServer query cannot be completed or decoded. */
-export class ArcGISSceneServerQueryError extends Error {
-  /** HTTP status code, when the failure came from a response. */
-  readonly status?: number;
-
-  /** Creates a typed SceneServer query error. */
-  constructor(message: string, status?: number) {
-    super(message);
-    this.name = 'ArcGISSceneServerQueryError';
-    this.status = status;
-  }
-}
-
-/** Options for an ArcGIS SceneServer source. */
-export type ArcGISSceneServerSourceOptions = DataSourceOptions & {
-  'arcgis-scene-server'?: {
-    /** Layer identifier used when the input URL ends at `/SceneServer`. */
-    layerId?: number | string;
-    /** ArcGIS token applied to metadata and tile-resource requests. */
-    token?: string;
-    /** Optional metadata document for offline or preloaded use. */
-    metadata?: unknown;
-  };
-};
-
-/** Source facade for an ArcGIS SceneServer I3S layer. */
-export class ArcGISSceneServerSource extends DataSource<string, ArcGISSceneServerSourceOptions> {
-  /** Cached normalized layer metadata. */
-  private metadataPromise: Promise<I3SServiceMetadata> | null = null;
-  /** Cached profile-specific tileset source. */
-  private sourcePromise: Promise<I3SLayerSource> | null = null;
-
-  /** Creates a SceneServer source. */
-  constructor(url: string, options: ArcGISSceneServerSourceOptions = {}, coreApi?: CoreAPI) {
-    super(url.replace(/\/+$/, ''), options, ArcGISSceneServerSourceLoader.defaultOptions, coreApi);
-  }
-
-  /** Returns normalized SceneServer layer metadata. */
-  async getMetadata(): Promise<I3SServiceMetadata> {
-    this.metadataPromise ||= this.loadMetadata();
-    return await this.metadataPromise;
-  }
-
-  /** Creates the existing mesh or Point Cloud source for this layer. */
-  async getTilesetSource(): Promise<I3SLayerSource> {
-    this.sourcePromise ||= this.createTilesetSource();
-    return await this.sourcePromise;
-  }
-
-  /** Queries feature attributes and geometry from a SceneServer layer. */
-  async query(options: ArcGISSceneQueryOptions = {}): Promise<ArcGISSceneQueryResult> {
-    const {signal, f = 'json', ...queryParameters} = options;
-    const queryURL = buildArcGISResourceURL(this.getLayerURL(), 'query', {
-      where: '1=1',
-      outFields: '*',
-      returnGeometry: true,
-      f,
-      ...queryParameters,
-      token: this.getToken()
-    });
-    const response = await this.fetch(queryURL, signal ? {signal} : undefined);
-    if (!response.ok) {
-      throw new ArcGISSceneServerQueryError(
-        `ArcGIS SceneServer query failed: ${response.status} ${response.statusText}`,
-        response.status
-      );
-    }
-    const document = (await response.json()) as Record<string, unknown>;
-    if (document.error) {
-      throw new ArcGISSceneServerQueryError(
-        `ArcGIS SceneServer query returned an error: ${JSON.stringify(document.error)}`
-      );
-    }
-    return {
-      features: Array.isArray(document.features) ? document.features : [],
-      fields: Array.isArray(document.fields) ? document.fields : undefined,
-      exceededTransferLimit:
-        typeof document.exceededTransferLimit === 'boolean'
-          ? document.exceededTransferLimit
-          : undefined,
-      rawMetadata: document
-    };
-  }
-
-  /** Alias for query used by applications that consume generic feature sources. */
-  async getFeatures(options: ArcGISSceneQueryOptions = {}): Promise<ArcGISSceneQueryResult> {
-    return await this.query(options);
-  }
-
-  /** Returns the layer URL, resolving an explicit layer ID when needed. */
-  getLayerURL(): string {
-    const url = new URL(this.url);
-    url.pathname = url.pathname.replace(/\/+$/, '');
-    if (/\/SceneServer\/layers\/[^/]+$/i.test(url.pathname)) {
-      url.search = '';
-      url.hash = '';
-      return url.toString();
-    }
-
-    if (!/\/SceneServer$/i.test(url.pathname)) {
-      throw new Error(
-        'ArcGISSceneServerSource requires a /SceneServer/layers/{id} URL or a /SceneServer URL with arcgis-scene-server.layerId'
-      );
-    }
-
-    const layerId = this.options['arcgis-scene-server']?.layerId;
-    if (layerId === undefined) {
-      throw new Error(
-        'ArcGISSceneServerSource requires a /SceneServer/layers/{id} URL or a /SceneServer URL with arcgis-scene-server.layerId'
-      );
-    }
-    url.pathname = `${url.pathname.replace(/\/$/, '')}/layers/${encodeURIComponent(String(layerId))}`;
-    url.search = '';
-    url.hash = '';
-    return url.toString();
-  }
-
-  /** Returns the metadata request URL with ArcGIS JSON and authentication parameters. */
-  metadataURL(): string {
-    const url = new URL(this.getLayerURL());
-    url.searchParams.set('f', 'pjson');
-    const token = this.getToken();
-    if (token && !url.searchParams.has('token')) {
-      url.searchParams.set('token', token);
-    }
-    return url.toString();
-  }
-
-  private async loadMetadata(): Promise<I3SServiceMetadata> {
-    const configuredMetadata = this.options['arcgis-scene-server']?.metadata;
-    const layer = configuredMetadata
-      ? parseI3SSceneLayerMetadata(configuredMetadata)
-      : await this.fetchLayerMetadata();
-    return normalizeI3SServiceMetadata(this.getLayerURL(), layer);
-  }
-
-  private async fetchLayerMetadata(): Promise<SceneLayer3D> {
-    const response = await this.fetch(this.metadataURL());
-    if (!response.ok) {
-      throw new Error(
-        `ArcGIS SceneServer metadata request failed: ${response.status} ${response.statusText}`
-      );
-    }
-    return parseI3SSceneLayerMetadata(await response.json());
-  }
-
-  private async createTilesetSource(): Promise<I3SLayerSource> {
-    const metadata = await this.getMetadata();
-    return createI3SLayerSource(
-      metadata.url,
-      metadata.layer,
-      this.getSourceOptions(),
-      this.coreApi
-    );
-  }
-
-  private getSourceOptions(): DataSourceOptions {
-    const i3sOptions = (this.options['i3s'] as Record<string, unknown> | undefined) || {};
-    const token = this.getToken();
-    return {
-      ...this.options,
-      i3s: token ? {...i3sOptions, token} : i3sOptions
-    };
-  }
-
-  private getToken(): string | undefined {
-    const serviceToken = this.options['arcgis-scene-server']?.token;
-    const i3sToken = (this.options['i3s'] as Record<string, unknown> | undefined)?.token;
-    if (serviceToken) {
-      return serviceToken;
-    }
-    if (typeof i3sToken === 'string' && i3sToken) {
-      return i3sToken;
-    }
-    return new URL(this.url).searchParams.get('token') || undefined;
-  }
-}
-
-/** Source loader for ArcGIS SceneServer I3S layers. */
-export const ArcGISSceneServerSourceLoader = {
-  dataType: null as unknown as ArcGISSceneServerSource,
-  batchType: null as never,
-  name: 'ArcGIS SceneServer',
-  id: 'arcgis-scene-server',
-  module: 'services',
-  version: '0.0.0',
-  extensions: [],
-  mimeTypes: ['application/json'],
-  type: 'arcgis-scene-server',
-  fromUrl: true,
-  fromBlob: false,
-  options: {'arcgis-scene-server': {}},
-  defaultOptions: {'arcgis-scene-server': {}},
-  testURL: (url: string): boolean => /\/SceneServer(?:[\/?#]|$)/i.test(url),
-  createDataSource: (
-    url: string,
-    options: ArcGISSceneServerSourceOptions = {},
-    coreApi?: CoreAPI
-  ) => new ArcGISSceneServerSource(url, options, coreApi)
-} as const satisfies SourceLoader<ArcGISSceneServerSource>;

package/src/arcgis/arcgis-server.ts

@@ -1,61 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-export type Service = {name: string; type: string; url: string};
-
-type FetchLike = typeof fetch;
-
-/**
- * (Recursively) load the service directory from an ArcGIS Server URL
- * @param url
- * @param fetchFile= Optional fetch function override
- * @returns
- */
-export async function getArcGISServices(
-  url: string,
-  fetchFile: FetchLike = fetch
-): Promise<Service[] | null> {
-  if (url.includes('rest/services')) {
-    const serverUrl = url.replace(/rest\/services.*$/i, 'rest/services');
-    return loadServiceDirectory(serverUrl, fetchFile, []);
-  }
-  return null;
-}
-
-async function loadServiceDirectory(
-  serverUrl: string,
-  fetch: FetchLike,
-  path: string[]
-): Promise<Service[]> {
-  const serviceUrl = path.length ? `${serverUrl}/${path.join('/')}` : serverUrl;
-
-  const response = await fetch(`${serviceUrl}?f=pjson`);
-  const directory = await response.json();
-
-  const services = extractServices(directory, serviceUrl, serverUrl);
-
-  const folders = (directory.folders || []) as string[];
-  const promises = folders.map(folder =>
-    loadServiceDirectory(`${serverUrl}`, fetch, [...path, folder])
-  );
-
-  for (const folderServices of await Promise.all(promises)) {
-    services.push(...folderServices);
-  }
-
-  return services;
-}
-
-function extractServices(directory: unknown, url: string, serverUrl: string): Service[] {
-  const arcgisServices = ((directory as any).services || []) as {name: string; type: string}[];
-  const services: Service[] = [];
-  for (const service of arcgisServices) {
-    services.push({
-      name: service.name,
-      type: `arcgis-${service.type.toLocaleLowerCase().replace('server', '-server')}`,
-      url: `${service.name.includes('/') ? serverUrl : url}/${service.name}/${service.type}`
-    });
-  }
-  return services;
-}

package/src/arcgis/arcgis-url-utils.ts

@@ -1,26 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/** Builds an ArcGIS REST resource URL while preserving authentication query parameters. */
-export function buildArcGISResourceURL(
-  serviceURL: string,
-  resourcePath: string,
-  parameters: Record<string, unknown>
-): string {
-  const url = new URL(serviceURL);
-  if (resourcePath) {
-    url.pathname = `${url.pathname.replace(/\/$/, '')}/${resourcePath.replace(/^\//, '')}`;
-  }
-  for (const [key, value] of Object.entries(parameters)) {
-    if (value === undefined || value === null) continue;
-    url.searchParams.set(key, encodeArcGISParameter(value));
-  }
-  return url.toString();
-}
-
-/** Converts a generic request value to ArcGIS REST query syntax. */
-function encodeArcGISParameter(value: unknown): string {
-  if (Array.isArray(value)) return value.join(',');
-  return typeof value === 'object' ? JSON.stringify(value) : String(value);
-}

package/src/arcgis/arcgis-vector-tile-server-source-loader.ts

@@ -1,233 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {
-  CoreAPI,
-  DataSourceOptions,
-  GetTileDataParameters,
-  GetTileParameters,
-  SourceLoader,
-  TileSourceMetadata,
-  VectorTile,
-  VectorTileSource
-} from '@loaders.gl/loader-utils';
-import {DataSource} from '@loaders.gl/loader-utils';
-import {MVTLoader, type MVTLoaderOptions} from '@loaders.gl/mvt';
-import type {Schema} from '@loaders.gl/schema';
-
-/** ArcGIS vector tile service metadata. */
-export type ArcGISVectorTileServiceMetadata = {
-  /** Human-readable service description. */
-  serviceDescription?: string;
-  /** Map name exposed by the service. */
-  mapName?: string;
-  /** Tile grid information. */
-  tileInfo?: {
-    /** Tile width in pixels. */
-    cols?: number;
-    /** Tile height in pixels. */
-    rows?: number;
-    /** Tile format, normally pbf. */
-    format?: string;
-    /** Tile origin. */
-    origin?: {x: number; y: number};
-    /** Tile grid spatial reference. */
-    spatialReference?: {wkid?: number; latestWkid?: number};
-    /** Levels of detail. */
-    lods?: Array<{level: number; resolution: number; scale?: number}>;
-  };
-  /** Full service extent. */
-  fullExtent?: {xmin: number; ymin: number; xmax: number; ymax: number};
-  /** Initial service extent. */
-  initialExtent?: {xmin: number; ymin: number; xmax: number; ymax: number};
-};
-
-/** Options for the ArcGIS VectorTileServer source. */
-export type ArcGISVectorTileServerSourceLoaderOptions = DataSourceOptions & {
-  'arcgis-vector-tile-server'?: {
-    /** Optional MVT parser options. */
-    mvt?: MVTLoaderOptions['mvt'];
-  };
-};
-
-/** A source for ArcGIS VectorTileServer metadata and PBF tiles. */
-export class ArcGISVectorTileServerSource
-  extends DataSource<string, ArcGISVectorTileServerSourceLoaderOptions>
-  implements VectorTileSource
-{
-  /** Decoded tile family consumed by generic tile renderers. */
-  readonly mimeType = 'application/vnd.mapbox-vector-tile';
-  /** ArcGIS tiles are decoded to WGS84 coordinates before rendering. */
-  readonly localCoordinates = false;
-  /** Cached service metadata request. */
-  private serviceMetadata: Promise<ArcGISVectorTileServiceMetadata> | null = null;
-  /** Query parameters supplied with the service URL, such as an access token. */
-  private readonly serviceQueryParameters: URLSearchParams;
-
-  /** Creates an ArcGIS VectorTileServer source. */
-  constructor(
-    url: string,
-    options: ArcGISVectorTileServerSourceLoaderOptions = {},
-    coreApi?: CoreAPI
-  ) {
-    const serviceURL = new URL(url);
-    serviceURL.pathname = serviceURL.pathname.replace(/\/$/, '');
-    super(
-      `${serviceURL.origin}${serviceURL.pathname}`,
-      options,
-      ArcGISVectorTileServerSourceLoader.defaultOptions,
-      coreApi
-    );
-    this.serviceQueryParameters = new URLSearchParams(serviceURL.search);
-  }
-
-  /** Returns normalized service and tile-grid metadata. */
-  async getMetadata(): Promise<TileSourceMetadata> {
-    const metadata = await this.getServiceMetadata();
-    const tileInfo = metadata.tileInfo;
-    const lods = tileInfo?.lods || [];
-    const extent = metadata.fullExtent || metadata.initialExtent;
-    return {
-      name: metadata.mapName || this.url.split('/').pop() || '',
-      title: metadata.mapName,
-      abstract: metadata.serviceDescription,
-      format: 'application/vnd.mapbox-vector-tile',
-      minZoom: lods[0]?.level,
-      maxZoom: lods.at(-1)?.level,
-      boundingBox: extent
-        ? [
-            [extent.xmin, extent.ymin],
-            [extent.xmax, extent.ymax]
-          ]
-        : undefined,
-      layer: {
-        name: metadata.mapName || '',
-        srs: tileInfo?.spatialReference ? [getSpatialReference(tileInfo.spatialReference)] : [],
-        layers: []
-      },
-      formatHeader: {
-        tileInfo,
-        styleURL: this.getStyleURL(),
-        spriteURL: this.getSpriteURL()
-      }
-    };
-  }
-
-  /** Fetches one raw PBF tile from the ArcGIS tile endpoint. */
-  async getTile(parameters: GetTileParameters, signal?: AbortSignal): Promise<ArrayBuffer | null> {
-    const response = await this.fetch(this.getTileURL(parameters), {
-      signal,
-      headers: {Accept: 'application/vnd.mapbox-vector-tile, application/x-protobuf'}
-    });
-    if (!response.ok) return null;
-    return response.arrayBuffer();
-  }
-
-  /** Returns the schema advertised by decoded vector tiles. */
-  async getSchema(): Promise<Schema> {
-    return {fields: [], metadata: {}};
-  }
-
-  /** Fetches and decodes one ArcGIS vector tile to geographic coordinates. */
-  async getVectorTile(parameters: GetTileParameters): Promise<VectorTile | null> {
-    const arrayBuffer = await this.getTile(parameters, parameters.signal);
-    if (!arrayBuffer) {
-      return null;
-    }
-    const inheritedOptions = (this.loadOptions as MVTLoaderOptions).mvt;
-    const sourceOptions = this.options['arcgis-vector-tile-server']?.mvt;
-    return (await this.coreApi.parse(arrayBuffer, MVTLoader, {
-      ...this.loadOptions,
-      mvt: {
-        ...inheritedOptions,
-        ...sourceOptions,
-        coordinates: 'wgs84',
-        tileIndex: {x: parameters.x, y: parameters.y, z: parameters.z},
-        layers:
-          normalizeLayers(parameters.layers) || sourceOptions?.layers || inheritedOptions?.layers
-      }
-    })) as VectorTile;
-  }
-
-  /** Provides decoded vector tiles through the deck.gl source interface. */
-  async getTileData(parameters: GetTileDataParameters): Promise<VectorTile | null> {
-    return this.getVectorTile({...parameters.index, signal: parameters.signal});
-  }
-
-  /** Builds the ArcGIS cached vector tile URL. */
-  getTileURL(parameters: GetTileParameters): string {
-    return this.getResourceURL(`/tile/${parameters.z}/${parameters.y}/${parameters.x}.pbf`);
-  }
-
-  /** Returns the service metadata URL. */
-  getMetadataURL(): string {
-    const url = new URL(this.getResourceURL(''));
-    url.searchParams.set('f', 'pjson');
-    return url.toString();
-  }
-
-  /** Returns the ArcGIS Mapbox style resource URL. */
-  getStyleURL(): string {
-    return this.getResourceURL('/resources/styles/root.json');
-  }
-
-  /** Returns the ArcGIS sprite resource base URL. */
-  getSpriteURL(): string {
-    return this.getResourceURL('/resources/sprites/sprite');
-  }
-
-  /** Loads and caches the ArcGIS VectorTileServer metadata document. */
-  private async getServiceMetadata(): Promise<ArcGISVectorTileServiceMetadata> {
-    this.serviceMetadata ||= this.fetch(this.getMetadataURL()).then(async response => {
-      if (!response.ok)
-        throw new Error(`ArcGIS VectorTileServer request failed: ${response.status}`);
-      return (await response.json()) as ArcGISVectorTileServiceMetadata;
-    });
-    return this.serviceMetadata;
-  }
-
-  /** Builds a resource URL while retaining service query parameters. */
-  private getResourceURL(resourcePath: string): string {
-    const url = new URL(this.url);
-    url.pathname = `${url.pathname.replace(/\/$/, '')}${resourcePath}`;
-    for (const [key, value] of this.serviceQueryParameters) {
-      url.searchParams.set(key, value);
-    }
-    return url.toString();
-  }
-}
-
-/** Source loader for ArcGIS VectorTileServer services. */
-export const ArcGISVectorTileServerSourceLoader = {
-  dataType: null as unknown as ArcGISVectorTileServerSource,
-  batchType: null as never,
-  name: 'ArcGIS VectorTileServer',
-  id: 'arcgis-vector-tile-server',
-  module: 'services',
-  version: '0.0.0',
-  extensions: [],
-  mimeTypes: ['application/vnd.mapbox-vector-tile', 'application/x-protobuf'],
-  type: 'arcgis-vector-tile-server',
-  fromUrl: true,
-  fromBlob: false,
-  options: {'arcgis-vector-tile-server': {}},
-  defaultOptions: {'arcgis-vector-tile-server': {}},
-  testURL: (url: string): boolean => /\/vectortileserver(?:[\/?#]|$)/i.test(url),
-  createDataSource: (
-    url: string,
-    options: ArcGISVectorTileServerSourceLoaderOptions = {},
-    coreApi?: CoreAPI
-  ) => new ArcGISVectorTileServerSource(url, options, coreApi)
-} as const satisfies SourceLoader<ArcGISVectorTileServerSource>;
-
-/** Converts an ArcGIS spatial reference to an EPSG identifier. */
-function getSpatialReference(spatialReference: {wkid?: number; latestWkid?: number}): string {
-  return `EPSG:${spatialReference.latestWkid || spatialReference.wkid}`;
-}
-
-/** Normalizes generic tile layer selection for the MVT parser. */
-function normalizeLayers(layers?: string | string[]): string[] | undefined {
-  if (!layers) return undefined;
-  return Array.isArray(layers) ? layers : [layers];
-}

package/src/service-registry.ts

@@ -1,43 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {ArcGISFeatureServerSourceLoader} from './arcgis/arcgis-feature-server-source-loader';
-import {ArcGISImageServerSourceLoader} from './arcgis/arcgis-image-server-source-loader';
-import {ArcGISImageTileSourceLoader} from './arcgis/arcgis-image-tile-source-loader';
-import {ArcGISMapTileSourceLoader} from './arcgis/arcgis-map-tile-source-loader';
-import {ArcGISSceneServerSourceLoader} from './arcgis/arcgis-scene-server-source-loader';
-import {ArcGISVectorTileServerSourceLoader} from './arcgis/arcgis-vector-tile-server-source-loader';
-
-/** A source loader currently exposed through the services package. */
-export type ServiceLoader =
-  | typeof ArcGISFeatureServerSourceLoader
-  | typeof ArcGISImageServerSourceLoader
-  | typeof ArcGISImageTileSourceLoader
-  | typeof ArcGISMapTileSourceLoader
-  | typeof ArcGISVectorTileServerSourceLoader
-  | typeof ArcGISSceneServerSourceLoader;
-
-/** All source loaders owned by `@loaders.gl/services`, in URL-selection order. */
-export const SERVICE_LOADERS: ServiceLoader[] = [
-  ArcGISFeatureServerSourceLoader,
-  ArcGISImageServerSourceLoader,
-  ArcGISImageTileSourceLoader,
-  ArcGISMapTileSourceLoader,
-  ArcGISVectorTileServerSourceLoader,
-  ArcGISSceneServerSourceLoader
-];
-
-/**
- * Finds a service loader by its canonical loader id or service type.
- *
- * The lookup is intentionally small and explicit. It provides discovery without
- * introducing a second request lifecycle or hiding provider-specific options.
- */
-export function getServiceLoader(serviceType: string): ServiceLoader | undefined {
-  const normalizedServiceType = serviceType.toLowerCase();
-  return SERVICE_LOADERS.find(
-    serviceLoader =>
-      serviceLoader.id === normalizedServiceType || serviceLoader.type === normalizedServiceType
-  );
-}