@itowns/geographic 2.46.1-next.6 → 2.46.1-next.60

package/lib/OrientationUtils.js

@@ -8,6 +8,9 @@ const axis = /* @__PURE__ */new Vector3().set(0, 0, 1);
 const coord = /* @__PURE__ */new Coordinates('EPSG:4326', 0, 0, 0);
 const euler = /* @__PURE__ */new Euler();
 const quat = /* @__PURE__ */new Quaternion();
+
+// To unify with Crs.js ProjectionLike type ?
+
 /**
  * The transform from the platform frame to the local East, North, Up (ENU)
  * frame is `RotationZ(heading).RotationX(pitch).RotationY(roll)`.
@@ -19,11 +22,7 @@ const quat = /* @__PURE__ */new Quaternion();
  *
  * @returns The target quaternion
  */
-export function quaternionFromRollPitchHeading() {
-  let roll = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let pitch = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let heading = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromRollPitchHeading(roll = 0, pitch = 0, heading = 0, target = new Quaternion()) {
   roll *= MathUtils.DEG2RAD;
   pitch *= MathUtils.DEG2RAD;
   heading *= MathUtils.DEG2RAD;
@@ -53,11 +52,7 @@ export function quaternionFromRollPitchHeading() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromOmegaPhiKappa() {
-  let omega = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-  let phi = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-  let kappa = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromOmegaPhiKappa(omega = 0, phi = 0, kappa = 0, target = new Quaternion()) {
   omega *= MathUtils.DEG2RAD;
   phi *= MathUtils.DEG2RAD;
   kappa *= MathUtils.DEG2RAD;
@@ -76,8 +71,7 @@ export function quaternionFromOmegaPhiKappa() {
  *
  * @returns The target quaternion
  */
-export function quaternionFromAttitude(attitude) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromAttitude(attitude, target = new Quaternion()) {
   if ('roll' in attitude || 'pitch' in attitude || 'heading' in attitude) {
     return quaternionFromRollPitchHeading(attitude.roll, attitude.pitch, attitude.heading, target);
   }
@@ -97,13 +91,11 @@ export function quaternionFromAttitude(attitude) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToGeocent(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromEnuToGeocent(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToGeocent()(coordinates, target);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     const up = coordinates.geodesicNormal;
     if (up.x == 0 && up.y == 0) {
       return target.set(0, 0, 0, 1);
@@ -127,16 +119,12 @@ export function quaternionFromEnuToGeocent(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromGeocentToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+export function quaternionFromGeocentToEnu(coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromGeocentToEnu()(coordinates, target);
   }
   const toGeocent = quaternionFromEnuToGeocent();
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toGeocent(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => toGeocent(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Lambert Conformal Conic (LCC) frame to the local
@@ -152,14 +140,12 @@ export function quaternionFromGeocentToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLCCToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromLCCToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromLCCToEnu(proj)(coordinates, target);
   }
   const sinlat0 = Math.sin(proj.lat0);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     const long = coordinates.as(coord.crs, coord).longitude * MathUtils.DEG2RAD;
     return target.setFromAxisAngle(axis, sinlat0 * (proj.long0 - long));
   };
@@ -177,16 +163,12 @@ export function quaternionFromLCCToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLCC(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToLCC(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToLCC(proj)(coordinates, target);
   }
   const fromLCC = quaternionFromLCCToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromLCC(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromLCC(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a Transverse Mercator frame (TMerc) to the
@@ -201,8 +183,7 @@ export function quaternionFromEnuToLCC(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromTMercToEnu(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromTMercToEnu(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromTMercToEnu(proj)(coordinates, target);
   }
@@ -215,8 +196,7 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
     const e2 = proj.e * proj.e;
     eta0 = e2 / (1 - e2);
   }
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
+  return (coordinates, target = new Quaternion()) => {
     coordinates.as(coord.crs, coord);
     const long = coord.longitude * MathUtils.DEG2RAD;
     const lat = coord.latitude * MathUtils.DEG2RAD;
@@ -244,16 +224,12 @@ export function quaternionFromTMercToEnu(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined. Otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToTMerc(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToTMerc(proj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToTMerc(proj)(coordinates, target);
   }
   const fromTMerc = quaternionFromTMercToEnu(proj);
-  return function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return fromTMerc(coordinates, target).conjugate();
-  };
+  return (coordinates, target = new Quaternion()) => fromTMerc(coordinates, target).conjugate();
 }
 /**
  * Computes the rotation from a LongLat frame to the local East North Up
@@ -266,12 +242,8 @@ export function quaternionFromEnuToTMerc(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromLongLatToEnu(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromLongLatToEnu(coordinates, target);
-  };
+export function quaternionFromLongLatToEnu(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromLongLatToEnu(coordinates, target);
 }
 /**
  * Computes the rotation from the local East North Up (ENU) frame to a
@@ -283,30 +255,23 @@ export function quaternionFromLongLatToEnu(coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToLongLat(coordinates) {
-  let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionFromEnuToLongLat(coordinates, target);
-  };
+export function quaternionFromEnuToLongLat(coordinates, target = new Quaternion()) {
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionFromEnuToLongLat(coordinates, target);
 }
 /**
  * Warns for an unimplemented projection, sets the quaternion to the
  * identity (0,0,0,1).
  *
  * @param proj - the unimplemented projection (may be parsed using proj4)
+ * @param proj.projName - the name of the projection
  * @param coordinates - the origin of the local East North Up (ENU) frame
  * @param target - output Quaternion
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionUnimplemented(proj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionUnimplemented(proj, coordinates, target = new Quaternion()) {
   console.warn('This quaternion function is not implemented for projections of type', proj.projName);
-  return coordinates ? target.set(0, 0, 0, 1) : function (coordinates) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return quaternionUnimplemented(proj, coordinates, target);
-  };
+  return coordinates ? target.set(0, 0, 0, 1) : (coordinates, target = new Quaternion()) => quaternionUnimplemented(proj, coordinates, target);
 }
 /**
  * Compute the quaternion that models the rotation from the local East North
@@ -319,8 +284,7 @@ export function quaternionUnimplemented(proj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromEnuToCRS(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromEnuToCRS(crsOrProj)(coordinates, target);
   }
@@ -331,6 +295,7 @@ export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
       return quaternionFromEnuToGeocent();
     case 'Lambert Tangential Conformal Conic Projection':
       return quaternionFromEnuToLCC(proj);
+    case 'Universal Transverse Mercator System':
     case 'Fast_Transverse_Mercator':
       return quaternionFromEnuToTMerc(proj);
     case 'longlat':
@@ -350,8 +315,7 @@ export function quaternionFromEnuToCRS(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
-  let target = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new Quaternion();
+export function quaternionFromCRSToEnu(crsOrProj, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToEnu(crsOrProj)(coordinates, target);
   }
@@ -362,6 +326,7 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
       return quaternionFromGeocentToEnu();
     case 'Lambert Tangential Conformal Conic Projection':
       return quaternionFromLCCToEnu(proj);
+    case 'Universal Transverse Mercator System':
     case 'Fast_Transverse_Mercator':
       return quaternionFromTMercToEnu(proj);
     case 'longlat':
@@ -370,6 +335,7 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
       return quaternionUnimplemented(proj);
   }
 }
+const quaternionCrs2CrsCache = {};
 /**
  * Return the function that computes the quaternion that represents a
  * rotation of coordinates between two CRS frames.
@@ -381,23 +347,25 @@ export function quaternionFromCRSToEnu(crsOrProj, coordinates) {
  * @returns The target quaternion if coordinates is defined, otherwise, a
  * function to compute it from coordinates.
  */
-export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates) {
-  let target = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new Quaternion();
+export function quaternionFromCRSToCRS(crsIn, crsOut, coordinates, target = new Quaternion()) {
   if (coordinates) {
     return quaternionFromCRSToCRS(crsIn, crsOut)(coordinates, target);
   }
   if (crsIn == crsOut) {
-    return function (origin) {
-      let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-      return target.set(0, 0, 0, 1);
-    };
+    return (origin, target = new Quaternion()) => target.set(0, 0, 0, 1);
+  }
+  if (quaternionCrs2CrsCache[crsIn] && quaternionCrs2CrsCache[crsIn][crsOut]) {
+    return quaternionCrs2CrsCache[crsIn][crsOut];
   }
 
   // get rotations from the local East/North/Up (ENU) frame to both CRS.
   const fromCrs = quaternionFromCRSToEnu(crsIn);
   const toCrs = quaternionFromEnuToCRS(crsOut);
-  return function (origin) {
-    let target = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Quaternion();
-    return toCrs(origin, target).multiply(fromCrs(origin, quat));
-  };
+  if (!quaternionCrs2CrsCache[crsIn]) {
+    quaternionCrs2CrsCache[crsIn] = {};
+  }
+  if (!quaternionCrs2CrsCache[crsIn][crsOut]) {
+    quaternionCrs2CrsCache[crsIn][crsOut] = (origin, target = new Quaternion()) => toCrs(origin, target).multiply(fromCrs(origin, quat));
+  }
+  return quaternionCrs2CrsCache[crsIn][crsOut];
 }

package/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Extent, type ExtentLike } from './Extent';
+export { default as Coordinates, type CoordinatesLike } from './Coordinates';
+export * as CRS from './Crs';
+export { type ProjectionLike } from './Crs';
+export { default as CoordStars } from './CoordStars';
+export * as OrientationUtils from './OrientationUtils';
+export { default as Ellipsoid, ellipsoidSizes } from './Ellipsoid';

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "@itowns/geographic",
-  "version": "2.46.1-next.6",
-  "description": "Geodesy",
+  "version": "2.46.1-next.60",
+  "description": "Proj4-based three.js geodesy toolkit",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
-    "types": "./src/index.ts",
+    "types": "./lib/index.d.ts",
     "default": "./lib/index.js"
   },
-  "types": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "scripts": {
     "build": "",
-    "lint": "eslint \"src/**/*.{js,ts,tsx}\" \"test/**/*.js\"",
     "transpile": "tsc && cross-env BABEL_DISABLE_CACHE=1 babel src --out-dir lib --extensions .js,.ts",
     "test-unit": "npm run base-test-unit test/unit",
-    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 mocha --import=../../config/babel-register/register.mjs",
+    "base-test-unit": "cross-env BABEL_DISABLE_CACHE=1 NODE_OPTIONS=--no-experimental-strip-types mocha --import=../../config/babel-register/register.mjs",
     "test-with-coverage": "c8 -n src -r html cross-env npm run test-unit",
     "test-with-coverage_lcov": "c8 -n src --reporter=lcov cross-env npm run test-unit",
     "watch": "npm run transpile -- --watch",
@@ -35,8 +34,8 @@
     "url": "https://github.com/itowns/itowns/issues"
   },
   "peerDependencies": {
-    "proj4": "^2.19.10",
-    "three": "^0.174.0"
+    "proj4": ">=2.20.0",
+    "three": ">=0.182.0"
   },
   "homepage": "https://itowns.github.io/"
 }

package/src/Coordinates.ts

@@ -1,19 +1,14 @@
 import { Vector3, type Vector3Like, type Matrix4, MathUtils } from 'three';
-import proj4, { type Converter } from 'proj4';
 import Ellipsoid from './Ellipsoid';
 import * as CRS from './Crs';
 
 import type { ProjectionLike } from './Crs';
 
 const ellipsoid = /* @__PURE__ */ new Ellipsoid();
-const projectionCache: Record<string, Record<string, Converter>> = {};
 
 const v0 = /* @__PURE__ */ new Vector3();
 const v1 = /* @__PURE__ */ new Vector3();
 
-let coord0: Coordinates;
-let coord1: Coordinates;
-
 export interface CoordinatesLike {
     readonly crs: string;
     readonly x: number;
@@ -21,18 +16,6 @@ export interface CoordinatesLike {
     readonly z: number;
 }
 
-function proj4cache(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter {
-    if (!projectionCache[crsIn]) {
-        projectionCache[crsIn] = {};
-    }
-
-    if (!projectionCache[crsIn][crsOut]) {
-        projectionCache[crsIn][crsOut] = proj4(crsIn, crsOut);
-    }
-
-    return projectionCache[crsIn][crsOut];
-}
-
 /**
  * A class representing a geographic or geocentric coordinate.
  *
@@ -91,7 +74,7 @@ class Coordinates {
      * @param y - y or latitude value.
      * @param z - z or altitude value.
      */
-    constructor(crs: ProjectionLike, x: number = 0, y: number = 0, z: number = 0) {
+    constructor(crs: ProjectionLike, x = 0, y = 0, z = 0) {
         this.isCoordinates = true;
 
         CRS.isValid(crs);
@@ -132,6 +115,7 @@ class Coordinates {
     /**
      * Sets the Coordinate Reference System.
      * @param crs - Coordinate Reference System (e.g. 'EPSG:4978')
+     * @returns
      */
     setCrs(crs: ProjectionLike): this {
         CRS.isValid(crs);
@@ -145,8 +129,9 @@ class Coordinates {
      * @param x - x or longitude value.
      * @param y - y or latitude value.
      * @param z - z or altitude value.
+     * @returns
      */
-    setFromValues(x: number = 0, y: number = 0, z: number = 0): this {
+    setFromValues(x = 0, y = 0, z = 0): this {
         this.x = x;
         this.y = y;
         this.z = z;
@@ -163,8 +148,9 @@ class Coordinates {
      *
      * @param array - The source array.
      * @param offset - Optional offset into the array. Default is 0.
+     * @returns
      */
-    setFromArray(array: number[], offset: number = 0): this {
+    setFromArray(array: number[], offset = 0): this {
         return this.setFromValues(
             array[offset],
             array[offset + 1],
@@ -178,6 +164,7 @@ class Coordinates {
      * properties.
      *
      * @param v - The source object.
+     * @returns
      */
     setFromVector3(v: Vector3Like): this {
         return this.setFromValues(v.x, v.y, v.z);
@@ -186,6 +173,7 @@ class Coordinates {
     /**
      * Returns a new coordinate with the same `(x, y, z)` vector and crs as this
      * one.
+     * @returns
      */
     clone(): Coordinates {
         return new Coordinates(this.crs, this.x, this.y, this.z);
@@ -196,6 +184,7 @@ class Coordinates {
      * to this coordinate.
      *
      * @param src - The source coordinate to copy from.
+     * @returns
      */
     copy(src: CoordinatesLike): this {
         this.crs = src.crs;
@@ -220,6 +209,7 @@ class Coordinates {
 
     /**
      * The geodesic normal of the coordinate.
+     * @returns
      */
     get geodesicNormal() {
         if (this._normalNeedsUpdate) {
@@ -260,7 +250,7 @@ class Coordinates {
      * @returns An array [x, y, z], or copies x, y and z into the provided
      * array.
      */
-    toArray(array: number[] = [], offset: number = 0): ArrayLike<number> {
+    toArray(array: number[] = [], offset = 0): ArrayLike<number> {
         return Vector3.prototype.toArray.call(this, array, offset);
     }
 
@@ -268,6 +258,8 @@ class Coordinates {
      * Computes the planar distance from this coordinates to `coord`.
      * **Planar distance** is the straight-line euclidean distance calculated in
      * a 2D cartesian coordinate system.
+     * @param coord
+     * @returns
      */
     planarDistanceTo(coord: Coordinates): number {
         this.toVector3(v0).setZ(0);
@@ -279,6 +271,8 @@ class Coordinates {
      * Computes the geodetic distance from this coordinates to `coord`.
      * **Geodetic distance** is calculated in an ellipsoid space as the shortest
      * distance across the curved surface of the ellipsoid.
+     * @param coord
+     * @returns
      */
     geodeticDistanceTo(coord: Coordinates): number {
         this.as('EPSG:4326', coord0);
@@ -304,6 +298,7 @@ class Coordinates {
      * by `mat`, and divides by perspective.
      *
      * @param mat - The matrix.
+     * @returns
      */
     applyMatrix4(mat: Matrix4): this {
         Vector3.prototype.applyMatrix4.call(this, mat);
@@ -348,7 +343,7 @@ class Coordinates {
                 this.y = MathUtils.clamp(this.y, -89.999999, 89.999999);
             }
 
-            target.setFromArray(proj4cache(this.crs, crs)
+            target.setFromArray(CRS.transform(this.crs, crs)
                 .forward([this.x, this.y, this.z]));
         }
 
@@ -358,7 +353,7 @@ class Coordinates {
     }
 }
 
-coord0 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
-coord1 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
+const coord0 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
+const coord1 = /* @__PURE__ */ new Coordinates('EPSG:4326', 0, 0, 0);
 
 export default Coordinates;

package/src/Crs.ts

@@ -1,7 +1,15 @@
 import proj4 from 'proj4';
-
+import type { Converter } from 'proj4';
 import type { ProjectionDefinition } from 'proj4/dist/lib/defs';
 
+interface proj4Def {
+    type: string;
+    PROJCS: proj4Def;
+    unknown?: string;
+    (alias: string): proj4Def & { name: string };
+    title: string;
+}
+
 proj4.defs('EPSG:4978', '+proj=geocent +datum=WGS84 +units=m +no_defs');
 
 // Redefining proj4 global projections to match epsg.org database axis order.
@@ -15,8 +23,22 @@ proj4.defs('WGS84').axis = 'neu';
  * projection definition previously defined with
  * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections).
  */
+// TODO Unify with OrientationUtils.js
 export type ProjectionLike = string;
 
+const proj4Cache: Record<string, Record<string, Converter>> = {};
+export function transform(crsIn: ProjectionLike, crsOut: ProjectionLike): Converter {
+    if (!proj4Cache[crsIn]) {
+        proj4Cache[crsIn] = {};
+    }
+
+    if (!proj4Cache[crsIn][crsOut]) {
+        proj4Cache[crsIn][crsOut] = proj4(crsIn, crsOut);
+    }
+
+    return proj4Cache[crsIn][crsOut];
+}
+
 function isString(s: unknown): s is string {
     return typeof s === 'string' || s instanceof String;
 }
@@ -52,6 +74,7 @@ export const UNIT = {
  * @internal
  *
  * @param crs - The CRS to test.
+ * @returns
  */
 export function is4326(crs: ProjectionLike) {
     return crs === 'EPSG:4326';
@@ -62,7 +85,7 @@ function unitFromProj4Unit(proj: ProjectionDefinition) {
         return UNIT.DEGREE;
     } else if (proj.units === 'm' || proj.units === 'meter') {
         return UNIT.METER;
-    } else if (proj.units === 'foot') {
+    } else if (proj.units === 'foot' || proj.units === 'ft') {
         return UNIT.FOOT;
     } else if (proj.units === undefined && proj.to_meter === undefined) {
         // See https://proj.org/en/9.4/usage/projections.html [17/10/2024]
@@ -92,7 +115,8 @@ export function getUnit(crs: ProjectionLike) {
  * Asserts that the CRS is using metric units.
  *
  * @param crs - The CRS to check.
- * @throws {@link Error} if the CRS is not valid.
+ * @returns
+ * @throws {Error} if the CRS is not valid.
  */
 export function isMetricUnit(crs: ProjectionLike) {
     return getUnit(crs) === UNIT.METER;
@@ -102,7 +126,8 @@ export function isMetricUnit(crs: ProjectionLike) {
  * Asserts that the CRS is geographic.
  *
  * @param crs - The CRS to check.
- * @throws {@link Error} if the CRS is not valid.
+ * @returns
+ * @throws {Error} if the CRS is not valid.
  */
 export function isGeographic(crs: ProjectionLike) {
     return getUnit(crs) === UNIT.DEGREE;
@@ -125,12 +150,12 @@ export function isGeocentric(crs: ProjectionLike) {
  * includes an unit.
  *
  * @param crs - The CRS to test.
- * @throws {@link Error} if the crs is not valid.
+ * @throws {Error} if the crs is not valid.
  */
 export function isValid(crs: ProjectionLike) {
     const proj = proj4.defs(crs);
     if (!proj) {
-        throw new Error(`Undefined crs '${crs}'. Add it with proj4.defs('${crs}', string)`);
+        throw new Error(`Undefined crs '${crs}'. Add it with itowns.CRS.defs('${crs}', wktString)`);
     }
     if (!unitFromProj4Unit(proj)) {
         throw new Error(`No valid unit found for crs '${crs}', found ${proj.units}`);
@@ -166,11 +191,56 @@ export function axisOrder(crs: ProjectionLike) {
 
 /**
  * Defines a proj4 projection as a named alias.
- * This function is a specialized wrapper over the
- * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections)
- * function.
+ * This function is an alias for the
+ * [`proj4.defs`](https://github.com/proj4js/proj4js#named-projections) function.
+ */
+export const defs = proj4.defs;
+
+/**
+ * Fetches a CRS definition from epsg.io and registers it with proj4.
+ * If the CRS is already defined, returns the existing definition.
  *
- * @param code - Named alias of the currently defined projection.
- * @param proj4def - Proj4 or WKT string of the defined projection.
+ * @param crs - The EPSG code string (e.g. "EPSG:2154").
+ * @returns The proj4 projection definition.
+ *
+ * @example
+ * // Register EPSG:2154 (RGF93 / Lambert-93)
+ * await CRS.fromEPSG('EPSG:2154');
+ *
+ * // Register EPSG:4269 (NAD83)
+ * await CRS.fromEPSG('EPSG:4269');
  */
-export const defs = (code: string, proj4def: string) => proj4.defs(code, proj4def);
+export async function fromEPSG(crs: string): Promise<ProjectionDefinition> {
+    const def = proj4.defs(crs);
+    if (def) {
+        return def;
+    }
+
+    const code = crs.replace(/^EPSG:/i, '');
+    const response = await fetch(`https://epsg.io/${code}.proj4`);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch EPSG:${code} from epsg.io: ${response.status}`);
+    }
+
+    const proj4def = await response.text();
+    proj4.defs(crs, proj4def);
+    return proj4.defs(crs);
+}
+
+export function defsFromWkt(wkt: string): string {
+    proj4.defs('unknown', wkt);
+    const proj4Defs = proj4.defs as unknown as proj4Def;
+    let projCS;
+    if (proj4Defs('unknown').type === 'COMPD_CS') {
+        console.warn('Compound coordinate system is not yet supported.');
+        projCS = proj4Defs('unknown').PROJCS;
+    } else {
+        projCS = proj4Defs('unknown');
+    }
+    const crsAlias = (projCS.title || projCS.name || 'EPSG:XXXX');
+    if (!(crsAlias in proj4.defs)) {
+        proj4.defs(crsAlias, projCS);
+    }
+    delete proj4Defs.unknown;
+    return crsAlias;
+}