ol 10.3.2-dev.1737449234314 → 10.3.2-dev.1737622602778

package/expr/expression.d.ts

@@ -31,6 +31,7 @@ export function isType(type: number, expected: number): boolean;
  * @property {Set<string>} properties Properties referenced with the 'get' operator.
  * @property {boolean} featureId The style uses the feature id.
  * @property {boolean} geometryType The style uses the feature geometry type.
+ * @property {boolean} mapState The style uses the map state (view state or time elapsed).
  */
 /**
  * @return {ParsingContext} A new parsing context.
@@ -107,6 +108,10 @@ export type ParsingContext = {
      * The style uses the feature geometry type.
      */
     geometryType: boolean;
+    /**
+     * The style uses the map state (view state or time elapsed).
+     */
+    mapState: boolean;
 };
 export type EncodedExpression = LiteralValue | any[];
 /**

package/expr/expression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AAoKA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAmCD;;GAEG;AAEH;;;;;;GAMG;AAEH;;GAEG;AACH,qCAFY,cAAc,CASzB;AAED;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,gBACjB,MAAM,WACN,cAAc,GACb,UAAU,CA6FrB;AAuoBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AA/4BD,uBAAwB,CAAC,CAAC;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,8BAAwC;AACxC,6BAAiD;AAqEjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAUtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,EAAA,EAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AAiID;;GAEG;AACH;;EAgDE;yBAjLW,iBAAiB,GAAC,cAAc;;;;;eAK/B,GAAG,CAAC,MAAM,CAAC;;;;gBACX,GAAG,CAAC,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;gCAgBR,YAAY,QAAM;;;;;2BAyUlB,CAAS,IAAwB,EAAxB,KAAK,CAAC,iBAAiB,CAAC,EAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,KAAK,CAAC,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BApdjF,KAAK,CAAC,GAAC,CAAC,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAkF1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;qBAqNnC,CAAS,IAAK,SAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,UAAU"}
+{"version":3,"file":"expression.d.ts","sourceRoot":"","sources":["expression.js"],"names":[],"mappings":"AAoKA;;;;GAIG;AACH,+BAHW,MAAM,GACL,MAAM,CAgBjB;AAED;;;;GAIG;AACH,oCAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,sCAJW,MAAM,aACN,MAAM,GACL,OAAO,CAIlB;AAED;;;;GAIG;AACH,6BAJW,MAAM,YACN,MAAM,GACL,OAAO,CAIlB;AAmCD;;GAEG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH,qCAFY,cAAc,CAUzB;AAED;;GAEG;AAEH;;;;;GAKG;AACH,+BALW,iBAAiB,gBACjB,MAAM,WACN,cAAc,GACb,UAAU,CA6FrB;AA8oBD;;;;GAIG;AACH,8CAHW,OAAO,qBAAqB,EAAE,OAAO,GAAC,OAAO,sBAAsB,EAAE,OAAO,GAC3E,OAAO,GAAC,YAAY,GAAC,SAAS,GAAC,EAAE,CA2B5C;AAx5BD,uBAAwB,CAAC,CAAC;AAC1B,iCAA2C;AAC3C,gCAA0C;AAC1C,gCAA0C;AAC1C,+BAAyC;AACzC,qCAA+C;AAC/C,8BAAwC;AACxC,6BAAiD;AAqEjD;;GAEG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,YAAY,EAUtB;IAFC,aAAgB;IAChB,oBAAkB;CAErB;AAED;IACE;;;;OAIG;IACH,kBAJW,MAAM,YACN,MAAM,WACH,UAAU,EAAA,EAMvB;IAHC,aAAgB;IAChB,iBAAwB;IACxB,mBAAgB;CAEnB;AAmID;;GAEG;AACH;;EAgDE;yBAnLW,iBAAiB,GAAC,cAAc;;;;;eAK/B,GAAG,CAAC,MAAM,CAAC;;;;gBACX,GAAG,CAAC,MAAM,CAAC;;;;eACX,OAAO;;;;kBACP,OAAO;;;;cACP,OAAO;;gCAiBR,YAAY,QAAM;;;;;2BAyUlB,CAAS,IAAwB,EAAxB,KAAK,CAAC,iBAAiB,CAAC,EAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,KAAK,CAAC,UAAU,CAAC,GAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAtdjF,KAAK,CAAC,GAAC,CAAC,GAAC,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,MAAM,GAAC,OAAO;2BAkF1D,OAAO,GAAC,MAAM,GAAC,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;qBAuNnC,CAAS,IAAK,SAAE,IAAM,EAAN,MAAM,EAAE,IAAc,EAAd,cAAc,KAAE,UAAU"}

package/expr/expression.js

@@ -253,6 +253,7 @@ export class CallExpression {
  * @property {Set<string>} properties Properties referenced with the 'get' operator.
  * @property {boolean} featureId The style uses the feature id.
  * @property {boolean} geometryType The style uses the feature geometry type.
+ * @property {boolean} mapState The style uses the map state (view state or time elapsed).
  */
 
 /**
@@ -264,6 +265,7 @@ export function newParsingContext() {
     properties: new Set(),
     featureId: false,
     geometryType: false,
+    mapState: false,
   };
 }
 
@@ -443,9 +445,9 @@ const parsers = {
   ),
   [Ops.GeometryType]: createCallExpressionParser(usesGeometryType, withNoArgs),
   [Ops.LineMetric]: createCallExpressionParser(withNoArgs),
-  [Ops.Resolution]: createCallExpressionParser(withNoArgs),
-  [Ops.Zoom]: createCallExpressionParser(withNoArgs),
-  [Ops.Time]: createCallExpressionParser(withNoArgs),
+  [Ops.Resolution]: createCallExpressionParser(usesMapState, withNoArgs),
+  [Ops.Zoom]: createCallExpressionParser(usesMapState, withNoArgs),
+  [Ops.Time]: createCallExpressionParser(usesMapState, withNoArgs),
   [Ops.Any]: createCallExpressionParser(
     hasArgsCount(2, Infinity),
     withArgsOfType(BooleanType),
@@ -660,6 +662,13 @@ function usesGeometryType(encoded, returnType, context) {
   context.geometryType = true;
 }
 
+/**
+ * @type {ArgValidator}
+ */
+function usesMapState(encoded, returnType, context) {
+  context.mapState = true;
+}
+
 /**
  * @type {ArgValidator}
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ol",
-  "version": "10.3.2-dev.1737449234314",
+  "version": "10.3.2-dev.1737622602778",
   "description": "OpenLayers mapping library",
   "keywords": [
     "map",

package/render/webgl/MixedGeometryBatch.d.ts

@@ -168,7 +168,7 @@ declare class MixedGeometryBatch {
     private uidToRef_;
     /**
      * The precision in WebGL shaders is limited.
-     * To keep the refs as small as possible we maintain an array of returned references.
+     * To keep the refs as small as possible we maintain an array of freed up references.
      * @type {Array<number>}
      * @private
      */
@@ -259,6 +259,14 @@ declare class MixedGeometryBatch {
      * @return {Feature|RenderFeature} feature
      */
     getFeatureFromRef(ref: number): Feature | RenderFeature;
+    isEmpty(): boolean;
+    /**
+     * Will return a new instance of this class that only contains the features
+     * for which the provided callback returned true
+     * @param {function((Feature|RenderFeature)): boolean} featureFilter Feature filter callback
+     * @return {MixedGeometryBatch} Filtered geometry batch
+     */
+    filter(featureFilter: (arg0: (Feature | RenderFeature)) => boolean): MixedGeometryBatch;
 }
 import RenderFeature from '../../render/Feature.js';
 //# sourceMappingURL=MixedGeometryBatch.d.ts.map

package/render/webgl/MixedGeometryBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,kBAAkB,EAAE,OAAO;2BAGlC,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;4BAQrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;;;;;;;qBAO9D,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;qBAON,MAAM;;;;mBACN,MAAM;;;;;;;;;;;;;;;;qBAON,MAAM;;AA1CpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;OAEG;IACH,uBAAuB;IAEvB;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,uBAAwB;IAExB;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,KAAK,CAAC,OAAO,GAAC,aAAa,CAAC,wBAC5B,OAAO,eAAe,EAAE,iBAAiB,QAMnD;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,wBACrB,OAAO,eAAe,EAAE,iBAAiB,QAYnD;IAED;;;;OAIG;IACH,uCASC;IAED;;;;OAIG;IACH,4CAUC;IAED;;;;OAIG;IACH,yCAWC;IAED;;;;OAIG;IACH,qBA2GC;IAED;;;;;;;;;OASG;IACH,wBAyJC;IAED;;;;;OAKG;IACH,uBAYC;IAED;;;;;OAKG;IACH,mBAOC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAU/B;IAED,cAcC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,GAAC,aAAa,CAIhC;CACF;0BApjByB,yBAAyB"}
+{"version":3,"file":"MixedGeometryBatch.d.ts","sourceRoot":"","sources":["MixedGeometryBatch.js"],"names":[],"mappings":";sBAQa,OAAO,kBAAkB,EAAE,OAAO;2BAGlC,OAAO,wBAAwB,EAAE,IAAI;;;;;;;;aAKpC,OAAO,GAAC,aAAa;;;;iBACrB,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;4BAQrB,kBAAkB,GAAC,uBAAuB,GAAC,oBAAoB;;;;;;;;;;;;;;;qBAO9D,MAAM;;;;mBACN,MAAM;;;;gBACN,MAAM;;;;;;;;;;;;;;;;qBAON,MAAM;;;;mBACN,MAAM;;;;;;;;;;;;;;;;qBAON,MAAM;;AA1CpB;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH;IAEI;;OAEG;IACH,uBAAuB;IAEvB;;;;OAIG;IACH,sBAA8B;IAE9B;;;;OAIG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,uBAAwB;IAExB;;OAEG;IACH,cAFU,oBAAoB,CAO7B;IAED;;OAEG;IACH,YAFU,kBAAkB,CAK3B;IAED;;OAEG;IACH,iBAFU,uBAAuB,CAMhC;IAGH;;;OAGG;IACH,sBAHW,KAAK,CAAC,OAAO,GAAC,aAAa,CAAC,wBAC5B,OAAO,eAAe,EAAE,iBAAiB,QAMnD;IAED;;;OAGG;IACH,oBAHW,OAAO,GAAC,aAAa,wBACrB,OAAO,eAAe,EAAE,iBAAiB,QAYnD;IAED;;;;OAIG;IACH,uCASC;IAED;;;;OAIG;IACH,4CAUC;IAED;;;;OAIG;IACH,yCAWC;IAED;;;;OAIG;IACH,qBA2GC;IAED;;;;;;;;;OASG;IACH,wBAyJC;IAED;;;;;OAKG;IACH,uBAYC;IAED;;;;;OAKG;IACH,mBAOC;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED;;OAEG;IACH,uBAFW,OAAO,GAAC,aAAa,QAS/B;IAED,cAcC;IAED;;;;OAIG;IACH,uBAHW,MAAM,GACL,OAAO,GAAC,aAAa,CAIhC;IAED,mBAEC;IAED;;;;;OAKG;IACH,sBAHW,CAAS,IAAuB,EAAvB,CAAC,OAAO,GAAC,aAAa,CAAC,KAAG,OAAO,GACzC,kBAAkB,CAU7B;CACF;0BAvkByB,yBAAyB"}

package/render/webgl/MixedGeometryBatch.js

@@ -92,7 +92,7 @@ class MixedGeometryBatch {
 
     /**
      * The precision in WebGL shaders is limited.
-     * To keep the refs as small as possible we maintain an array of returned references.
+     * To keep the refs as small as possible we maintain an array of freed up references.
      * @type {Array<number>}
      * @private
      */
@@ -533,8 +533,7 @@ class MixedGeometryBatch {
    * @param {Feature|RenderFeature} feature Feature
    */
   removeFeature(feature) {
-    let entry;
-    entry = this.clearFeatureEntryInPointBatch_(feature) || entry;
+    let entry = this.clearFeatureEntryInPointBatch_(feature);
     entry = this.clearFeatureEntryInPolygonBatch_(feature) || entry;
     entry = this.clearFeatureEntryInLineStringBatch_(feature) || entry;
     if (entry) {
@@ -566,6 +565,26 @@ class MixedGeometryBatch {
   getFeatureFromRef(ref) {
     return this.refToFeature_.get(ref);
   }
+
+  isEmpty() {
+    return this.globalCounter_ === 0;
+  }
+
+  /**
+   * Will return a new instance of this class that only contains the features
+   * for which the provided callback returned true
+   * @param {function((Feature|RenderFeature)): boolean} featureFilter Feature filter callback
+   * @return {MixedGeometryBatch} Filtered geometry batch
+   */
+  filter(featureFilter) {
+    const filtered = new MixedGeometryBatch();
+    for (const feature of this.refToFeature_.values()) {
+      if (featureFilter(feature)) {
+        filtered.addFeature(feature);
+      }
+    }
+    return filtered;
+  }
 }
 
 /**

package/render/webgl/VectorStyleRenderer.d.ts

@@ -177,8 +177,9 @@ declare class VectorStyleRenderer {
      * @param {import('../../style/flat.js').StyleVariables} variables Style variables
      * @param {import('../../webgl/Helper.js').default} helper Helper
      * @param {boolean} [enableHitDetection] Whether to enable the hit detection (needs compatible shader)
+     * @param {import("../../expr/expression.js").ExpressionValue} [filter] Optional filter expression
      */
-    constructor(styleOrShaders: VectorStyle, variables: import("../../style/flat.js").StyleVariables, helper: import("../../webgl/Helper.js").default, enableHitDetection?: boolean);
+    constructor(styleOrShaders: VectorStyle, variables: import("../../style/flat.js").StyleVariables, helper: import("../../webgl/Helper.js").default, enableHitDetection?: boolean, filter?: import("../../expr/expression.js").ExpressionValue);
     /**
      * @private
      * @type {import('../../webgl/Helper.js').default}
@@ -242,6 +243,11 @@ declare class VectorStyleRenderer {
      * @private
      */
     private symbolFragmentShader_;
+    /**
+     * @type {function(import('../../Feature.js').FeatureLike): boolean}
+     * @private
+     */
+    private featureFilter_;
     /**
      * @private
      */
@@ -265,12 +271,19 @@ declare class VectorStyleRenderer {
      * @private
      */
     private pointAttributesDesc_;
+    /**
+     * Will apply the style filter when generating geometry batches (if it can be evaluated outside a map context)
+     * @param {import("../../expr/expression.js").ExpressionValue} filter Style filter
+     * @return {function(import('../../Feature.js').FeatureLike): boolean} Feature filter
+     * @private
+     */
+    private computeFeatureFilter;
     /**
      * @param {import('./MixedGeometryBatch.js').default} geometryBatch Geometry batch
      * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
-     * @return {Promise<WebGLBuffers>} A promise resolving to WebGL buffers
+     * @return {Promise<WebGLBuffers|null>} A promise resolving to WebGL buffers; returns null if buffers are empty
      */
-    generateBuffers(geometryBatch: import("./MixedGeometryBatch.js").default, transform: import("../../transform.js").Transform): Promise<WebGLBuffers>;
+    generateBuffers(geometryBatch: import("./MixedGeometryBatch.js").default, transform: import("../../transform.js").Transform): Promise<WebGLBuffers | null>;
     /**
      * @param {import('./MixedGeometryBatch.js').default} geometryBatch Geometry batch
      * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates

package/render/webgl/VectorStyleRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBAmCU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;oBAW5H,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;;;;;WAQpD,OAAO,qBAAqB,EAAE,SAAS;;;;;;0BAKxC,MAAM,GAAC,SAAS;AAlD7B;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;OAKG;IACH,4BALW,WAAW,aACX,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,uBACvC,OAAO,EAwMjB;IArMC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAAgD;IAkBhD;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,iBAAyD;IAEvD;;OAEG;IACH,0BAAgE;IAChE;;OAEG;IACH,4BAAoE;IAGtE;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAG1E;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAc1E;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAmC;IASnC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCAqCC;IACD;;;OAGG;IACH,6BAYC;IAKH;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,CAAC,CAqChC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAwEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QAuCtB;CACF;6BAzkB4B,uBAAuB"}
+{"version":3,"file":"VectorStyleRenderer.d.ts","sourceRoot":"","sources":["VectorStyleRenderer.js"],"names":[],"mappings":";;;;yBAyCU,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;cAmBF,CAAS,IAAwD,EAAnD,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,IAAmC,EAAnC,OAAO,eAAe,EAAE,WAAW,KAAE,MAAM,GAAC,KAAK,CAAC,MAAM,CAAC;;;;;;;;;;;;oBAW5H,KAAK,CAAC,gBAAgB,CAAC;;;;uBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;kBACvB,KAAK,CAAC,gBAAgB,CAAC;;;;6BACvB,OAAO,oBAAoB,EAAE,SAAS;;;;;;yBAKtC,YAAY,GAAC,IAAI;;;;4BACjB,YAAY,GAAC,IAAI;;;;uBACjB,YAAY,GAAC,IAAI;;;;;;;;;YAKjB,MAAM;;;;cACN,MAAM;;;;;;aAKN,OAAO,8BAA8B,EAAE,aAAa;;;;;;;;;;;;;;;;;;;WAQpD,OAAO,qBAAqB,EAAE,SAAS;;;;;;0BAKxC,MAAM,GAAC,SAAS;AAlD7B;;;;;;;GAOG;AAEH;;;GAGG;AAEH;;;;;;GAMG;AAEH;;;;;GAKG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;;GAIG;AAEH;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH;IACE;;;;;;OAMG;IACH,4BANW,WAAW,aACX,OAAO,qBAAqB,EAAE,cAAc,UAC5C,OAAO,uBAAuB,EAAE,OAAO,uBACvC,OAAO,WACP,OAAO,0BAA0B,EAAE,eAAe,EAiN5D;IA9MC;;;OAGG;IACH,gBAAY;IAEZ;;OAEG;IACH,6BAAgD;IAkBhD;;;OAGG;IACH,qBAAiB;IAEjB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,uBAAmB;IAEnB;;;OAGG;IACH,iBAAyD;IAEvD;;OAEG;IACH,0BAAgE;IAChE;;OAEG;IACH,4BAAoE;IAGtE;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAG1E;;;OAGG;IACH,mBAA6D;IAE3D;;OAEG;IACH,4BAAoE;IACpE;;OAEG;IACH,8BAAwE;IAG1E;;;OAGG;IACH,uBAA0B;IAgB1B;;OAEG;IACH,0BAIC;IACD;;OAEG;IACH,kBAAmC;IASnC;;;OAGG;IACH,+BAOC;IACD;;;OAGG;IACH,kCAqCC;IACD;;;OAGG;IACH,6BAYC;IAKH;;;;;OAKG;IACH,6BAgCC;IAED;;;;OAIG;IACH,+BAJW,OAAO,yBAAyB,EAAE,OAAO,aACzC,OAAO,oBAAoB,EAAE,SAAS,GACrC,OAAO,CAAC,YAAY,GAAC,IAAI,CAAC,CA4CrC;IAED;;;;;OAKG;IACH,oCA+BC;IAED;;;;;;OAMG;IACH,gCAwEC;IAED;;;;;OAKG;IACH,gBAJW,YAAY,cACZ,OAAO,cAAc,EAAE,UAAU,qBACjC,MAAY,IAAI,QA8B1B;IAED;;;;;;;;OAQG;IACH,wBAkBC;IAED;;;OAGG;IACH,kBAHW,OAAO,uBAAuB,EAAE,OAAO,YACvC,YAAY,QAuCtB;CACF;6BAloB4B,uBAAuB"}

package/render/webgl/VectorStyleRenderer.js

@@ -1,6 +1,12 @@
 /**
  * @module ol/render/webgl/VectorStyleRenderer
  */
+import {buildExpression, newEvaluationContext} from '../../expr/cpu.js';
+import {
+  BooleanType,
+  computeGeometryType,
+  newParsingContext,
+} from '../../expr/expression.js';
 import {
   create as createTransform,
   makeInverse as makeInverseTransform,
@@ -120,8 +126,9 @@ class VectorStyleRenderer {
    * @param {import('../../style/flat.js').StyleVariables} variables Style variables
    * @param {import('../../webgl/Helper.js').default} helper Helper
    * @param {boolean} [enableHitDetection] Whether to enable the hit detection (needs compatible shader)
+   * @param {import("../../expr/expression.js").ExpressionValue} [filter] Optional filter expression
    */
-  constructor(styleOrShaders, variables, helper, enableHitDetection) {
+  constructor(styleOrShaders, variables, helper, enableHitDetection, filter) {
     /**
      * @private
      * @type {import('../../webgl/Helper.js').default}
@@ -215,6 +222,15 @@ class VectorStyleRenderer {
       this.symbolFragmentShader_ = asShaders.builder.getSymbolFragmentShader();
     }
 
+    /**
+     * @type {function(import('../../Feature.js').FeatureLike): boolean}
+     * @private
+     */
+    this.featureFilter_ = null;
+    if (filter) {
+      this.featureFilter_ = this.computeFeatureFilter(filter);
+    }
+
     const hitDetectionAttributes = this.hitDetectionEnabled_
       ? {
           hitColor: {
@@ -321,14 +337,61 @@ class VectorStyleRenderer {
     this.setHelper(helper);
   }
 
+  /**
+   * Will apply the style filter when generating geometry batches (if it can be evaluated outside a map context)
+   * @param {import("../../expr/expression.js").ExpressionValue} filter Style filter
+   * @return {function(import('../../Feature.js').FeatureLike): boolean} Feature filter
+   * @private
+   */
+  computeFeatureFilter(filter) {
+    const parsingContext = newParsingContext();
+    /**
+     * @type {import('../../expr/cpu.js').ExpressionEvaluator}
+     */
+    let compiled;
+    try {
+      compiled = buildExpression(filter, BooleanType, parsingContext);
+    } catch {
+      // filter expression failed to compile for CPU: ignore it
+      return null;
+    }
+
+    // do not apply the filter if it depends on map state (e.g. zoom level) or any variable
+    if (parsingContext.mapState || parsingContext.variables.size > 0) {
+      return null;
+    }
+
+    const evalContext = newEvaluationContext();
+    return (feature) => {
+      evalContext.properties = feature.getPropertiesInternal();
+      if (parsingContext.featureId) {
+        const id = feature.getId();
+        if (id !== undefined) {
+          evalContext.featureId = id;
+        } else {
+          evalContext.featureId = null;
+        }
+      }
+      evalContext.geometryType = computeGeometryType(feature.getGeometry());
+      return /** @type {boolean} */ (compiled(evalContext));
+    };
+  }
+
   /**
    * @param {import('./MixedGeometryBatch.js').default} geometryBatch Geometry batch
    * @param {import("../../transform.js").Transform} transform Transform to apply to coordinates
-   * @return {Promise<WebGLBuffers>} A promise resolving to WebGL buffers
+   * @return {Promise<WebGLBuffers|null>} A promise resolving to WebGL buffers; returns null if buffers are empty
    */
   async generateBuffers(geometryBatch, transform) {
+    let filteredBatch = geometryBatch;
+    if (this.featureFilter_) {
+      filteredBatch = filteredBatch.filter(this.featureFilter_);
+      if (filteredBatch.isEmpty()) {
+        return null;
+      }
+    }
     const renderInstructions = this.generateRenderInstructions_(
-      geometryBatch,
+      filteredBatch,
       transform,
     );
     const [polygonBuffers, lineStringBuffers, pointBuffers] = await Promise.all(

package/renderer/webgl/VectorLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;EAKE;;6BAGW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;;;;;WAMzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;AAVlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EA0GjB;IA5FC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,yBAAqB;IAErB;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,wBAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C;;OAEG;IACH,mBAAwB;IACxB;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAEtC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,0BAA6B;IAG/B;;;OAGG;IACH,4BAoCC;IAED;;;OAGG;IACH,sBAGC;IAED;;OAEG;IACH,yBAWC;IAED;;OAEG;IACH,mCAMC;IAoBD;;;;OAIG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAsBC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CA+BtB;IAwED;;;;;;;OAOG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,mBACjC,OAAO,cACP,MAAM,YACN,MAAM,cACN,MAAM,QAuChB;IA0CD;;;OAGG;IACH,wBAFW,OAAO,2CAA2C,EAAE,YAAY,QAkB1E;CAkBF;+BAliB8B,YAAY"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;EAKE;;6BAGW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;;;;;WAMzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;AAVlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,mBAHW,OAAO,sBAAsB,EAAE,OAAO,WACtC,OAAO,EA0GjB;IA5FC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,yBAAqB;IAErB;;OAEG;IACH,wBAAyB;IAEzB;;OAEG;IACH,wBAAoC;IAEpC;;;;;;OAMG;IACH,0BAA0C;IAE1C;;OAEG;IACH,mBAAwB;IACxB;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,oCAAoD;IAEpD;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAAyB;IAEzB;;;OAGG;IACH,iBAAkB;IAIlB;;OAEG;IACH,eAAsC;IAEtC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,0BAA6B;IAG/B;;;OAGG;IACH,4BAoCC;IAED;;;OAGG;IACH,sBAGC;IAED;;OAEG;IACH,yBAYC;IAED;;OAEG;IACH,mCAMC;IAoBD;;;;OAIG;IACH,kCAGC;IAED;;;OAGG;IACH,oCAGC;IAED;;;OAGG;IACH,mCAGC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,uBAsBC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CA+BtB;IAwED;;;;;;;OAOG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,mBACjC,OAAO,cACP,MAAM,YACN,MAAM,cACN,MAAM,QAuChB;IA0CD;;;OAGG;IACH,wBAFW,OAAO,2CAA2C,EAAE,YAAY,QAsB1E;CAoBF;+BAziB8B,YAAY"}

package/renderer/webgl/VectorLayer.js

@@ -249,6 +249,7 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
           this.styleVariables_,
           this.helper,
           this.hitDetectionEnabled_,
+          'filter' in style ? style.filter : null,
         ),
     );
   }
@@ -543,20 +544,24 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    * @param {import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers} buffers Buffers
    */
   disposeBuffers(buffers) {
+    /**
+     * @param {Array<import('../../webgl/Buffer.js').default>} typeBuffers Buffers
+     */
+    const disposeBuffersOfType = (typeBuffers) => {
+      for (const buffer of typeBuffers) {
+        if (buffer) {
+          this.helper.deleteBuffer(buffer);
+        }
+      }
+    };
     if (buffers.pointBuffers) {
-      buffers.pointBuffers
-        .filter(Boolean)
-        .forEach((buffer) => this.helper.deleteBuffer(buffer));
+      disposeBuffersOfType(buffers.pointBuffers);
     }
     if (buffers.lineStringBuffers) {
-      buffers.lineStringBuffers
-        .filter(Boolean)
-        .forEach((buffer) => this.helper.deleteBuffer(buffer));
+      disposeBuffersOfType(buffers.lineStringBuffers);
     }
     if (buffers.polygonBuffers) {
-      buffers.polygonBuffers
-        .filter(Boolean)
-        .forEach((buffer) => this.helper.deleteBuffer(buffer));
+      disposeBuffersOfType(buffers.polygonBuffers);
     }
   }
 
@@ -566,7 +571,9 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    */
   disposeInternal() {
     this.buffers_.forEach((buffers) => {
-      this.disposeBuffers(buffers);
+      if (buffers) {
+        this.disposeBuffers(buffers);
+      }
     });
     if (this.sourceListenKeys_) {
       this.sourceListenKeys_.forEach(function (key) {

package/renderer/webgl/VectorTileLayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;EAIE;;;;;6BAOW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;WAKzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;AATlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAuFjB;IA5EC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,wBAAyB;IAEzB;;;;;;OAMG;IACH,oCAAoD;IAEpD;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,wBAA2B;IAE3B;;OAEG;IACH,yBAGC;IAGD;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,yBAAqB;IAKvB;;;OAGG;IACH,wBAHW,OAAO,QAWjB;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,yBAwCC;IAED;;OAEG;IACH,sBAYC;IAUD;;OAEG;IACH,8DAWC;IAED;;OAEG;IACH,uEAMC;IAED;;OAEG;IACH,yDA0BC;IAED;;OAEG;IACH,4FAeC;IAED;;;;;;;OAOG;IACH,uBAoBC;IAED;;OAEG;IACH,sNA4BC;IAED;;;OAGG;IACH,4BAFW,OAAO,cAAc,EAAE,UAAU,QAEd;CAS/B;uCAzXM,oBAAoB;yBALF,6BAA6B"}
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;EAIE;;;;;6BAOW,OAAO,2CAA2C,EAAE,SAAS;0BAG7D,OAAO,2CAA2C,EAAE,MAAM;;;;;WAKzD,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,cAAc,CAAC,GAAG,cAAc;;;;;;;;;;;;;;;;;;;;AATlG;;GAEG;AACH;;GAEG;AAEH;;;;;;;;;GASG;AAEH;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EAuFjB;IA5EC;;;OAGG;IACH,6BAAwD;IAExD;;;OAGG;IACH,gBAAiB;IAEjB;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,wBAAyB;IAEzB;;;;;;OAMG;IACH,oCAAoD;IAEpD;;OAEG;IACH,sBAAsC;IACtC;;OAEG;IACH,iBAA4B;IAE5B;;;OAGG;IACH,wBAA2B;IAE3B;;OAEG;IACH,yBAGC;IAGD;;;OAGG;IACH,4BAMC;IAED;;;OAGG;IACH,yBAAqB;IAKvB;;;OAGG;IACH,wBAHW,OAAO,QAWjB;IAED;;;OAGG;IACH,sBAEC;IAED;;OAEG;IACH,yBAyCC;IAED;;OAEG;IACH,sBAYC;IAUD;;OAEG;IACH,8DAWC;IAED;;OAEG;IACH,uEAMC;IAED;;OAEG;IACH,yDA0BC;IAED;;OAEG;IACH,4FAeC;IAED;;;;;;;OAOG;IACH,uBAoBC;IAED;;OAEG;IACH,sNA+BC;IAED;;;OAGG;IACH,4BAFW,OAAO,cAAc,EAAE,UAAU,QAEd;CAS/B;uCA7XM,oBAAoB;yBALF,6BAA6B"}

package/renderer/webgl/VectorTileLayer.js

@@ -218,6 +218,7 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
         this.styleVariables_,
         this.helper,
         this.hitDetectionEnabled_,
+        'filter' in style ? style.filter : null,
       );
     });
   }
@@ -376,6 +377,9 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
     for (let i = 0, ii = this.styleRenderers_.length; i < ii; i++) {
       const renderer = this.styleRenderers_[i];
       const buffers = tileRepresentation.buffers[i];
+      if (!buffers) {
+        continue;
+      }
       renderer.render(buffers, frameState, () => {
         this.applyUniforms_(
           alpha,

package/util.js

@@ -33,4 +33,4 @@ export function getUid(obj) {
  * OpenLayers version.
  * @type {string}
  */
-export const VERSION = '10.3.2-dev.1737449234314';
+export const VERSION = '10.3.2-dev.1737622602778';

package/webgl/TileGeometry.d.ts

@@ -34,6 +34,11 @@ declare class TileGeometry extends BaseTileRepresentation<import("../VectorRende
      * @private
      */
     private generateMaskBuffer_;
+    /**
+     * Will release a set of Webgl buffers
+     * @param {import('../render/webgl/VectorStyleRenderer.js').WebGLBuffers} buffers Buffers
+     */
+    disposeBuffers(buffers: import("../render/webgl/VectorStyleRenderer.js").WebGLBuffers): void;
 }
 import BaseTileRepresentation from './BaseTileRepresentation.js';
 import WebGLArrayBuffer from './Buffer.js';

package/webgl/TileGeometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileGeometry.d.ts","sourceRoot":"","sources":["TileGeometry.js"],"names":[],"mappings":";uBAca,OAAO,qBAAqB,EAAE,OAAO;AADlD;;GAEG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,qBAHW,OAAO,6BAA6B,EAAE,yBAAyB,CAAC,QAAQ,CAAC,kBACzE,KAAK,CAAC,OAAO,wCAAwC,EAAE,OAAO,CAAC,EA4BzE;IAvBC;;OAEG;IACH,eAAsC;IAEtC;;OAEG;IACH,wBAAqC;IAErC;;OAEG;IACH,SAFU,KAAK,CAAC,OAAO,wCAAwC,EAAE,YAAY,CAAC,CAE7D;IAEjB;;;;OAIG;IACH,+BAAmE;IAKrE;;OAEG;IACH,4BAaC;CAiCF;mCA5FkC,6BAA6B;6BACnC,aAAa"}
+{"version":3,"file":"TileGeometry.d.ts","sourceRoot":"","sources":["TileGeometry.js"],"names":[],"mappings":";uBAca,OAAO,qBAAqB,EAAE,OAAO;AADlD;;GAEG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,qBAHW,OAAO,6BAA6B,EAAE,yBAAyB,CAAC,QAAQ,CAAC,kBACzE,KAAK,CAAC,OAAO,wCAAwC,EAAE,OAAO,CAAC,EA4BzE;IAvBC;;OAEG;IACH,eAAsC;IAEtC;;OAEG;IACH,wBAAqC;IAErC;;OAEG;IACH,SAFU,KAAK,CAAC,OAAO,wCAAwC,EAAE,YAAY,CAAC,CAE7D;IAEjB;;;;OAIG;IACH,+BAAmE;IAKrE;;OAEG;IACH,4BAaC;IA4CD;;;OAGG;IACH,wBAFW,OAAO,wCAAwC,EAAE,YAAY,QAsBvE;CACF;mCAhIkC,6BAA6B;6BACnC,aAAa"}

package/webgl/TileGeometry.js

@@ -100,6 +100,42 @@ class TileGeometry extends BaseTileRepresentation {
       this.setReady();
     });
   }
+
+  /**
+   * @override
+   */
+  disposeInternal() {
+    this.buffers.forEach((buffers) => {
+      this.disposeBuffers(buffers);
+    });
+    super.disposeInternal();
+  }
+
+  /**
+   * Will release a set of Webgl buffers
+   * @param {import('../render/webgl/VectorStyleRenderer.js').WebGLBuffers} buffers Buffers
+   */
+  disposeBuffers(buffers) {
+    /**
+     * @param {Array<WebGLArrayBuffer>} typeBuffers Buffers
+     */
+    const disposeBuffersOfType = (typeBuffers) => {
+      for (const buffer of typeBuffers) {
+        if (buffer) {
+          this.helper.deleteBuffer(buffer);
+        }
+      }
+    };
+    if (buffers.pointBuffers) {
+      disposeBuffersOfType(buffers.pointBuffers);
+    }
+    if (buffers.lineStringBuffers) {
+      disposeBuffersOfType(buffers.lineStringBuffers);
+    }
+    if (buffers.polygonBuffers) {
+      disposeBuffersOfType(buffers.polygonBuffers);
+    }
+  }
 }
 
 export default TileGeometry;

package/webgl/styleparser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styleparser.d.ts","sourceRoot":"","sources":["styleparser.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,qDALW,OAAO,gBAAgB,EAAE,kBAAkB,SAC3C,OAAO,uBAAuB,EAAE,iBAAiB,iBACjD,MAAM,GACL,MAAM,CAUjB;AAED;;;;GAIG;AACH,iCAHW,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GACjC,KAAK,CAAC,MAAM,CAAC,CASxB;AAqCD;;;;GAIG;AACH,mCAHW,MAAO,MAAM,GACZ,MAAM,CAOjB;AAgvBD;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,yCALW,OAAO,kBAAkB,EAAE,SAAS,cACpC,OAAO,kBAAkB,EAAE,cAAc,WACzC,OAAO,uBAAuB,EAAE,iBAAiB,GAChD,gBAAgB,CAgK3B;;;;;aAhLa,aAAa;;;;cACb,OAAO,wCAAwC,EAAE,kBAAkB;;;;gBACnE,OAAO,wCAAwC,EAAE,oBAAoB;;8BAn0BvD,oBAAoB"}
+{"version":3,"file":"styleparser.d.ts","sourceRoot":"","sources":["styleparser.js"],"names":[],"mappings":"AA2BA;;;;;;;GAOG;AACH,qDALW,OAAO,gBAAgB,EAAE,kBAAkB,SAC3C,OAAO,uBAAuB,EAAE,iBAAiB,iBACjD,MAAM,GACL,MAAM,CAUjB;AAED;;;;GAIG;AACH,iCAHW,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GACjC,KAAK,CAAC,MAAM,CAAC,CASxB;AAqCD;;;;GAIG;AACH,mCAHW,MAAO,MAAM,GACZ,MAAM,CAOjB;AAgvBD;;;;;GAKG;AAEH;;;;;;;;;;;;GAYG;AACH,yCALW,OAAO,kBAAkB,EAAE,SAAS,cACpC,OAAO,kBAAkB,EAAE,cAAc,WACzC,OAAO,uBAAuB,EAAE,iBAAiB,GAChD,gBAAgB,CAkK3B;;;;;aAlLa,aAAa;;;;cACb,OAAO,wCAAwC,EAAE,kBAAkB;;;;gBACnE,OAAO,wCAAwC,EAAE,oBAAoB;;8BAn0BvD,oBAAoB"}

package/webgl/styleparser.js

@@ -901,6 +901,8 @@ export function parseLiteralStyle(style, variables, filter) {
   parseStrokeProperties(style, builder, uniforms, vertContext, fragContext);
   parseFillProperties(style, builder, uniforms, vertContext, fragContext);
 
+  // note that the style filter may have already been applied earlier when building the rendering instructions
+  // this is still needed in case a filter cannot be evaluated statically beforehand (e.g. depending on time)
   if (filter) {
     const parsedFilter = expressionToGlsl(fragContext, filter, BooleanType);
     builder.setFragmentDiscardExpression(`!${parsedFilter}`);