ol 9.2.2-dev.1715952885334 → 9.2.2-dev.1716040825122

package/featureloader.d.ts

@@ -36,7 +36,7 @@
 /**
  * @template {import("./Feature.js").FeatureLike} [FeatureType=import("./Feature.js").FeatureLike]
  * @param {string|FeatureUrlFunction} url Feature URL service.
- * @param {import("./format/Feature.js").default} format Feature format.
+ * @param {import("./format/Feature.js").default<import('./format/Feature.js').FeatureToFeatureClass<FeatureType>>} format Feature format.
  * @param {import("./extent.js").Extent} extent Extent.
  * @param {number} resolution Resolution.
  * @param {import("./proj/Projection.js").default} projection Projection.
@@ -45,7 +45,7 @@
  * @param {function(): void} failure Failure
  *      Function called when loading failed.
  */
-export function loadFeaturesXhr<FeatureType extends import("./Feature.js").FeatureLike = import("./Feature.js").FeatureLike>(url: string | FeatureUrlFunction, format: import("./format/Feature.js").default, extent: import("./extent.js").Extent, resolution: number, projection: import("./proj/Projection.js").default, success: (arg0: FeatureType[], arg1: import("./proj/Projection.js").default) => void, failure: () => void): void;
+export function loadFeaturesXhr<FeatureType extends import("./Feature.js").FeatureLike = import("./Feature.js").FeatureLike>(url: string | FeatureUrlFunction, format: import("./format/Feature.js").default<import("./format/Feature.js").FeatureToFeatureClass<FeatureType>>, extent: import("./extent.js").Extent, resolution: number, projection: import("./proj/Projection.js").default, success: (arg0: FeatureType[], arg1: import("./proj/Projection.js").default) => void, failure: () => void): void;
 /**
  * Create an XHR feature loader for a `url` and `format`. The feature loader
  * loads features (with XHR), parses the features, and adds them to the

package/featureloader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"featureloader.d.ts","sourceRoot":"","sources":["featureloader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;GAWG;AACH,kIAVW,MAAM,GAAC,kBAAkB,UACzB,OAAO,qBAAqB,EAAE,OAAO,UACrC,OAAO,aAAa,EAAE,MAAM,cAC5B,MAAM,cACN,OAAO,sBAAsB,EAAE,OAAO,uCACT,OAAO,sBAAsB,EAAE,OAAO,KAAG,IAAI,iBAE9D,IAAI,QAkE1B;AAED;;;;;;;;;GASG;AACH,sHALW,MAAM,GAAC,kBAAkB,+IAsCnC;AAED;;;;;;GAMG;AACH,uDAJW,OAAO,QAMjB;;;;;;;;;;;;;;;;0JAxJ0B,CAAC,OAAO,iBAAiB,EAAE,OAAO,GAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,QAC/F,OAAmB,aAAa,EAAE,MAAM,QACxC,MAAkB,QAClB,OAAmB,sBAAsB,EAAE,OAAO,gBAC7B,MAAM,WAAW,CAAC,KAAG,IAAI,4BACtB,IAAI,kBAAI,IAAI;;;;;;;;;;wCAYf,OAAO,aAAa,EAAE,MAAM,QAAE,MAAM,QAAE,OAAO,sBAAsB,EAAE,OAAO,KAAG,MAAM"}
+{"version":3,"file":"featureloader.d.ts","sourceRoot":"","sources":["featureloader.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;GAWG;AACH,kIAVW,MAAM,GAAC,kBAAkB,2HAEzB,OAAO,aAAa,EAAE,MAAM,cAC5B,MAAM,cACN,OAAO,sBAAsB,EAAE,OAAO,uCACT,OAAO,sBAAsB,EAAE,OAAO,KAAG,IAAI,iBAE9D,IAAI,QAkE1B;AAED;;;;;;;;;GASG;AACH,sHALW,MAAM,GAAC,kBAAkB,+IAsCnC;AAED;;;;;;GAMG;AACH,uDAJW,OAAO,QAMjB;;;;;;;;;;;;;;;;0JAxJ0B,CAAC,OAAO,iBAAiB,EAAE,OAAO,GAAC,OAAO,iBAAiB,EAAE,OAAO,CAAC,QAC/F,OAAmB,aAAa,EAAE,MAAM,QACxC,MAAkB,QAClB,OAAmB,sBAAsB,EAAE,OAAO,gBAC7B,MAAM,WAAW,CAAC,KAAG,IAAI,4BACtB,IAAI,kBAAI,IAAI;;;;;;;;;;wCAYf,OAAO,aAAa,EAAE,MAAM,QAAE,MAAM,QAAE,OAAO,sBAAsB,EAAE,OAAO,KAAG,MAAM"}

package/featureloader.js

@@ -50,7 +50,7 @@ let withCredentials = false;
 /**
  * @template {import("./Feature.js").FeatureLike} [FeatureType=import("./Feature.js").FeatureLike]
  * @param {string|FeatureUrlFunction} url Feature URL service.
- * @param {import("./format/Feature.js").default} format Feature format.
+ * @param {import("./format/Feature.js").default<import('./format/Feature.js').FeatureToFeatureClass<FeatureType>>} format Feature format.
  * @param {import("./extent.js").Extent} extent Extent.
  * @param {number} resolution Resolution.
  * @param {import("./proj/Projection.js").default} projection Projection.

package/format/Feature.d.ts

@@ -121,13 +121,13 @@ export type FeatureObject = {
     } | undefined;
 };
 /**
- * <T>
+ * *
  */
-export type FeatureToFeatureClass<T extends import("../Feature.js").FeatureLike> = T extends import("../render/Feature.js").default ? typeof import("../render/Feature.js").default : typeof import("../Feature.js").default;
+export type FeatureToFeatureClass<T extends Feature<import("../geom.js").Geometry> | RenderFeature> = T extends RenderFeature ? typeof RenderFeature : typeof Feature;
 /**
- * <T>
+ * *
  */
-export type FeatureClassToFeature<T extends import("../Feature.js").FeatureClass> = T[keyof T] extends import("../render/Feature.js").default ? import("../render/Feature.js").default : import("../Feature.js").default;
+export type FeatureClassToFeature<T extends import("../Feature.js").FeatureClass> = T[keyof T] extends RenderFeature ? RenderFeature : Feature;
 import RenderFeature from '../render/Feature.js';
 /**
  * @typedef {Object} ReadOptions
@@ -191,12 +191,12 @@ import RenderFeature from '../render/Feature.js';
  * @property {Object<string, *>} [properties] Properties.
  */
 /***
- * @template {import("../Feature.js").FeatureLike} T
- * @typedef {T extends import("../render/Feature.js").default ? typeof import("../render/Feature.js").default : typeof import("../Feature.js").default} FeatureToFeatureClass<T>
+ * @template {Feature|RenderFeature} T
+ * @typedef {T extends RenderFeature ? typeof RenderFeature : typeof Feature} FeatureToFeatureClass
  */
 /***
  * @template {import("../Feature.js").FeatureClass} T
- * @typedef {T[keyof T] extends import("../render/Feature.js").default ? import("../render/Feature.js").default : import("../Feature.js").default} FeatureClassToFeature<T>
+ * @typedef {T[keyof T] extends RenderFeature ? RenderFeature : Feature} FeatureClassToFeature
  */
 /**
  * @classdesc
@@ -224,9 +224,9 @@ declare class FeatureFormat<T extends import("../Feature.js").FeatureClass = typ
     protected defaultFeatureProjection: import("../proj/Projection.js").default | undefined;
     /**
      * @protected
-     * @type {import("../Feature.js").FeatureClass}
+     * @type {T}
      */
-    protected featureClass: import("../Feature.js").FeatureClass;
+    protected featureClass: T;
     /**
      * A list media types supported by the format in descending order of preference.
      * @type {Array<string>}
@@ -294,20 +294,20 @@ declare class FeatureFormat<T extends import("../Feature.js").FeatureClass = typ
      * Encode a feature in this format.
      *
      * @abstract
-     * @param {import("../Feature.js").default} feature Feature.
+     * @param {Feature} feature Feature.
      * @param {WriteOptions} [options] Write options.
      * @return {string|ArrayBuffer} Result.
      */
-    writeFeature(feature: import("../Feature.js").default, options?: WriteOptions | undefined): string | ArrayBuffer;
+    writeFeature(feature: Feature, options?: WriteOptions | undefined): string | ArrayBuffer;
     /**
      * Encode an array of features in this format.
      *
      * @abstract
-     * @param {Array<import("../Feature.js").default>} features Features.
+     * @param {Array<Feature>} features Features.
      * @param {WriteOptions} [options] Write options.
      * @return {string|ArrayBuffer} Result.
      */
-    writeFeatures(features: Array<import("../Feature.js").default>, options?: WriteOptions | undefined): string | ArrayBuffer;
+    writeFeatures(features: Array<Feature>, options?: WriteOptions | undefined): string | ArrayBuffer;
     /**
      * Write a single geometry in this format.
      *

package/format/Feature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Feature.d.ts","sourceRoot":"","sources":["Feature.js"],"names":[],"mappings":"AAgSA;;;;;;GAMG;AACH,0HAJW,OAAO,uDAkDjB;AAED;;;;GAIG;AACH,mDAJW,OAAO,cAAc,EAAE,MAAM,sCAE5B,OAAO,cAAc,EAAE,MAAM,CAgBxC;AA2BD;;;;GAIG;AACH,4CAJW,aAAa,qDAEZ,aAAa,GAAC,MAAM,aAAa,CAAC,CAkC7C;AAED;;;;GAIG;AACH,uCAJW,cAAc,GAAC,IAAI,qDAElB,OAAO,qBAAqB,EAAE,OAAO,CAkBhD;;;;;;;;;;qBAnaa,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;wBASnC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;qBAOnC,OAAO,YAAY,EAAE,cAAc;;;;;;wBAInC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;mBAoBpC,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK;;;;;UAKtC,OAAO,qBAAqB,EAAE,IAAI;;;;qBAClC,MAAM,MAAM,CAAC;;;;;;;;;;uCAMd,MAAM,cAAc,CAAC;6BAIrB,oBAAoB,mBAAyB;;;;;;;;;;;;;;;;;;;;mFAY7C,CAAC,SAAS,OAAO,sBAAsB,EAAE,OAAO,GAAG,cAAc,sBAAsB,EAAE,OAAO,GAAG,cAAc,eAAe,EAAE,OAAO;;;;oFAKzI,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,OAAO,sBAAsB,EAAE,OAAO,GAAG,OAAO,sBAAsB,EAAE,OAAO,GAAG,OAAO,eAAe,EAAE,OAAO;0BAnGvH,sBAAsB;AAwBhD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;GAEG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH;IAEI;;;OAGG;IACH,0BAFU,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAE5B;IAE/B;;;OAGG;IACH,oCAFU,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAElB;IAEzC;;;OAGG;IACH,wBAFU,OAAO,eAAe,EAAE,YAAY,CAEnB;IAE3B;;;OAGG;IACH,qBAFU,MAAM,MAAM,CAAC,CAEQ;IAGjC;;;;;;OAMG;IACH,iCALW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,WAAW,GAAC,SAAS,CAsBhC;IAED;;;;;;;;OAQG;IACH,gCANW,YAAY,GAAC,WAAW,GAAC,SAAS,GAGjC,YAAY,GAAC,WAAW,GAAC,SAAS,CAY7C;IAED;;;OAGG;IACH,WAFY,IAAI,CAIf;IAED;;;;;;;OAOG;IACH,oBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,OAAO,eAAe,EAAE,WAAW,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,CAI5F;IAED;;;;;;;OAOG;IACH,qBAJW,QAAQ,GAAC,OAAO,GAAC,WAAW,SAAQ,MAAM,sCAEzC,MAAM,OAAO,eAAe,EAAE,WAAW,GAAC,sBAAsB,CAAC,CAAC,CAAC,CAI9E;IAED;;;;;;;OAOG;IACH,qBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,OAAO,qBAAqB,EAAE,OAAO,CAIhD;IAED;;;;;;OAMG;IACH,uBAHW,QAAQ,GAAC,OAAO,SAAQ,MAAM,GAC7B,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAI5D;IAED;;;;;;;OAOG;IACH,sBAJW,OAAO,eAAe,EAAE,OAAO,uCAE9B,MAAM,GAAC,WAAW,CAI7B;IAED;;;;;;;OAOG;IACH,wBAJW,MAAM,OAAO,eAAe,EAAE,OAAO,CAAC,uCAErC,MAAM,GAAC,WAAW,CAI7B;IAED;;;;;;;OAOG;IACH,wBAJW,OAAO,qBAAqB,EAAE,OAAO,uCAEpC,MAAM,GAAC,WAAW,CAI7B;CACF;oBAzRmB,eAAe"}
+{"version":3,"file":"Feature.d.ts","sourceRoot":"","sources":["Feature.js"],"names":[],"mappings":"AAgSA;;;;;;GAMG;AACH,0HAJW,OAAO,uDAkDjB;AAED;;;;GAIG;AACH,mDAJW,OAAO,cAAc,EAAE,MAAM,sCAE5B,OAAO,cAAc,EAAE,MAAM,CAgBxC;AA2BD;;;;GAIG;AACH,4CAJW,aAAa,qDAEZ,aAAa,GAAC,MAAM,aAAa,CAAC,CAkC7C;AAED;;;;GAIG;AACH,uCAJW,cAAc,GAAC,IAAI,qDAElB,OAAO,qBAAqB,EAAE,OAAO,CAkBhD;;;;;;;;;;qBAnaa,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;wBASnC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;qBAOnC,OAAO,YAAY,EAAE,cAAc;;;;;;wBAInC,OAAO,YAAY,EAAE,cAAc;;;;;;;;;;;;;;;;;;;;;;mBAoBpC,aAAa,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK;;;;;UAKtC,OAAO,qBAAqB,EAAE,IAAI;;;;qBAClC,MAAM,MAAM,CAAC;;;;;;;;;;uCAMd,MAAM,cAAc,CAAC;6BAIrB,oBAAoB,mBAAyB;;;;;;;;;;;;;;;;;;;;sGAY7C,CAAC,SAAS,aAAa,GAAG,oBAAoB,GAAG,cAAc;;;;oFAK/D,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,GAAG,OAAO;0BAnG7C,sBAAsB;AAwBhD;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;GAEG;AAEH;;;;;;GAMG;AAEH;;GAEG;AAEH;;GAEG;AAEH;;;;;GAKG;AAEH;;;GAGG;AAEH;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AACH;IAEI;;;OAGG;IACH,0BAFU,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAE5B;IAE/B;;;OAGG;IACH,oCAFU,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAElB;IAEzC;;;OAGG;IACH,wBAFU,CAAC,CAEmC;IAE9C;;;OAGG;IACH,qBAFU,MAAM,MAAM,CAAC,CAEQ;IAGjC;;;;;;OAMG;IACH,iCALW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,WAAW,GAAC,SAAS,CAsBhC;IAED;;;;;;;;OAQG;IACH,gCANW,YAAY,GAAC,WAAW,GAAC,SAAS,GAGjC,YAAY,GAAC,WAAW,GAAC,SAAS,CAY7C;IAED;;;OAGG;IACH,WAFY,IAAI,CAIf;IAED;;;;;;;OAOG;IACH,oBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,OAAO,eAAe,EAAE,WAAW,GAAC,MAAM,OAAO,sBAAsB,EAAE,OAAO,CAAC,CAI5F;IAED;;;;;;;OAOG;IACH,qBAJW,QAAQ,GAAC,OAAO,GAAC,WAAW,SAAQ,MAAM,sCAEzC,MAAM,OAAO,eAAe,EAAE,WAAW,GAAC,sBAAsB,CAAC,CAAC,CAAC,CAI9E;IAED;;;;;;;OAOG;IACH,qBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,sCAE7B,OAAO,qBAAqB,EAAE,OAAO,CAIhD;IAED;;;;;;OAMG;IACH,uBAHW,QAAQ,GAAC,OAAO,SAAQ,MAAM,GAC7B,OAAO,uBAAuB,EAAE,OAAO,GAAC,SAAS,CAI5D;IAED;;;;;;;OAOG;IACH,sBAJW,OAAO,uCAEN,MAAM,GAAC,WAAW,CAI7B;IAED;;;;;;;OAOG;IACH,wBAJW,MAAM,OAAO,CAAC,uCAEb,MAAM,GAAC,WAAW,CAI7B;IAED;;;;;;;OAOG;IACH,wBAJW,OAAO,qBAAqB,EAAE,OAAO,uCAEpC,MAAM,GAAC,WAAW,CAI7B;CACF;oBAzRmB,eAAe"}

package/format/Feature.js

@@ -95,13 +95,13 @@ import {
  */
 
 /***
- * @template {import("../Feature.js").FeatureLike} T
- * @typedef {T extends import("../render/Feature.js").default ? typeof import("../render/Feature.js").default : typeof import("../Feature.js").default} FeatureToFeatureClass<T>
+ * @template {Feature|RenderFeature} T
+ * @typedef {T extends RenderFeature ? typeof RenderFeature : typeof Feature} FeatureToFeatureClass
  */
 
 /***
  * @template {import("../Feature.js").FeatureClass} T
- * @typedef {T[keyof T] extends import("../render/Feature.js").default ? import("../render/Feature.js").default : import("../Feature.js").default} FeatureClassToFeature<T>
+ * @typedef {T[keyof T] extends RenderFeature ? RenderFeature : Feature} FeatureClassToFeature
  */
 
 /**
@@ -133,9 +133,9 @@ class FeatureFormat {
 
     /**
      * @protected
-     * @type {import("../Feature.js").FeatureClass}
+     * @type {T}
      */
-    this.featureClass = Feature;
+    this.featureClass = /** @type {T} */ (Feature);
 
     /**
      * A list media types supported by the format in descending order of preference.
@@ -251,7 +251,7 @@ class FeatureFormat {
    * Encode a feature in this format.
    *
    * @abstract
-   * @param {import("../Feature.js").default} feature Feature.
+   * @param {Feature} feature Feature.
    * @param {WriteOptions} [options] Write options.
    * @return {string|ArrayBuffer} Result.
    */
@@ -263,7 +263,7 @@ class FeatureFormat {
    * Encode an array of features in this format.
    *
    * @abstract
-   * @param {Array<import("../Feature.js").default>} features Features.
+   * @param {Array<Feature>} features Features.
    * @param {WriteOptions} [options] Write options.
    * @return {string|ArrayBuffer} Result.
    */

package/format/MVT.d.ts

@@ -51,11 +51,6 @@ declare class MVT<T extends import("../Feature.js").FeatureClass = typeof Render
      * @param {Options<T>} [options] Options.
      */
     constructor(options?: Options<T> | undefined);
-    /**
-     * @private
-     * @type {import("../Feature.js").FeatureClass}
-     */
-    private featureClass_;
     /**
      * @private
      * @type {string|undefined}

package/format/MVT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MVT.d.ts","sourceRoot":"","sources":["MVT.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;GAOG;AACH;IACE;;OAEG;IACH,8CAiDC;IApCC;;;OAGG;IACH,sBAEiB;IAEjB;;;OAGG;IACH,sBAAyC;IAEzC;;;OAGG;IACH,mBAAiE;IAEjE;;;OAGG;IACH,gBAAqD;IAErD;;;OAGG;IACH,oBAAqC;IAQvC;;;;;;;;OAQG;IACH,yBAoDC;IAED;;;;;;OAMG;IACH,uBAuEC;IASD;;;;;;;OAOG;IACH,qBALW,WAAW,6DAEV,MAAM,OAAO,cAAc,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAkCjE;IAED;;;;;;OAMG;IACH,uBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,GAC7B,OAAO,uBAAuB,EAAE,OAAO,CAKlD;IAED;;;;OAIG;IACH,kBAHW,MAAM,MAAM,CAAC,QAKvB;CACF;0BAnSyB,sBAAsB;0BATU,cAAc"}
+{"version":3,"file":"MVT.d.ts","sourceRoot":"","sources":["MVT.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA;;;;;;;;;;;;GAYG;AAEH;;;;;;;GAOG;AACH;IACE;;OAEG;IACH,8CA6CC;IA5BC;;;OAGG;IACH,sBAAyC;IAEzC;;;OAGG;IACH,mBAAiE;IAEjE;;;OAGG;IACH,gBAAqD;IAErD;;;OAGG;IACH,oBAAqC;IAQvC;;;;;;;;OAQG;IACH,yBAoDC;IAED;;;;;;OAMG;IACH,uBAuEC;IASD;;;;;;;OAOG;IACH,qBALW,WAAW,6DAEV,MAAM,OAAO,cAAc,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAC,CAkCjE;IAED;;;;;;OAMG;IACH,uBAJW,QAAQ,GAAC,OAAO,SAAQ,MAAM,GAC7B,OAAO,uBAAuB,EAAE,OAAO,CAKlD;IAED;;;;OAIG;IACH,kBAHW,MAAM,MAAM,CAAC,QAKvB;CACF;0BA/RyB,sBAAsB;0BATU,cAAc"}

package/format/MVT.js

@@ -55,13 +55,9 @@ class MVT extends FeatureFormat {
       units: 'tile-pixels',
     });
 
-    /**
-     * @private
-     * @type {import("../Feature.js").FeatureClass}
-     */
-    this.featureClass_ = options.featureClass
+    this.featureClass = options.featureClass
       ? options.featureClass
-      : RenderFeature;
+      : /** @type {T} */ (RenderFeature);
 
     /**
      * @private
@@ -188,8 +184,8 @@ class MVT extends FeatureFormat {
 
     const geometryType = getGeometryType(type, ends.length);
 
-    if (this.featureClass_ === RenderFeature) {
-      feature = new this.featureClass_(
+    if (this.featureClass === RenderFeature) {
+      feature = new /** @type {typeof RenderFeature} */ (this.featureClass)(
         geometryType,
         flatCoordinates,
         ends,
@@ -219,7 +215,7 @@ class MVT extends FeatureFormat {
                   : null;
       }
       const ctor = /** @type {typeof import("../Feature.js").default} */ (
-        this.featureClass_
+        this.featureClass
       );
       feature = new ctor();
       if (this.geometryName_) {

package/layer/Vector.d.ts

@@ -1,4 +1,159 @@
 export default VectorLayer;
+export type Options<FeatureType extends import("../Feature.js").FeatureLike> = {
+    /**
+     * A CSS class name to set to the layer element.
+     */
+    className?: string | undefined;
+    /**
+     * Opacity (0, 1).
+     */
+    opacity?: number | undefined;
+    /**
+     * Visibility.
+     */
+    visible?: boolean | undefined;
+    /**
+     * The bounding extent for layer rendering.  The layer will not be
+     * rendered outside of this extent.
+     */
+    extent?: import("../extent.js").Extent | undefined;
+    /**
+     * The z-index for layer rendering.  At rendering time, the layers
+     * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed
+     * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`
+     * method was used.
+     */
+    zIndex?: number | undefined;
+    /**
+     * The minimum resolution (inclusive) at which this layer will be
+     * visible.
+     */
+    minResolution?: number | undefined;
+    /**
+     * The maximum resolution (exclusive) below which this layer will
+     * be visible.
+     */
+    maxResolution?: number | undefined;
+    /**
+     * The minimum view zoom level (exclusive) above which this layer will be
+     * visible.
+     */
+    minZoom?: number | undefined;
+    /**
+     * The maximum view zoom level (inclusive) at which this layer will
+     * be visible.
+     */
+    maxZoom?: number | undefined;
+    /**
+     * Render order. Function to be used when sorting
+     * features before rendering. By default features are drawn in the order that they are created. Use
+     * `null` to avoid the sort, but get an undefined draw order.
+     */
+    renderOrder?: import("../render.js").OrderFunction | undefined;
+    /**
+     * The buffer in pixels around the viewport extent used by the
+     * renderer when getting features from the vector source for the rendering or hit-detection.
+     * Recommended value: the size of the largest symbol, line width or label.
+     */
+    renderBuffer?: number | undefined;
+    /**
+     * Source.
+     */
+    source?: import("../source/Vector.js").default<FeatureType> | undefined;
+    /**
+     * Sets the layer as overlay on a map. The map will not manage
+     * this layer in its layers collection, and the layer will be rendered on top. This is useful for
+     * temporary layers. The standard way to add a layer to a map and have it managed by the map is to
+     * use [map.addLayer()]{@link import ("../Map.js").default#addLayer}.
+     */
+    map?: import("../Map.js").default | undefined;
+    /**
+     * Declutter images and text. Any truthy value will enable
+     * decluttering. Within a layer, a feature rendered before another has higher priority. All layers with the
+     * same `declutter` value will be decluttered together. The priority is determined by the drawing order of the
+     * layers with the same `declutter` value. Higher in the layer stack means higher priority. To declutter distinct
+     * layers or groups of layers separately, use different truthy values for `declutter`.
+     */
+    declutter?: string | number | boolean | undefined;
+    /**
+     * Layer style. When set to `null`, only
+     * features that have their own style will be rendered. See {@link module :ol/style/Style~Style} for the default style
+     * which will be used if this is not set.
+     */
+    style?: import("../style/Style.js").StyleLike | import("../style/flat.js").FlatStyleLike | null | undefined;
+    /**
+     * Background color for the layer. If not specified, no background
+     * will be rendered.
+     */
+    background?: import("./Base.js").BackgroundColor | undefined;
+    /**
+     * When set to `true`, feature batches will
+     * be recreated during animations. This means that no vectors will be shown clipped, but the
+     * setting will have a performance impact for large amounts of vector data. When set to `false`,
+     * batches will be recreated when no animation is active.
+     */
+    updateWhileAnimating?: boolean | undefined;
+    /**
+     * When set to `true`, feature batches will
+     * be recreated during interactions. See also `updateWhileAnimating`.
+     */
+    updateWhileInteracting?: boolean | undefined;
+    /**
+     * Arbitrary observable properties. Can be accessed with `#get()` and `#set()`.
+     */
+    properties?: {
+        [x: string]: any;
+    } | undefined;
+};
+/**
+ * @template {import('../Feature.js').FeatureLike} FeatureType
+ * @typedef {Object} Options
+ * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.
+ * @property {number} [opacity=1] Opacity (0, 1).
+ * @property {boolean} [visible=true] Visibility.
+ * @property {import("../extent.js").Extent} [extent] The bounding extent for layer rendering.  The layer will not be
+ * rendered outside of this extent.
+ * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers
+ * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed
+ * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`
+ * method was used.
+ * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be
+ * visible.
+ * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will
+ * be visible.
+ * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be
+ * visible.
+ * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will
+ * be visible.
+ * @property {import("../render.js").OrderFunction} [renderOrder] Render order. Function to be used when sorting
+ * features before rendering. By default features are drawn in the order that they are created. Use
+ * `null` to avoid the sort, but get an undefined draw order.
+ * @property {number} [renderBuffer=100] The buffer in pixels around the viewport extent used by the
+ * renderer when getting features from the vector source for the rendering or hit-detection.
+ * Recommended value: the size of the largest symbol, line width or label.
+ * @property {import("../source/Vector.js").default<FeatureType>} [source] Source.
+ * @property {import("../Map.js").default} [map] Sets the layer as overlay on a map. The map will not manage
+ * this layer in its layers collection, and the layer will be rendered on top. This is useful for
+ * temporary layers. The standard way to add a layer to a map and have it managed by the map is to
+ * use [map.addLayer()]{@link import("../Map.js").default#addLayer}.
+ * @property {boolean|string|number} [declutter=false] Declutter images and text. Any truthy value will enable
+ * decluttering. Within a layer, a feature rendered before another has higher priority. All layers with the
+ * same `declutter` value will be decluttered together. The priority is determined by the drawing order of the
+ * layers with the same `declutter` value. Higher in the layer stack means higher priority. To declutter distinct
+ * layers or groups of layers separately, use different truthy values for `declutter`.
+ * @property {import("../style/Style.js").StyleLike|import("../style/flat.js").FlatStyleLike|null} [style] Layer style. When set to `null`, only
+ * features that have their own style will be rendered. See {@link module:ol/style/Style~Style} for the default style
+ * which will be used if this is not set.
+ * @property {import("./Base.js").BackgroundColor} [background] Background color for the layer. If not specified, no background
+ * will be rendered.
+ * @property {boolean} [updateWhileAnimating=false] When set to `true`, feature batches will
+ * be recreated during animations. This means that no vectors will be shown clipped, but the
+ * setting will have a performance impact for large amounts of vector data. When set to `false`,
+ * batches will be recreated when no animation is active.
+ * @property {boolean} [updateWhileInteracting=false] When set to `true`, feature batches will
+ * be recreated during interactions. See also `updateWhileAnimating`.
+ * @property {Object<string, *>} [properties] Arbitrary observable properties. Can be accessed with `#get()` and `#set()`.
+ */
 /**
  * @classdesc
  * Vector data is rendered client-side, as vectors. This layer type provides most accurate rendering
@@ -16,9 +171,9 @@ export default VectorLayer;
  */
 declare class VectorLayer<FeatureType extends import("../Feature.js").FeatureLike> extends BaseVectorLayer<import("../source/Vector.js").default<FeatureType>, CanvasVectorLayerRenderer> {
     /**
-     * @param {import("./BaseVector.js").Options<import("../source/Vector.js").default<FeatureType>>} [options] Options.
+     * @param {Options<FeatureType>} [options] Options.
      */
-    constructor(options?: import("./BaseVector.js").Options<import("../source/Vector.js").default<FeatureType>> | undefined);
+    constructor(options?: Options<FeatureType> | undefined);
 }
 import CanvasVectorLayerRenderer from '../renderer/canvas/VectorLayer.js';
 import BaseVectorLayer from './BaseVector.js';

package/layer/Vector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector.d.ts","sourceRoot":"","sources":["Vector.js"],"names":[],"mappings":";AAMA;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,yHAEC;CAKF;sCA5BqC,mCAAmC;4BAD7C,iBAAiB"}
+{"version":3,"file":"Vector.d.ts","sourceRoot":"","sources":["Vector.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH;;;;;;;;;;;;;;GAcG;AACH;IACE;;OAEG;IACH,wDAEC;CAKF;sCA9EqC,mCAAmC;4BAD7C,iBAAiB"}

package/layer/Vector.js

@@ -4,6 +4,56 @@
 import BaseVectorLayer from './BaseVector.js';
 import CanvasVectorLayerRenderer from '../renderer/canvas/VectorLayer.js';
 
+/**
+ * @template {import('../Feature.js').FeatureLike} FeatureType
+ * @typedef {Object} Options
+ * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.
+ * @property {number} [opacity=1] Opacity (0, 1).
+ * @property {boolean} [visible=true] Visibility.
+ * @property {import("../extent.js").Extent} [extent] The bounding extent for layer rendering.  The layer will not be
+ * rendered outside of this extent.
+ * @property {number} [zIndex] The z-index for layer rendering.  At rendering time, the layers
+ * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed
+ * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`
+ * method was used.
+ * @property {number} [minResolution] The minimum resolution (inclusive) at which this layer will be
+ * visible.
+ * @property {number} [maxResolution] The maximum resolution (exclusive) below which this layer will
+ * be visible.
+ * @property {number} [minZoom] The minimum view zoom level (exclusive) above which this layer will be
+ * visible.
+ * @property {number} [maxZoom] The maximum view zoom level (inclusive) at which this layer will
+ * be visible.
+ * @property {import("../render.js").OrderFunction} [renderOrder] Render order. Function to be used when sorting
+ * features before rendering. By default features are drawn in the order that they are created. Use
+ * `null` to avoid the sort, but get an undefined draw order.
+ * @property {number} [renderBuffer=100] The buffer in pixels around the viewport extent used by the
+ * renderer when getting features from the vector source for the rendering or hit-detection.
+ * Recommended value: the size of the largest symbol, line width or label.
+ * @property {import("../source/Vector.js").default<FeatureType>} [source] Source.
+ * @property {import("../Map.js").default} [map] Sets the layer as overlay on a map. The map will not manage
+ * this layer in its layers collection, and the layer will be rendered on top. This is useful for
+ * temporary layers. The standard way to add a layer to a map and have it managed by the map is to
+ * use [map.addLayer()]{@link import("../Map.js").default#addLayer}.
+ * @property {boolean|string|number} [declutter=false] Declutter images and text. Any truthy value will enable
+ * decluttering. Within a layer, a feature rendered before another has higher priority. All layers with the
+ * same `declutter` value will be decluttered together. The priority is determined by the drawing order of the
+ * layers with the same `declutter` value. Higher in the layer stack means higher priority. To declutter distinct
+ * layers or groups of layers separately, use different truthy values for `declutter`.
+ * @property {import("../style/Style.js").StyleLike|import("../style/flat.js").FlatStyleLike|null} [style] Layer style. When set to `null`, only
+ * features that have their own style will be rendered. See {@link module:ol/style/Style~Style} for the default style
+ * which will be used if this is not set.
+ * @property {import("./Base.js").BackgroundColor} [background] Background color for the layer. If not specified, no background
+ * will be rendered.
+ * @property {boolean} [updateWhileAnimating=false] When set to `true`, feature batches will
+ * be recreated during animations. This means that no vectors will be shown clipped, but the
+ * setting will have a performance impact for large amounts of vector data. When set to `false`,
+ * batches will be recreated when no animation is active.
+ * @property {boolean} [updateWhileInteracting=false] When set to `true`, feature batches will
+ * be recreated during interactions. See also `updateWhileAnimating`.
+ * @property {Object<string, *>} [properties] Arbitrary observable properties. Can be accessed with `#get()` and `#set()`.
+ */
+
 /**
  * @classdesc
  * Vector data is rendered client-side, as vectors. This layer type provides most accurate rendering
@@ -21,7 +71,7 @@ import CanvasVectorLayerRenderer from '../renderer/canvas/VectorLayer.js';
  */
 class VectorLayer extends BaseVectorLayer {
   /**
-   * @param {import("./BaseVector.js").Options<import("../source/Vector.js").default<FeatureType>>} [options] Options.
+   * @param {Options<FeatureType>} [options] Options.
    */
   constructor(options) {
     super(options);

package/layer/VectorTile.d.ts

@@ -4,7 +4,134 @@ export default VectorTileLayer;
  */
 export type VectorTileLayerOnSignature<Return> = import("../Observable").OnSignature<import("../Observable").EventTypes, import("../events/Event.js").default, Return> & import("../Observable").OnSignature<import("./Base").BaseLayerObjectEventTypes | import("./Layer.js").LayerEventType | 'change:preload' | 'change:useInterimTilesOnError', import("../Object").ObjectEvent, Return> & import("../Observable").OnSignature<import("../render/EventType").LayerRenderEventTypes, import("../render/Event").default, Return> & import("../Observable").CombinedOnSignature<import("../Observable").EventTypes | import("./Base").BaseLayerObjectEventTypes | import("./Layer.js").LayerEventType | 'change:preload' | 'change:useInterimTilesOnError' | import("../render/EventType").LayerRenderEventTypes, Return>;
 export type VectorTileRenderType = 'hybrid' | 'vector';
-export type Options = any;
+export type Options<FeatureType extends import("../Feature").FeatureLike> = {
+    /**
+     * A CSS class name to set to the layer element.
+     */
+    className?: string | undefined;
+    /**
+     * Opacity (0, 1).
+     */
+    opacity?: number | undefined;
+    /**
+     * Visibility.
+     */
+    visible?: boolean | undefined;
+    /**
+     * The bounding extent for layer rendering.  The layer will not be
+     * rendered outside of this extent.
+     */
+    extent?: import("../extent.js").Extent | undefined;
+    /**
+     * The z-index for layer rendering.  At rendering time, the layers
+     * will be ordered, first by Z-index and then by position. When `undefined`, a `zIndex` of 0 is assumed
+     * for layers that are added to the map's `layers` collection, or `Infinity` when the layer's `setMap()`
+     * method was used.
+     */
+    zIndex?: number | undefined;
+    /**
+     * The minimum resolution (inclusive) at which this layer will be
+     * visible.
+     */
+    minResolution?: number | undefined;
+    /**
+     * The maximum resolution (exclusive) below which this layer will
+     * be visible.
+     */
+    maxResolution?: number | undefined;
+    /**
+     * The minimum view zoom level (exclusive) above which this layer will be
+     * visible.
+     */
+    minZoom?: number | undefined;
+    /**
+     * The maximum view zoom level (inclusive) at which this layer will
+     * be visible.
+     */
+    maxZoom?: number | undefined;
+    /**
+     * Render order. Function to be used when sorting
+     * features before rendering. By default features are drawn in the order that they are created. Use
+     * `null` to avoid the sort, but get an undefined draw order.
+     */
+    renderOrder?: import("../render.js").OrderFunction | undefined;
+    /**
+     * The buffer in pixels around the tile extent used by the
+     * renderer when getting features from the vector tile for the rendering or hit-detection.
+     * Recommended value: Vector tiles are usually generated with a buffer, so this value should match
+     * the largest possible buffer of the used tiles. It should be at least the size of the largest
+     * point symbol or line width.
+     */
+    renderBuffer?: number | undefined;
+    /**
+     * Render mode for vector tiles:
+     * * `'hybrid'`: Polygon and line elements are rendered as images, so pixels are scaled during zoom
+     * animations. Point symbols and texts are accurately rendered as vectors and can stay upright on
+     * rotated views, but get lifted above all polygon and line elements.
+     * * `'vector'`: Everything is rendered as vectors and the original render order is maintained. Use
+     * this mode for improved performance and visual epxerience on vector tile layers with not too many
+     * rendered features (e.g. for highlighting a subset of features of another layer with the same
+     * source).
+     */
+    renderMode?: VectorTileRenderType | undefined;
+    /**
+     * Source.
+     */
+    source?: import("../source/VectorTile.js").default<FeatureType> | undefined;
+    /**
+     * Sets the layer as overlay on a map. The map will not manage
+     * this layer in its layers collection, and the layer will be rendered on top. This is useful for
+     * temporary layers. The standard way to add a layer to a map and have it managed by the map is to
+     * use [map.addLayer()]{@link import ("../Map.js").default#addLayer}.
+     */
+    map?: import("../Map.js").default | undefined;
+    /**
+     * Declutter images and text. Any truthy value will enable
+     * decluttering. Within a layer, a feature rendered before another has higher priority. All layers with the
+     * same `declutter` value will be decluttered together. The priority is determined by the drawing order of the
+     * layers with the same `declutter` value. Higher in the layer stack means higher priority. To declutter distinct
+     * layers or groups of layers separately, use different truthy values for `declutter`.
+     */
+    declutter?: string | number | boolean | undefined;
+    /**
+     * Layer style. When set to `null`, only
+     * features that have their own style will be rendered. See {@link module :ol/style/Style~Style} for the default style
+     * which will be used if this is not set.
+     */
+    style?: import("../style/Style.js").StyleLike | null | undefined;
+    /**
+     * Background color for the layer. If not specified, no
+     * background will be rendered.
+     */
+    background?: import("./Base").BackgroundColor | undefined;
+    /**
+     * When set to `true`, feature batches will be
+     * recreated during animations. This means that no vectors will be shown clipped, but the setting
+     * will have a performance impact for large amounts of vector data. When set to `false`, batches
+     * will be recreated when no animation is active.
+     */
+    updateWhileAnimating?: boolean | undefined;
+    /**
+     * When set to `true`, feature batches will be
+     * recreated during interactions. See also `updateWhileAnimating`.
+     */
+    updateWhileInteracting?: boolean | undefined;
+    /**
+     * Preload. Load low-resolution tiles up to `preload` levels. `0`
+     * means no preloading.
+     */
+    preload?: number | undefined;
+    /**
+     * Use interim tiles on error.
+     */
+    useInterimTilesOnError?: boolean | undefined;
+    /**
+     * Arbitrary observable properties. Can be accessed with `#get()` and `#set()`.
+     */
+    properties?: {
+        [x: string]: any;
+    } | undefined;
+};
 /***
  * @template Return
  * @typedef {import("../Observable").OnSignature<import("../Observable").EventTypes, import("../events/Event.js").default, Return> &
@@ -18,8 +145,8 @@ export type Options = any;
  * @typedef {'hybrid' | 'vector'} VectorTileRenderType
  */
 /**
+ * @template {import('../Feature').FeatureLike} FeatureType
  * @typedef {Object} Options
- * @template {import("../source/VectorTile.js").default<import('../Feature').FeatureLike>} VectorTileSourceType
  * @property {string} [className='ol-layer'] A CSS class name to set to the layer element.
  * @property {number} [opacity=1] Opacity (0, 1).
  * @property {boolean} [visible=true] Visibility.
@@ -53,7 +180,7 @@ export type Options = any;
  *    this mode for improved performance and visual epxerience on vector tile layers with not too many
  *    rendered features (e.g. for highlighting a subset of features of another layer with the same
  *    source).
- * @property {VectorTileSourceType} [source] Source.
+ * @property {import("../source/VectorTile.js").default<FeatureType>} [source] Source.
  * @property {import("../Map.js").default} [map] Sets the layer as overlay on a map. The map will not manage
  * this layer in its layers collection, and the layer will be rendered on top. This is useful for
  * temporary layers. The standard way to add a layer to a map and have it managed by the map is to
@@ -66,7 +193,7 @@ export type Options = any;
  * @property {import("../style/Style.js").StyleLike|null} [style] Layer style. When set to `null`, only
  * features that have their own style will be rendered. See {@link module:ol/style/Style~Style} for the default style
  * which will be used if this is not set.
- * @property {import("./Base.js").BackgroundColor|false} [background] Background color for the layer. If not specified, no
+ * @property {import("./Base.js").BackgroundColor} [background] Background color for the layer. If not specified, no
  * background will be rendered.
  * @property {boolean} [updateWhileAnimating=false] When set to `true`, feature batches will be
  * recreated during animations. This means that no vectors will be shown clipped, but the setting
@@ -86,16 +213,15 @@ export type Options = any;
  * property on the layer object; for example, setting `title: 'My Title'` in the
  * options means that `title` is observable, and has get/set accessors.
  *
- * @param {Options} [options] Options.
  * @template {import('../Feature').FeatureLike} FeatureType
  * @extends {BaseVectorLayer<import("../source/VectorTile.js").default<FeatureType>, CanvasVectorTileLayerRenderer>}
  * @api
  */
 declare class VectorTileLayer<FeatureType extends import("../Feature").FeatureLike> extends BaseVectorLayer<import("../source/VectorTile.js").default<FeatureType>, CanvasVectorTileLayerRenderer> {
     /**
-     * @param {Options} [options] Options.
+     * @param {Options<FeatureType>} [options] Options.
      */
-    constructor(options?: Options);
+    constructor(options?: Options<FeatureType> | undefined);
     /***
      * @type {VectorTileLayerOnSignature<import("../events").EventsKey>}
      */