@cesium/engine 24.0.0 → 25.0.0

package/Source/Core/ExtrapolationType.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * Constants to determine how an interpolated value is extrapolated
  * when querying outside the bounds of available data.
@@ -31,4 +33,7 @@ const ExtrapolationType = {
    */
   EXTRAPOLATE: 2,
 };
-export default Object.freeze(ExtrapolationType);
+
+Object.freeze(ExtrapolationType);
+
+export default ExtrapolationType;

package/Source/Core/GeocodeType.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 /**
  * The type of geocoding to be performed by a {@link GeocoderService}.
  * @enum {number}
@@ -21,4 +23,7 @@ const GeocodeType = {
    */
   AUTOCOMPLETE: 1,
 };
-export default Object.freeze(GeocodeType);
+
+Object.freeze(GeocodeType);
+
+export default GeocodeType;

package/Source/Core/GeographicProjection.js

@@ -1,105 +1,105 @@
+// @ts-check
+
 import Cartesian3 from "./Cartesian3.js";
 import Cartographic from "./Cartographic.js";
 import defined from "./defined.js";
 import DeveloperError from "./DeveloperError.js";
 import Ellipsoid from "./Ellipsoid.js";
 
+/** @import MapProjection from "./MapProjection.js"; */
+
 /**
  * A simple map projection where longitude and latitude are linearly mapped to X and Y by multiplying
  * them by the {@link Ellipsoid#maximumRadius}.  This projection
  * is commonly known as geographic, equirectangular, equidistant cylindrical, or plate carrée. When using the WGS84 ellipsoid, it
  * is also known as EPSG:4326.
  *
- * @alias GeographicProjection
- * @constructor
- *
- * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid.
- *
  * @see WebMercatorProjection
+ *
+ * @implements MapProjection
  */
-function GeographicProjection(ellipsoid) {
-  this._ellipsoid = ellipsoid ?? Ellipsoid.default;
-  this._semimajorAxis = this._ellipsoid.maximumRadius;
-  this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
-}
+class GeographicProjection {
+  /**
+   * @param {Ellipsoid} [ellipsoid=Ellipsoid.default] The ellipsoid.
+   */
+  constructor(ellipsoid) {
+    this._ellipsoid = ellipsoid ?? Ellipsoid.default;
+    this._semimajorAxis = this._ellipsoid.maximumRadius;
+    this._oneOverSemimajorAxis = 1.0 / this._semimajorAxis;
+  }
 
-Object.defineProperties(GeographicProjection.prototype, {
   /**
    * Gets the {@link Ellipsoid}.
    *
-   * @memberof GeographicProjection.prototype
-   *
    * @type {Ellipsoid}
    * @readonly
    */
-  ellipsoid: {
-    get: function () {
-      return this._ellipsoid;
-    },
-  },
-});
+  get ellipsoid() {
+    return this._ellipsoid;
+  }
 
-/**
- * Projects a set of {@link Cartographic} coordinates, in radians, to map coordinates, in meters.
- * X and Y are the longitude and latitude, respectively, multiplied by the maximum radius of the
- * ellipsoid.  Z is the unmodified height.
- *
- * @param {Cartographic} cartographic The coordinates to project.
- * @param {Cartesian3} [result] An instance into which to copy the result.  If this parameter is
- *        undefined, a new instance is created and returned.
- * @returns {Cartesian3} The projected coordinates.  If the result parameter is not undefined, the
- *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
- *          created and returned.
- */
-GeographicProjection.prototype.project = function (cartographic, result) {
-  // Actually this is the special case of equidistant cylindrical called the plate carree
-  const semimajorAxis = this._semimajorAxis;
-  const x = cartographic.longitude * semimajorAxis;
-  const y = cartographic.latitude * semimajorAxis;
-  const z = cartographic.height;
+  /**
+   * Projects a set of {@link Cartographic} coordinates, in radians, to map coordinates, in meters.
+   * X and Y are the longitude and latitude, respectively, multiplied by the maximum radius of the
+   * ellipsoid.  Z is the unmodified height.
+   *
+   * @param {Cartographic} cartographic The coordinates to project.
+   * @param {Cartesian3} [result] An instance into which to copy the result.  If this parameter is
+   *        undefined, a new instance is created and returned.
+   * @returns {Cartesian3} The projected coordinates.  If the result parameter is not undefined, the
+   *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
+   *          created and returned.
+   */
+  project(cartographic, result) {
+    // Actually this is the special case of equidistant cylindrical called the plate carree
+    const semimajorAxis = this._semimajorAxis;
+    const x = cartographic.longitude * semimajorAxis;
+    const y = cartographic.latitude * semimajorAxis;
+    const z = cartographic.height;
+
+    if (!defined(result)) {
+      return new Cartesian3(x, y, z);
+    }
 
-  if (!defined(result)) {
-    return new Cartesian3(x, y, z);
+    result.x = x;
+    result.y = y;
+    result.z = z;
+    return result;
   }
 
-  result.x = x;
-  result.y = y;
-  result.z = z;
-  return result;
-};
+  /**
+   * Unprojects a set of projected {@link Cartesian3} coordinates, in meters, to {@link Cartographic}
+   * coordinates, in radians.  Longitude and Latitude are the X and Y coordinates, respectively,
+   * divided by the maximum radius of the ellipsoid.  Height is the unmodified Z coordinate.
+   *
+   * @param {Cartesian3} cartesian The Cartesian position to unproject with height (z) in meters.
+   * @param {Cartographic} [result] An instance into which to copy the result.  If this parameter is
+   *        undefined, a new instance is created and returned.
+   * @returns {Cartographic} The unprojected coordinates.  If the result parameter is not undefined, the
+   *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
+   *          created and returned.
+   */
+  unproject(cartesian, result) {
+    //>>includeStart('debug', pragmas.debug);
+    if (!defined(cartesian)) {
+      throw new DeveloperError("cartesian is required");
+    }
+    //>>includeEnd('debug');
 
-/**
- * Unprojects a set of projected {@link Cartesian3} coordinates, in meters, to {@link Cartographic}
- * coordinates, in radians.  Longitude and Latitude are the X and Y coordinates, respectively,
- * divided by the maximum radius of the ellipsoid.  Height is the unmodified Z coordinate.
- *
- * @param {Cartesian3} cartesian The Cartesian position to unproject with height (z) in meters.
- * @param {Cartographic} [result] An instance into which to copy the result.  If this parameter is
- *        undefined, a new instance is created and returned.
- * @returns {Cartographic} The unprojected coordinates.  If the result parameter is not undefined, the
- *          coordinates are copied there and that instance is returned.  Otherwise, a new instance is
- *          created and returned.
- */
-GeographicProjection.prototype.unproject = function (cartesian, result) {
-  //>>includeStart('debug', pragmas.debug);
-  if (!defined(cartesian)) {
-    throw new DeveloperError("cartesian is required");
-  }
-  //>>includeEnd('debug');
+    const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
+    const longitude = cartesian.x * oneOverEarthSemimajorAxis;
+    const latitude = cartesian.y * oneOverEarthSemimajorAxis;
+    const height = cartesian.z;
 
-  const oneOverEarthSemimajorAxis = this._oneOverSemimajorAxis;
-  const longitude = cartesian.x * oneOverEarthSemimajorAxis;
-  const latitude = cartesian.y * oneOverEarthSemimajorAxis;
-  const height = cartesian.z;
+    if (!defined(result)) {
+      return new Cartographic(longitude, latitude, height);
+    }
 
-  if (!defined(result)) {
-    return new Cartographic(longitude, latitude, height);
+    result.longitude = longitude;
+    result.latitude = latitude;
+    result.height = height;
+    return result;
   }
-
-  result.longitude = longitude;
-  result.latitude = latitude;
-  result.height = height;
-  return result;
-};
+}
 
 export default GeographicProjection;

package/Source/Core/GeographicTilingScheme.js

@@ -1,3 +1,5 @@
+// @ts-check
+
 import Cartesian2 from "./Cartesian2.js";
 import Check from "./Check.js";
 import Frozen from "./Frozen.js";
@@ -7,239 +9,218 @@ import GeographicProjection from "./GeographicProjection.js";
 import CesiumMath from "./Math.js";
 import Rectangle from "./Rectangle.js";
 
+/** @import Cartographic from "./Cartographic.js"; */
+/** @import MapProjection from "./MapProjection.js"; */
+/** @import TilingScheme from "./TilingScheme.js"; */
+
 /**
  * A tiling scheme for geometry referenced to a simple {@link GeographicProjection} where
  * longitude and latitude are directly mapped to X and Y.  This projection is commonly
  * known as geographic, equirectangular, equidistant cylindrical, or plate carrée.
  *
- * @alias GeographicTilingScheme
- * @constructor
- *
- * @param {object} [options] Object with the following properties:
- * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The ellipsoid whose surface is being tiled. Defaults to
- * the default ellipsoid.
- * @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the tiling scheme.
- * @param {number} [options.numberOfLevelZeroTilesX=2] The number of tiles in the X direction at level zero of
- * the tile tree.
- * @param {number} [options.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
- * the tile tree.
+ * @implements {TilingScheme}
  */
-function GeographicTilingScheme(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-
-  this._ellipsoid = options.ellipsoid ?? Ellipsoid.default;
-  this._rectangle = options.rectangle ?? Rectangle.MAX_VALUE;
-  this._projection = new GeographicProjection(this._ellipsoid);
-  this._numberOfLevelZeroTilesX = options.numberOfLevelZeroTilesX ?? 2;
-  this._numberOfLevelZeroTilesY = options.numberOfLevelZeroTilesY ?? 1;
-}
+class GeographicTilingScheme {
+  /**
+   * @param {object} [options] Object with the following properties:
+   * @param {Ellipsoid} [options.ellipsoid=Ellipsoid.default] The ellipsoid whose surface is being tiled. Defaults to
+   * the default ellipsoid.
+   * @param {Rectangle} [options.rectangle=Rectangle.MAX_VALUE] The rectangle, in radians, covered by the tiling scheme.
+   * @param {number} [options.numberOfLevelZeroTilesX=2] The number of tiles in the X direction at level zero of
+   * the tile tree.
+   * @param {number} [options.numberOfLevelZeroTilesY=1] The number of tiles in the Y direction at level zero of
+   * the tile tree.
+   */
+  constructor(options) {
+    options = options ?? Frozen.EMPTY_OBJECT;
+
+    this._ellipsoid = options.ellipsoid ?? Ellipsoid.default;
+    this._rectangle = options.rectangle ?? Rectangle.MAX_VALUE;
+    this._projection = new GeographicProjection(this._ellipsoid);
+    this._numberOfLevelZeroTilesX = options.numberOfLevelZeroTilesX ?? 2;
+    this._numberOfLevelZeroTilesY = options.numberOfLevelZeroTilesY ?? 1;
+  }
 
-Object.defineProperties(GeographicTilingScheme.prototype, {
   /**
    * Gets the ellipsoid that is tiled by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {Ellipsoid}
    */
-  ellipsoid: {
-    get: function () {
-      return this._ellipsoid;
-    },
-  },
+  get ellipsoid() {
+    return this._ellipsoid;
+  }
 
   /**
    * Gets the rectangle, in radians, covered by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {Rectangle}
    */
-  rectangle: {
-    get: function () {
-      return this._rectangle;
-    },
-  },
+  get rectangle() {
+    return this._rectangle;
+  }
 
   /**
    * Gets the map projection used by this tiling scheme.
-   * @memberof GeographicTilingScheme.prototype
    * @type {MapProjection}
    */
-  projection: {
-    get: function () {
-      return this._projection;
-    },
-  },
-});
-
-/**
- * Gets the total number of tiles in the X direction at a specified level-of-detail.
- *
- * @param {number} level The level-of-detail.
- * @returns {number} The number of tiles in the X direction at the given level.
- */
-GeographicTilingScheme.prototype.getNumberOfXTilesAtLevel = function (level) {
-  return this._numberOfLevelZeroTilesX << level;
-};
-
-/**
- * Gets the total number of tiles in the Y direction at a specified level-of-detail.
- *
- * @param {number} level The level-of-detail.
- * @returns {number} The number of tiles in the Y direction at the given level.
- */
-GeographicTilingScheme.prototype.getNumberOfYTilesAtLevel = function (level) {
-  return this._numberOfLevelZeroTilesY << level;
-};
-
-/**
- * Transforms a rectangle specified in geodetic radians to the native coordinate system
- * of this tiling scheme.
- *
- * @param {Rectangle} rectangle The rectangle to transform.
- * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
- *        should be created.
- * @returns {Rectangle} The specified 'result', or a new object containing the native rectangle if 'result'
- *          is undefined.
- */
-GeographicTilingScheme.prototype.rectangleToNativeRectangle = function (
-  rectangle,
-  result,
-) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.defined("rectangle", rectangle);
-  //>>includeEnd('debug');
-
-  const west = CesiumMath.toDegrees(rectangle.west);
-  const south = CesiumMath.toDegrees(rectangle.south);
-  const east = CesiumMath.toDegrees(rectangle.east);
-  const north = CesiumMath.toDegrees(rectangle.north);
-
-  if (!defined(result)) {
-    return new Rectangle(west, south, east, north);
+  get projection() {
+    return this._projection;
   }
 
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
-
-/**
- * Converts tile x, y coordinates and level to a rectangle expressed in the native coordinates
- * of the tiling scheme.
- *
- * @param {number} x The integer x coordinate of the tile.
- * @param {number} y The integer y coordinate of the tile.
- * @param {number} level The tile level-of-detail.  Zero is the least detailed.
- * @param {object} [result] The instance to which to copy the result, or undefined if a new instance
- *        should be created.
- * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
- *          if 'result' is undefined.
- */
-GeographicTilingScheme.prototype.tileXYToNativeRectangle = function (
-  x,
-  y,
-  level,
-  result,
-) {
-  const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
-  rectangleRadians.west = CesiumMath.toDegrees(rectangleRadians.west);
-  rectangleRadians.south = CesiumMath.toDegrees(rectangleRadians.south);
-  rectangleRadians.east = CesiumMath.toDegrees(rectangleRadians.east);
-  rectangleRadians.north = CesiumMath.toDegrees(rectangleRadians.north);
-  return rectangleRadians;
-};
+  /**
+   * Gets the total number of tiles in the X direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the X direction at the given level.
+   */
+  getNumberOfXTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesX << level;
+  }
 
-/**
- * Converts tile x, y coordinates and level to a cartographic rectangle in radians.
- *
- * @param {number} x The integer x coordinate of the tile.
- * @param {number} y The integer y coordinate of the tile.
- * @param {number} level The tile level-of-detail.  Zero is the least detailed.
- * @param {object} [result] The instance to which to copy the result, or undefined if a new instance
- *        should be created.
- * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
- *          if 'result' is undefined.
- */
-GeographicTilingScheme.prototype.tileXYToRectangle = function (
-  x,
-  y,
-  level,
-  result,
-) {
-  const rectangle = this._rectangle;
-
-  const xTiles = this.getNumberOfXTilesAtLevel(level);
-  const yTiles = this.getNumberOfYTilesAtLevel(level);
-
-  const xTileWidth = rectangle.width / xTiles;
-  const west = x * xTileWidth + rectangle.west;
-  const east = (x + 1) * xTileWidth + rectangle.west;
-
-  const yTileHeight = rectangle.height / yTiles;
-  const north = rectangle.north - y * yTileHeight;
-  const south = rectangle.north - (y + 1) * yTileHeight;
-
-  if (!defined(result)) {
-    result = new Rectangle(west, south, east, north);
+  /**
+   * Gets the total number of tiles in the Y direction at a specified level-of-detail.
+   *
+   * @param {number} level The level-of-detail.
+   * @returns {number} The number of tiles in the Y direction at the given level.
+   */
+  getNumberOfYTilesAtLevel(level) {
+    return this._numberOfLevelZeroTilesY << level;
   }
 
-  result.west = west;
-  result.south = south;
-  result.east = east;
-  result.north = north;
-  return result;
-};
+  /**
+   * Transforms a rectangle specified in geodetic radians to the native coordinate system
+   * of this tiling scheme.
+   *
+   * @param {Rectangle} rectangle The rectangle to transform.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the native rectangle if 'result'
+   *          is undefined.
+   */
+  rectangleToNativeRectangle(rectangle, result) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.defined("rectangle", rectangle);
+    //>>includeEnd('debug');
+
+    const west = CesiumMath.toDegrees(rectangle.west);
+    const south = CesiumMath.toDegrees(rectangle.south);
+    const east = CesiumMath.toDegrees(rectangle.east);
+    const north = CesiumMath.toDegrees(rectangle.north);
+
+    if (!defined(result)) {
+      return new Rectangle(west, south, east, north);
+    }
+
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
+  }
 
-/**
- * Calculates the tile x, y coordinates of the tile containing
- * a given cartographic position.
- *
- * @param {Cartographic} position The position.
- * @param {number} level The tile level-of-detail.  Zero is the least detailed.
- * @param {Cartesian2} [result] The instance to which to copy the result, or undefined if a new instance
- *        should be created.
- * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
- *          if 'result' is undefined.
- */
-GeographicTilingScheme.prototype.positionToTileXY = function (
-  position,
-  level,
-  result,
-) {
-  const rectangle = this._rectangle;
-  if (!Rectangle.contains(rectangle, position)) {
-    // outside the bounds of the tiling scheme
-    return undefined;
+  /**
+   * Converts tile x, y coordinates and level to a rectangle expressed in the native coordinates
+   * of the tiling scheme.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToNativeRectangle(x, y, level, result) {
+    const rectangleRadians = this.tileXYToRectangle(x, y, level, result);
+    rectangleRadians.west = CesiumMath.toDegrees(rectangleRadians.west);
+    rectangleRadians.south = CesiumMath.toDegrees(rectangleRadians.south);
+    rectangleRadians.east = CesiumMath.toDegrees(rectangleRadians.east);
+    rectangleRadians.north = CesiumMath.toDegrees(rectangleRadians.north);
+    return rectangleRadians;
   }
 
-  const xTiles = this.getNumberOfXTilesAtLevel(level);
-  const yTiles = this.getNumberOfYTilesAtLevel(level);
+  /**
+   * Converts tile x, y coordinates and level to a cartographic rectangle in radians.
+   *
+   * @param {number} x The integer x coordinate of the tile.
+   * @param {number} y The integer y coordinate of the tile.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Rectangle} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Rectangle} The specified 'result', or a new object containing the rectangle
+   *          if 'result' is undefined.
+   */
+  tileXYToRectangle(x, y, level, result) {
+    const rectangle = this._rectangle;
+
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
 
-  const xTileWidth = rectangle.width / xTiles;
-  const yTileHeight = rectangle.height / yTiles;
+    const xTileWidth = rectangle.width / xTiles;
+    const west = x * xTileWidth + rectangle.west;
+    const east = (x + 1) * xTileWidth + rectangle.west;
 
-  let longitude = position.longitude;
-  if (rectangle.east < rectangle.west) {
-    longitude += CesiumMath.TWO_PI;
-  }
+    const yTileHeight = rectangle.height / yTiles;
+    const north = rectangle.north - y * yTileHeight;
+    const south = rectangle.north - (y + 1) * yTileHeight;
 
-  let xTileCoordinate = ((longitude - rectangle.west) / xTileWidth) | 0;
-  if (xTileCoordinate >= xTiles) {
-    xTileCoordinate = xTiles - 1;
-  }
+    if (!defined(result)) {
+      result = new Rectangle(west, south, east, north);
+    }
 
-  let yTileCoordinate =
-    ((rectangle.north - position.latitude) / yTileHeight) | 0;
-  if (yTileCoordinate >= yTiles) {
-    yTileCoordinate = yTiles - 1;
+    result.west = west;
+    result.south = south;
+    result.east = east;
+    result.north = north;
+    return result;
   }
 
-  if (!defined(result)) {
-    return new Cartesian2(xTileCoordinate, yTileCoordinate);
+  /**
+   * Calculates the tile x, y coordinates of the tile containing
+   * a given cartographic position.
+   *
+   * @param {Cartographic} position The position.
+   * @param {number} level The tile level-of-detail.  Zero is the least detailed.
+   * @param {Cartesian2} [result] The instance to which to copy the result, or undefined if a new instance
+   *        should be created.
+   * @returns {Cartesian2} The specified 'result', or a new object containing the tile x, y coordinates
+   *          if 'result' is undefined.
+   */
+  positionToTileXY(position, level, result) {
+    const rectangle = this._rectangle;
+    if (!Rectangle.contains(rectangle, position)) {
+      // outside the bounds of the tiling scheme
+      return undefined;
+    }
+
+    const xTiles = this.getNumberOfXTilesAtLevel(level);
+    const yTiles = this.getNumberOfYTilesAtLevel(level);
+
+    const xTileWidth = rectangle.width / xTiles;
+    const yTileHeight = rectangle.height / yTiles;
+
+    let longitude = position.longitude;
+    if (rectangle.east < rectangle.west) {
+      longitude += CesiumMath.TWO_PI;
+    }
+
+    let xTileCoordinate = ((longitude - rectangle.west) / xTileWidth) | 0;
+    if (xTileCoordinate >= xTiles) {
+      xTileCoordinate = xTiles - 1;
+    }
+
+    let yTileCoordinate =
+      ((rectangle.north - position.latitude) / yTileHeight) | 0;
+    if (yTileCoordinate >= yTiles) {
+      yTileCoordinate = yTiles - 1;
+    }
+
+    if (!defined(result)) {
+      return new Cartesian2(xTileCoordinate, yTileCoordinate);
+    }
+
+    result.x = xTileCoordinate;
+    result.y = yTileCoordinate;
+    return result;
   }
+}
 
-  result.x = xTileCoordinate;
-  result.y = yTileCoordinate;
-  return result;
-};
 export default GeographicTilingScheme;

package/Source/Core/GeometryOffsetAttribute.js

@@ -1,5 +1,8 @@
+// @ts-check
+
 /**
  * Represents which vertices should have a value of `true` for the `applyOffset` attribute
+ * @enum {number}
  * @private
  */
 const GeometryOffsetAttribute = {
@@ -7,4 +10,7 @@ const GeometryOffsetAttribute = {
   TOP: 1,
   ALL: 2,
 };
-export default Object.freeze(GeometryOffsetAttribute);
+
+Object.freeze(GeometryOffsetAttribute);
+
+export default GeometryOffsetAttribute;

package/Source/Core/GeometryType.js

@@ -1,4 +1,7 @@
+// @ts-check
+
 /**
+ * @enum {number}
  * @private
  */
 const GeometryType = {
@@ -7,4 +10,7 @@ const GeometryType = {
   LINES: 2,
   POLYLINES: 3,
 };
-export default Object.freeze(GeometryType);
+
+Object.freeze(GeometryType);
+
+export default GeometryType;