@loaders.gl/tiles 5.0.0-alpha.11 → 5.0.0-alpha.13

package/src/point-cloud/types.ts

@@ -1,99 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {DataSource, DataSourceOptions} from '@loaders.gl/loader-utils';
-import type {MeshArrowTable} from '@loaders.gl/schema';
-import type {TilesetSpatialReference} from '../spatial/spatial-types';
-
-/**
- * An accessor-like description for point cloud attributes.
- */
-export type PointCloudAttribute = {
-  value: ArrayBufferView;
-  size: number;
-  normalized?: boolean;
-};
-
-/**
- * deck.gl coordinate system string values accepted by point cloud tile content.
- */
-export type PointCloudCoordinateSystem =
-  | 'default'
-  | 'lnglat'
-  | 'meter-offsets'
-  | 'lnglat-offsets'
-  | 'cartesian';
-
-/**
- * A normalized point cloud tile content payload.
- */
-export type PointCloudTileContent = {
-  data: MeshArrowTable;
-  pointCount: number;
-  cartographicOrigin: number[];
-  coordinateSystem: PointCloudCoordinateSystem;
-  constantRGBA?: number[];
-  modelMatrix?: number[] | Float32Array;
-  /** Spatial descriptor for returned points, origins, and bounds. */
-  spatialReference?: TilesetSpatialReference;
-  /** Content bound expressed in the selected spatial output frame. */
-  spatialBoundingVolume?: PointCloudBoundingVolume;
-};
-
-/**
- * A cartographic bounding volume for a point cloud tile.
- */
-export type PointCloudBoundingVolume = {
-  cartographicBounds: [min: number[], max: number[]];
-  /** True when the longitude interval crosses the antimeridian. */
-  wrapsDateline?: boolean;
-  /** True when the longitude interval covers the full globe. */
-  coversFullLongitude?: boolean;
-  center: number[];
-  radius: number;
-  /** Broad coordinate frame of `center` and `cartographicBounds`. */
-  coordinateFrame?: 'geographic' | 'cartesian';
-};
-
-/**
- * A source-owned tile header used by the point cloud tileset.
- */
-export type PointCloudTileHeader = {
-  id: string;
-  level: number;
-  pointCount: number;
-  geometricError: number;
-  boundingVolume: PointCloudBoundingVolume;
-  /** Bound expressed in the selected content/output frame; traversal retains geographic bounds. */
-  spatialBoundingVolume?: PointCloudBoundingVolume;
-  /** I3S LOD metric used to decide whether this node refines. */
-  lodSelectionMetricType?: 'maxScreenThresholdSQ' | 'density-threshold';
-  /** Source-provided LOD threshold for density or screen metrics. */
-  lodThreshold?: number;
-};
-
-/**
- * Optional tileset view metadata.
- */
-export type PointCloudTilesetViewState = {
-  cartographicCenter?: number[];
-  zoom?: number;
-  boundingVolume?: PointCloudBoundingVolume;
-};
-
-/**
- * Structural contract for point cloud sources that can back a PointCloudTileset.
- */
-export type PointCloudTilesetSource<
-  DataT = unknown,
-  OptionsT extends DataSourceOptions = DataSourceOptions
-> = DataSource<DataT, OptionsT> & {
-  isReady: boolean;
-  initialize(): Promise<void>;
-  getMetadata?(): Promise<unknown>;
-  getRootTile(): Promise<PointCloudTileHeader>;
-  getChildren(tile: PointCloudTileHeader): Promise<PointCloudTileHeader[]>;
-  loadTileContent(tile: PointCloudTileHeader): Promise<PointCloudTileContent | null>;
-  getViewState?(): Promise<PointCloudTilesetViewState> | PointCloudTilesetViewState;
-};

package/src/spatial/format-spatial-reference.ts

@@ -1,385 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import type {ReadonlyCRSDefinition} from '@math.gl/crs';
-import {getI3SLinearUnitScale, getI3SVerticalUnitScale} from './i3s-elevation';
-import {
-  getKnownCrsIdentifierCoordinateFrame,
-  getSpatialCoordinateFrame
-} from './get-spatial-coordinate-frame';
-import {createTilesetSpatialReference} from './spatial-types';
-import type {TilesetElevationMode, TilesetSpatialReference} from './spatial-types';
-
-/** ArcGIS/I3S spatial reference fields used without depending on the I3S package. */
-type I3SSpatialReferenceLike = {
-  wkid?: number;
-  latestWkid?: number;
-  vcsWkid?: number;
-  latestVcsWkid?: number;
-  wkt?: string;
-};
-
-/** I3S layer fields needed for spatial metadata discovery. */
-type I3SLayerLike = {
-  spatialReference?: I3SSpatialReferenceLike;
-  fullExtent?: {spatialReference?: I3SSpatialReferenceLike};
-  heightModelInfo?: {
-    heightModel?: string;
-    vertCRS?: ReadonlyCRSDefinition;
-    heightUnit?: string;
-  };
-  ZFactor?: number;
-  elevationInfo?: {mode?: string; offset?: number; unit?: string};
-};
-
-/** 3D Tiles metadata schema property used for semantic lookup. */
-type Tiles3DMetadataProperty = {semantic?: string};
-
-/** 3D Tiles document fields needed for CRS semantic discovery. */
-type Tiles3DLike = {
-  schema?: {
-    classes?: Record<string, unknown>;
-  };
-  schemaUri?: string;
-  metadata?: {class?: string; properties?: Record<string, unknown>};
-  root?: {boundingVolume?: {region?: unknown}};
-  extensions?: Record<string, unknown>;
-};
-
-/**
- * Discovers normalized spatial metadata from an I3S scene-layer document.
- *
- * I3S encodes geographic coordinates in longitude/latitude wire order even for authority
- * definitions whose formal axis order differs.
- *
- * @param layer - Parsed I3S layer document.
- * @returns Normalized source spatial metadata.
- */
-export function getI3SSpatialReference(layer: I3SLayerLike): TilesetSpatialReference {
-  const spatialReference = layer.spatialReference || layer.fullExtent?.spatialReference;
-  const sourceCrs = getI3SCrsDefinition(spatialReference);
-  const verticalCrs =
-    layer.heightModelInfo?.vertCRS || getI3SVerticalCrsDefinition(spatialReference);
-  const heightModel = layer.heightModelInfo?.heightModel;
-  const verticalUnit = layer.heightModelInfo?.heightUnit;
-  const verticalUnitScale = getI3SVerticalUnitScale(verticalUnit, layer.ZFactor);
-  const heightReference =
-    heightModel === 'ellipsoidal'
-      ? 'ellipsoidal'
-      : heightModel === 'gravity_related_height'
-        ? 'orthometric'
-        : 'unknown';
-  const sourceIdentifier = getCrsIdentifier(spatialReference);
-  const coordinateFrame =
-    sourceIdentifier === undefined
-      ? sourceCrs
-        ? getSpatialCoordinateFrame(sourceCrs)
-        : 'unknown'
-      : getSpatialCoordinateFrame(`EPSG:${sourceIdentifier}`);
-  const units = getI3SCoordinateUnits(coordinateFrame, verticalUnit, layer.ZFactor);
-  const warnings: string[] = [];
-  const elevationMode = getI3SElevationMode(layer.elevationInfo?.mode);
-  const elevationUnit = layer.elevationInfo ? layer.elevationInfo.unit || 'meter' : undefined;
-  const elevationUnitScale = getI3SLinearUnitScale(elevationUnit);
-  if (verticalUnitScale === undefined) {
-    warnings.push(
-      layer.ZFactor !== undefined
-        ? `I3S ZFactor ${layer.ZFactor} is not a positive finite conversion factor`
-        : `Unsupported I3S vertical unit ${verticalUnit}`
-    );
-  }
-  if (layer.elevationInfo && elevationUnitScale === undefined) {
-    warnings.push(`Unsupported I3S elevation unit ${elevationUnit}`);
-  }
-  if (layer.elevationInfo?.mode && !elevationMode) {
-    warnings.push(`Unsupported I3S elevation mode ${layer.elevationInfo.mode}`);
-  }
-  if (elevationMode && elevationMode !== 'absoluteHeight') {
-    warnings.push(
-      `I3S elevation mode ${elevationMode} requires a terrain or scene elevation provider`
-    );
-  }
-
-  return createTilesetSpatialReference({
-    sourceCrs,
-    sourceCrsRepresentation:
-      sourceIdentifier !== undefined ? 'identifier' : sourceCrs ? 'wkt' : undefined,
-    sourceCrsAlternatives:
-      sourceIdentifier !== undefined && spatialReference?.wkt
-        ? [{definition: spatialReference.wkt, representation: 'wkt'}]
-        : undefined,
-    verticalCrs,
-    units,
-    verticalUnitScale: verticalUnitScale ?? Number.NaN,
-    heightReference,
-    elevationMode,
-    elevationOffset: layer.elevationInfo?.offset,
-    elevationUnit,
-    elevationUnitScale:
-      layer.elevationInfo?.mode && !elevationMode
-        ? Number.NaN
-        : (elevationUnitScale ?? (layer.elevationInfo ? Number.NaN : 1)),
-    coordinateFrame,
-    axisOrder: sourceCrs ? 'xyz' : 'unknown',
-    provenance: sourceCrs ? 'metadata' : 'unknown',
-    warnings
-  });
-}
-
-/** Return per-component I3S units only when their coordinate association is unambiguous. */
-function getI3SCoordinateUnits(
-  coordinateFrame: TilesetSpatialReference['coordinateFrame'],
-  verticalUnit: string | undefined,
-  zFactor: number | undefined
-): readonly string[] | undefined {
-  if (coordinateFrame === 'geocentric') {
-    return ['meter', 'meter', 'meter'];
-  }
-  if (coordinateFrame === 'geographic' && (verticalUnit || zFactor === undefined)) {
-    return ['degree', 'degree', verticalUnit || 'meter'];
-  }
-  return undefined;
-}
-
-/** Return a supported I3S elevation mode without widening the public descriptor. */
-function getI3SElevationMode(mode: string | undefined): TilesetElevationMode | undefined {
-  switch (mode) {
-    case 'absoluteHeight':
-    case 'onTheGround':
-    case 'relativeToGround':
-    case 'relativeToScene':
-      return mode;
-    default:
-      return undefined;
-  }
-}
-
-/**
- * Discovers the 3D Tiles geocentric CRS and coordinate epoch from structured metadata semantics.
- *
- * The method intentionally does not infer ECEF from coordinate magnitude. A root `region`
- * establishes the format's global ellipsoidal frame, while local tilesets without an explicit
- * semantic remain unknown.
- *
- * @param tileset - Parsed 3D Tiles tileset document.
- * @returns Normalized source spatial metadata.
- */
-export function get3DTilesSpatialReference(tileset: Tiles3DLike): TilesetSpatialReference {
-  const draftSpatialReference = getDraft3DTilesSpatialReference(tileset);
-  if (draftSpatialReference) {
-    return draftSpatialReference;
-  }
-  const geocentricCrs = getTilesetSemanticValue(tileset, 'TILESET_CRS_GEOCENTRIC');
-  const coordinateEpoch = getTilesetSemanticValue(tileset, 'TILESET_CRS_COORDINATE_EPOCH');
-  const warnings: string[] = [];
-
-  let sourceCrs: ReadonlyCRSDefinition | undefined;
-  let provenance: TilesetSpatialReference['provenance'] = 'unknown';
-  let sourceCrsState: 'explicit' | 'default' | 'unknown' | 'absent' | undefined;
-  if (typeof geocentricCrs === 'string' && geocentricCrs.toUpperCase() !== 'UNKNOWN') {
-    sourceCrs = geocentricCrs;
-    provenance = 'metadata';
-    sourceCrsState = 'explicit';
-  } else if (geocentricCrs !== undefined) {
-    warnings.push('3D Tiles geocentric CRS is explicitly unknown');
-    provenance = 'metadata';
-    sourceCrsState = 'unknown';
-  } else if (tileset.root?.boundingVolume?.region) {
-    sourceCrs = 'EPSG:4978';
-    provenance = 'format-default';
-    sourceCrsState = 'default';
-  } else if (tileset.schemaUri && !tileset.schema) {
-    warnings.push(
-      'External 3D Tiles metadata schema must be loaded before CRS semantics can resolve'
-    );
-  }
-
-  const epoch = parseCoordinateEpoch(coordinateEpoch);
-  if (coordinateEpoch !== undefined && epoch === undefined) {
-    warnings.push('3D Tiles coordinate epoch is not a finite decimal year');
-  }
-
-  return createTilesetSpatialReference({
-    sourceCrs,
-    sourceCrsState,
-    sourceCrsRepresentation: sourceCrs ? 'identifier' : undefined,
-    coordinateEpoch: epoch,
-    heightReference: sourceCrs ? 'ellipsoidal' : 'unknown',
-    coordinateFrame: sourceCrs ? 'geocentric' : 'unknown',
-    axisOrder: sourceCrs ? 'xyz' : 'unknown',
-    provenance,
-    warnings
-  });
-}
-
-/** Resolves the draft glTF EXT_geospatial_crs WKID or WKT2 declaration. */
-function getDraft3DTilesSpatialReference(
-  tileset: Tiles3DLike
-): TilesetSpatialReference | undefined {
-  const extension = tileset.extensions?.EXT_geospatial_crs as
-    | {format?: unknown; extensions?: Record<string, unknown>}
-    | undefined;
-  if (!extension) {
-    return undefined;
-  }
-  const warnings: string[] = [];
-  let sourceCrs: ReadonlyCRSDefinition | undefined;
-  let verticalCrs: ReadonlyCRSDefinition | undefined;
-  let epoch: number | undefined;
-  let representation: 'identifier' | 'wkt' | undefined;
-  if (extension.format === 'wkid') {
-    const wkidExtension = extension.extensions?.EXT_geospatial_crs_wkid as
-      | {authority?: unknown; wkid?: unknown; vcsWkid?: unknown; epoch?: unknown}
-      | undefined;
-    if (typeof wkidExtension?.authority === 'string' && Number.isInteger(wkidExtension.wkid)) {
-      sourceCrs = `${wkidExtension.authority}:${wkidExtension.wkid}`;
-      representation = 'identifier';
-      if (Number.isInteger(wkidExtension.vcsWkid)) {
-        verticalCrs = `${wkidExtension.authority}:${wkidExtension.vcsWkid}`;
-      }
-      epoch = parseCoordinateEpoch(wkidExtension.epoch);
-      if (wkidExtension.epoch !== undefined && epoch === undefined) {
-        warnings.push('EXT_geospatial_crs_wkid epoch is not a finite decimal year');
-      }
-    } else {
-      warnings.push('EXT_geospatial_crs_wkid requires string authority and integer wkid');
-    }
-  } else if (extension.format === 'wkt2') {
-    const wktExtension = extension.extensions?.EXT_geospatial_crs_wkt2 as
-      | {wkt2?: unknown}
-      | undefined;
-    if (typeof wktExtension?.wkt2 === 'string' && wktExtension.wkt2.trim()) {
-      sourceCrs = wktExtension.wkt2;
-      representation = 'wkt';
-    } else {
-      warnings.push('EXT_geospatial_crs_wkt2 requires a nonempty wkt2 string');
-    }
-  } else {
-    warnings.push(`Unsupported EXT_geospatial_crs format ${String(extension.format)}`);
-  }
-  const coordinateFrame =
-    representation === 'wkt'
-      ? getSpatialCoordinateFrame(sourceCrs as string)
-      : getKnownCrsIdentifierCoordinateFrame(sourceCrs) || 'unknown';
-  const verticalSemantics = getDraftVerticalCrsSemantics(verticalCrs);
-  if (verticalCrs && !verticalSemantics) {
-    warnings.push(
-      `Unsupported vertical CRS ${String(verticalCrs)}; vertical unit and height reference are unknown`
-    );
-  }
-  const verticalUnit = verticalCrs ? verticalSemantics?.unit : 'meter';
-  return createTilesetSpatialReference({
-    sourceCrs,
-    sourceCrsState: sourceCrs ? 'explicit' : 'unknown',
-    sourceCrsRepresentation: representation,
-    verticalCrs,
-    coordinateEpoch: epoch,
-    units:
-      coordinateFrame === 'geocentric'
-        ? ['meter', 'meter', 'meter']
-        : coordinateFrame === 'geographic' && verticalUnit
-          ? ['degree', 'degree', verticalUnit]
-          : undefined,
-    verticalUnitScale: verticalCrs ? (verticalSemantics?.verticalUnitScale ?? Number.NaN) : 1,
-    heightReference: verticalCrs
-      ? (verticalSemantics?.heightReference ?? 'unknown')
-      : sourceCrs
-        ? 'ellipsoidal'
-        : 'unknown',
-    coordinateFrame,
-    axisOrder: sourceCrs ? 'xyz' : 'unknown',
-    provenance: 'metadata',
-    warnings
-  });
-}
-
-/** Known vertical CRS semantics needed to interpret draft 3D Tiles height values. */
-type DraftVerticalCrsSemantics = {
-  unit: string;
-  verticalUnitScale: number;
-  heightReference: 'orthometric';
-};
-
-/** Resolves vertical units and height interpretation for known EPSG vertical CRSs. */
-function getDraftVerticalCrsSemantics(
-  verticalCrs: ReadonlyCRSDefinition | undefined
-): DraftVerticalCrsSemantics | undefined {
-  if (typeof verticalCrs !== 'string') {
-    return undefined;
-  }
-  const epsgMatch = /^EPSG:(\d+)$/i.exec(verticalCrs);
-  if (!epsgMatch) {
-    return undefined;
-  }
-  switch (Number(epsgMatch[1])) {
-    case 5702: // NGVD29 height (ftUS)
-    case 6360: // NAVD88 height (ftUS)
-      return {
-        unit: 'us-foot',
-        verticalUnitScale: 1200 / 3937,
-        heightReference: 'orthometric'
-      };
-    case 5703: // NAVD88 height
-      return {unit: 'meter', verticalUnitScale: 1, heightReference: 'orthometric'};
-    default:
-      return undefined;
-  }
-}
-
-/** Parse the 3D Tiles decimal-year string while tolerating legacy numeric producer output. */
-function parseCoordinateEpoch(value: unknown): number | undefined {
-  if (typeof value !== 'string' && typeof value !== 'number') {
-    return undefined;
-  }
-  if (typeof value === 'string' && !value.trim()) {
-    return undefined;
-  }
-  const epoch = Number(value);
-  return Number.isFinite(epoch) ? epoch : undefined;
-}
-
-/** Return an I3S horizontal CRS definition, preferring current WKID aliases over legacy values. */
-function getI3SCrsDefinition(
-  spatialReference?: I3SSpatialReferenceLike
-): ReadonlyCRSDefinition | undefined {
-  const identifier = getCrsIdentifier(spatialReference);
-  if (identifier !== undefined) {
-    return `EPSG:${identifier}`;
-  }
-  return spatialReference?.wkt;
-}
-
-/** Return an I3S vertical CRS definition. */
-function getI3SVerticalCrsDefinition(
-  spatialReference?: I3SSpatialReferenceLike
-): ReadonlyCRSDefinition | undefined {
-  const identifier = spatialReference?.latestVcsWkid ?? spatialReference?.vcsWkid;
-  return identifier === undefined ? undefined : `EPSG:${identifier}`;
-}
-
-/** Return the preferred horizontal WKID. */
-function getCrsIdentifier(spatialReference?: I3SSpatialReferenceLike): number | undefined {
-  return spatialReference?.latestWkid ?? spatialReference?.wkid;
-}
-
-/** Resolve a tileset-wide structured metadata property by its standard semantic. */
-function getTilesetSemanticValue(tileset: Tiles3DLike, semantic: string): unknown {
-  const classIdentifier = tileset.metadata?.class;
-  if (!classIdentifier) {
-    return undefined;
-  }
-  const classDefinition = tileset.schema?.classes?.[classIdentifier] as
-    | {properties?: Record<string, Tiles3DMetadataProperty>}
-    | undefined;
-  const propertyDefinitions = classDefinition?.properties;
-  const propertyValues = tileset.metadata?.properties;
-  for (const [propertyIdentifier, propertyDefinition] of Object.entries(
-    propertyDefinitions || {}
-  )) {
-    if (propertyDefinition.semantic === semantic) {
-      return propertyValues?.[propertyIdentifier];
-    }
-  }
-  return undefined;
-}

package/src/spatial/get-spatial-coordinate-frame.ts

@@ -1,169 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-import {
-  inferCRSRepresentation,
-  parsePROJString,
-  parseWKTCRS,
-  type ReadonlyCRSDefinition,
-  type SpatialReferenceCoordinateFrame,
-  type WKTCRSNode
-} from '@math.gl/crs';
-import {
-  normalizeCrsIdentifier,
-  WGS84_GEOCENTRIC_CRS,
-  WGS84_GEOGRAPHIC_CRS
-} from './normalize-crs-identifier';
-
-/**
- * Classify a CRS definition into the broad coordinate frame used by 3D format adapters.
- *
- * @param definition - CRS definition to classify.
- * @returns The broad geographic, geocentric, projected, local, or unknown frame.
- */
-export function getSpatialCoordinateFrame(
-  definition: ReadonlyCRSDefinition
-): SpatialReferenceCoordinateFrame {
-  if (typeof definition === 'string') {
-    const representation = inferCRSRepresentation(definition);
-    if (representation === 'wkt') {
-      return getWktCoordinateFrame(definition);
-    }
-    if (representation === 'proj-string') {
-      return getProjStringCoordinateFrame(definition);
-    }
-    return getKnownCrsIdentifierCoordinateFrame(definition) || 'projected';
-  }
-
-  const projJsonDefinition = definition as {
-    type?: string;
-    source_crs?: ReadonlyCRSDefinition;
-    components?: readonly ReadonlyCRSDefinition[];
-    coordinate_system?: {subtype?: string};
-  };
-  if (projJsonDefinition.type === 'BoundCRS' && projJsonDefinition.source_crs) {
-    return getSpatialCoordinateFrame(projJsonDefinition.source_crs);
-  }
-  if (projJsonDefinition.type === 'CompoundCRS' && projJsonDefinition.components?.[0]) {
-    return getSpatialCoordinateFrame(projJsonDefinition.components[0]);
-  }
-  if (String(projJsonDefinition.type).includes('Projected')) {
-    return 'projected';
-  }
-  if (String(projJsonDefinition.type).includes('Geographic')) {
-    return 'geographic';
-  }
-  if (String(projJsonDefinition.type).includes('Geodetic')) {
-    return projJsonDefinition.coordinate_system?.subtype === 'Cartesian'
-      ? 'geocentric'
-      : 'geographic';
-  }
-  return 'unknown';
-}
-
-/**
- * Classifies authority identifiers for which the tiles runtime has explicit frame knowledge.
- *
- * Unlike {@link getSpatialCoordinateFrame}, this function does not assume that an unrecognized
- * authority identifier is projected. Draft formats use this strict result to avoid inventing
- * semantics for unknown authorities or registry codes.
- *
- * @param definition - Serialized CRS identifier.
- * @returns A known frame, or `undefined` when registry semantics are unavailable.
- */
-export function getKnownCrsIdentifierCoordinateFrame(
-  definition: ReadonlyCRSDefinition | undefined
-): SpatialReferenceCoordinateFrame | undefined {
-  if (typeof definition !== 'string') {
-    return undefined;
-  }
-  const normalized = normalizeCrsIdentifier(definition);
-  if (normalized === WGS84_GEOCENTRIC_CRS) {
-    return 'geocentric';
-  }
-  if (normalized === WGS84_GEOGRAPHIC_CRS || normalized === 'OGC:CRS84') {
-    return 'geographic';
-  }
-  const epsgMatch = /^EPSG:(\d+)$/.exec(normalized);
-  if (!epsgMatch) {
-    return undefined;
-  }
-  const identifier = Number(epsgMatch[1]);
-  if (identifier === 7789) {
-    return 'geocentric';
-  }
-  if (identifier === 4490 || identifier === 4979) {
-    return 'geographic';
-  }
-  if (
-    identifier === 3857 ||
-    (identifier >= 32601 && identifier <= 32660) ||
-    (identifier >= 32701 && identifier <= 32760)
-  ) {
-    return 'projected';
-  }
-  return undefined;
-}
-
-/** Classifies a WKT definition using the syntax tree parsed by `@math.gl/crs`. */
-function getWktCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
-  let root: WKTCRSNode;
-  try {
-    root = parseWKTCRS(definition).root;
-  } catch {
-    return 'unknown';
-  }
-  switch (root.keyword.toUpperCase()) {
-    case 'GEOCCS':
-      return 'geocentric';
-    case 'GEOGCS':
-    case 'GEOGCRS':
-    case 'GEOGRAPHICCRS':
-    case 'GEOGRAPHIC2DCRS':
-    case 'GEOGRAPHIC3DCRS':
-      return 'geographic';
-    case 'PROJCS':
-    case 'PROJCRS':
-    case 'PROJECTEDCRS':
-      return 'projected';
-    case 'GEODCRS':
-    case 'GEODETICCRS': {
-      const coordinateSystem = root.values.find(
-        (value): value is WKTCRSNode =>
-          value.type === 'node' && value.keyword.toUpperCase() === 'CS'
-      );
-      const subtype = coordinateSystem?.values[0];
-      if (subtype?.type !== 'enumeration' && subtype?.type !== 'string') {
-        return 'unknown';
-      }
-      return subtype.value.toUpperCase() === 'CARTESIAN'
-        ? 'geocentric'
-        : subtype.value.toUpperCase() === 'ELLIPSOIDAL'
-          ? 'geographic'
-          : 'unknown';
-    }
-    default:
-      return 'unknown';
-  }
-}
-
-/** Classifies a PROJ string using the syntax tree parsed by `@math.gl/crs`. */
-function getProjStringCoordinateFrame(definition: string): SpatialReferenceCoordinateFrame {
-  try {
-    const projection = parsePROJString(definition).parameters.find(
-      parameter => parameter.name.toLowerCase() === 'proj'
-    )?.value;
-    switch (projection?.toLowerCase()) {
-      case 'longlat':
-      case 'latlong':
-        return 'geographic';
-      case 'geocent':
-        return 'geocentric';
-      default:
-        return projection ? 'projected' : 'unknown';
-    }
-  } catch {
-    return 'unknown';
-  }
-}