ol 10.6.2-dev.1750922991910 → 10.6.2-dev.1751277211647

package/render/webgl/style.js

@@ -828,75 +828,3 @@ export function parseLiteralStyle(style, variables, filter) {
     },
   };
 }
-
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsShaders} StyleAsShaders
- */
-/**
- * @typedef {import('./VectorStyleRenderer.js').AsRule} StyleAsRule
- */
-
-/**
- * Takes in either a Flat Style or an array of shaders (used as input for the webgl vector layer classes)
- * and breaks it down into separate styles to be used by the VectorStyleRenderer class.
- * @param {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat style or shaders
- * @return {Array<StyleAsShaders | StyleAsRule>} Separate styles as shaders or rules with a single flat style and a filter
- */
-export function breakDownFlatStyle(style) {
-  // possible cases:
-  // - single shader
-  // - multiple shaders
-  // - single style
-  // - multiple styles
-  // - multiple rules
-  const asArray = Array.isArray(style) ? style : [style];
-
-  // if array of rules: break rules into separate styles, compute "else" filters
-  if ('style' in asArray[0]) {
-    /** @type {Array<StyleAsRule>} */
-    const styles = [];
-    const rules = /** @type {Array<import('../../style/flat.js').Rule>} */ (
-      asArray
-    );
-    const previousFilters = [];
-    for (const rule of rules) {
-      const ruleStyles = Array.isArray(rule.style) ? rule.style : [rule.style];
-      /** @type {import("../../expr/expression.js").EncodedExpression} */
-      let currentFilter = rule.filter;
-      if (rule.else && previousFilters.length) {
-        currentFilter = [
-          'all',
-          ...previousFilters.map((filter) => ['!', filter]),
-        ];
-        if (rule.filter) {
-          currentFilter.push(rule.filter);
-        }
-        if (currentFilter.length < 3) {
-          currentFilter = currentFilter[1];
-        }
-      }
-      if (rule.filter) {
-        previousFilters.push(rule.filter);
-      }
-      /** @type {Array<StyleAsRule>} */
-      const stylesWithFilters = ruleStyles.map((style) => ({
-        style,
-        ...(currentFilter && {filter: currentFilter}),
-      }));
-      styles.push(...stylesWithFilters);
-    }
-    return styles;
-  }
-
-  // if array of shaders: return as is
-  if ('builder' in asArray[0]) {
-    return /** @type {Array<StyleAsShaders>} */ (asArray);
-  }
-
-  return asArray.map(
-    (style) =>
-      /** @type {StyleAsRule} */ ({
-        style,
-      }),
-  );
-}

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

@@ -1 +1 @@
-{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAgDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD;;;;GAIG;AACH,oCAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,OAAO,oBAAoB,EAAE,SAAS,GACrC,MAAM,CAIjB;;;;;;;;;;;;;;yCA9EY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,GAAG,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EzB;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH,yCAL6B,SAAS,SAAxB,aAAc,EACmB,QAAQ,SAA1C,OAAQ,eAAe,EAAE,OAAQ,EACmC,kBAAkB,SAAtF,OAAQ,uCAAuC,EAAE,OAAO,CAAC,QAAQ,CAAE;IAI9E;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,KAAK,CAAC,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,4BAAoC;IAGtC;;;OAGG;IACH,wBAHW,OAAO,QAOjB;IA4BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAoIhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAyMtB;IAED;;;OAGG;IACH,qCAHW,OAAO,cAAc,EAAE,UAAU,QAK3C;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;CAkCF;+BApyB8B,YAAY"}
+{"version":3,"file":"TileLayerBase.d.ts","sourceRoot":"","sources":["TileLayerBase.js"],"names":[],"mappings":"AAgDA;;GAEG;AACH;;;;GAIG;AAEH;;GAEG;AACH,+CAFY,wBAAwB,CAInC;AA0DD;;;;GAIG;AACH,oCAJW,OAAO,sBAAsB,EAAE,OAAO,aACtC,OAAO,oBAAoB,EAAE,SAAS,GACrC,MAAM,CAIjB;;;;;;;;;;;;;;yCA9EY,OAAO,uCAAuC,EAAE,OAAO,CAAC,OAAO,eAAe,EAAE,OAAO,CAAC;;;;;aAIvF,GAAG,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;AA4EzB;;;;;;GAMG;AAEH;;GAEG;AAEH;;;;;;;GAOG;AACH,yCAL6B,SAAS,SAAxB,aAAc,EACmB,QAAQ,SAA1C,OAAQ,eAAe,EAAE,OAAQ,EACmC,kBAAkB,SAAtF,OAAQ,uCAAuC,EAAE,OAAO,CAAC,QAAQ,CAAE;IAI9E;;;OAGG;IACH,uBAHW,SAAS,WACT,OAAO,EA+DjB;IAvDC;;;OAGG;IACH,gBAFU,OAAO,CAEU;IAE3B;;;;OAIG;IACH,uBAAuC;IAEvC;;;OAGG;IACH,oBAHU,KAAK,CAAC,MAAM,CAAC,CAGK;IAE5B;;;OAGG;IACH,uBAA+C;IAE/C;;;OAGG;IACH,uBAA8C;IAE9C;;;OAGG;IACH,kBAAuB;IAGvB;;;OAGG;IACH,mCAHU,OAAO,2BAA2B,EAAE,OAAO,CAAC,kBAAkB,CAAC,CAGnB;IAEtD;;;OAGG;IACH,sBAFU,OAAO,cAAc,EAAE,UAAU,GAAC,IAAI,CAE1B;IAEtB;;;OAGG;IACH,4BAAoC;IAGtC;;;OAGG;IACH,wBAHW,OAAO,QAOjB;IA4BD;;;;;OAKG;IACH,4CAJW,OAAO,uCAAuC,EAAE,yBAAyB,CAAC,QAAQ,CAAC,GAClF,kBAAkB,CAK7B;IAED;;;;;;OAMG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,UACjC,OAAO,iBAAiB,EAAE,MAAM,YAChC,MAAM,4BACN,wBAAwB,WACxB,MAAM,QAoIhB;IAED;;;;OAIG;IACH,wCAJW,OAAO,cAAc,EAAE,UAAU,kBACjC,OAAO,QAKjB;IAED;;;;OAIG;IACH,4CAJW,OAAO,cAAc,EAAE,UAAU,GAChC,OAAO,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,yCAbW,kBAAkB,iBAClB,OAAO,oBAAoB,EAAE,SAAS,cACtC,OAAO,cAAc,EAAE,UAAU,gBACjC,OAAO,iBAAiB,EAAE,MAAM,kBAChC,MAAM,YACN,OAAO,eAAe,EAAE,IAAI,cAC5B,OAAO,qBAAqB,EAAE,UAAU,cACxC,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,UACN,MAAM,SACN,MAAM,QAeb;IAEJ;;;;;;OAMG;IACH,6CANW,kBAAkB,SAClB,MAAM,UACN,OAAO,iBAAiB,EAAE,MAAM,SAChC,MAAM,QAG0C;IAE3D,iIAuEC;IAED;;;;;OAKG;IACH,iCAJW,OAAO,cAAc,EAAE,UAAU,GAChC,WAAW,CAsMtB;IAED;;;OAGG;IACH,qCAHW,OAAO,cAAc,EAAE,UAAU,QAK3C;IAED;;;;;;;;;;OAUG;IACH,sBAsCC;CAkCF;+BAjyB8B,YAAY"}

package/renderer/webgl/TileLayerBase.js

@@ -725,10 +725,7 @@ class WebGLBaseTileLayerRenderer extends WebGLLayerRenderer {
     const canvas = this.helper.getCanvas();
 
     const tileRepresentationCache = this.tileRepresentationCache;
-    while (tileRepresentationCache.canExpireCache()) {
-      const tileRepresentation = tileRepresentationCache.pop();
-      tileRepresentation.dispose();
-    }
+    tileRepresentationCache.expireCache();
 
     this.postRender(gl, frameState);
     return canvas;

package/renderer/webgl/VectorLayer.d.ts

@@ -13,8 +13,8 @@ export const Uniforms: {
     HIT_DETECTION: string;
 };
 export default WebGLVectorLayerRenderer;
-export type StyleAsShaders = import("../../render/webgl/VectorStyleRenderer.js").AsShaders;
-export type StyleAsRule = import("../../render/webgl/VectorStyleRenderer.js").AsRule;
+export type StyleShaders = import("../../render/webgl/VectorStyleRenderer.js").StyleShaders;
+export type LayerStyle = import("../../style/flat.js").FlatStyleLike | Array<StyleShaders> | StyleShaders;
 export type Options = {
     /**
      * A CSS class name to set to the canvas element.
@@ -23,7 +23,7 @@ export type Options = {
     /**
      * Flat vector style; also accepts shaders
      */
-    style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders;
+    style: LayerStyle;
     /**
      * Style variables
      */
@@ -41,15 +41,15 @@ export type Options = {
     postProcesses?: import("./Layer.js").PostProcessesOptions[] | undefined;
 };
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').StyleShaders} StyleShaders
  */
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
+ * @typedef {import('../../style/flat.js').FlatStyleLike | Array<StyleShaders> | StyleShaders} LayerStyle
  */
 /**
  * @typedef {Object} Options
  * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
- * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
+ * @property {LayerStyle} style Flat vector style; also accepts shaders
  * @property {Object<string, number|Array<number>|string|boolean>} variables Style variables
  * @property {boolean} [disableHitDetection=false] Setting this to true will provide a slight performance boost, but will
  * prevent all hit detection on the layer.
@@ -128,17 +128,17 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
      */
     private styleVariables_;
     /**
-     * @type {Array<StyleAsRule | StyleAsShaders>}
+     * @type {LayerStyle}
      * @private
      */
-    private styles_;
+    private style_;
     /**
-     * @type {Array<VectorStyleRenderer>}
-     * @private
+     * @type {VectorStyleRenderer}
+     * @public
      */
-    private styleRenderers_;
+    public styleRenderer_: VectorStyleRenderer;
     /**
-     * @type {Array<import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers>}
+     * @type {import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers}
      * @private
      */
     private buffers_;
@@ -224,4 +224,5 @@ declare class WebGLVectorLayerRenderer extends WebGLLayerRenderer<any> {
     renderDeclutter(): void;
 }
 import WebGLLayerRenderer from './Layer.js';
+import VectorStyleRenderer from '../../render/webgl/VectorStyleRenderer.js';
 //# sourceMappingURL=VectorLayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;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;;;;OAIG;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;IAqBD,wBAAoB;CACrB;+BA5iB8B,YAAY"}
+{"version":3,"file":"VectorLayer.d.ts","sourceRoot":"","sources":["VectorLayer.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;EAKE;;2BAGW,OAAO,2CAA2C,EAAE,YAAY;yBAGhE,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,YAAY;;;;;;;;;WAM/E,UAAU;;;;;;;;;;;;;;;;;AAVxB;;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,eAAgB;IAEhB;;;OAGG;IACH,uBAHU,mBAAmB,CAGH;IAE1B;;;OAGG;IACH,iBAAoB;IAIpB;;OAEG;IACH,eAAsC;IAEtC;;;OAGG;IACH,8BAAkC;IAElC;;;OAGG;IACH,0BAA6B;IAG/B;;;OAGG;IACH,4BAoCC;IAED;;;OAGG;IACH,sBAGC;IAED;;OAEG;IACH,yBAQC;IAED;;OAEG;IACH,mCAMC;IAkBD;;;;OAIG;IACH,kCAGC;IAED;;;;OAIG;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;IAsED;;;;;;;OAOG;IACH,yBANW,OAAO,cAAc,EAAE,UAAU,mBACjC,OAAO,cACP,MAAM,YACN,MAAM,cACN,MAAM,QAmChB;IA0CD;;;OAGG;IACH,wBAFW,OAAO,2CAA2C,EAAE,YAAY,QAsB1E;IAmBD,wBAAoB;CACrB;+BA9hB8B,YAAY;gCAjBX,2CAA2C"}

package/renderer/webgl/VectorLayer.js

@@ -15,7 +15,6 @@ import {
 import MixedGeometryBatch from '../../render/webgl/MixedGeometryBatch.js';
 import VectorStyleRenderer from '../../render/webgl/VectorStyleRenderer.js';
 import {colorDecodeId} from '../../render/webgl/encodeUtil.js';
-import {breakDownFlatStyle} from '../../render/webgl/style.js';
 import VectorEventType from '../../source/VectorEventType.js';
 import {
   apply as applyTransform,
@@ -42,16 +41,16 @@ export const Uniforms = {
 };
 
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').StyleShaders} StyleShaders
  */
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
+ * @typedef {import('../../style/flat.js').FlatStyleLike | Array<StyleShaders> | StyleShaders} LayerStyle
  */
 
 /**
  * @typedef {Object} Options
  * @property {string} [className='ol-layer'] A CSS class name to set to the canvas element.
- * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
+ * @property {LayerStyle} style Flat vector style; also accepts shaders
  * @property {Object<string, number|Array<number>|string|boolean>} variables Style variables
  * @property {boolean} [disableHitDetection=false] Setting this to true will provide a slight performance boost, but will
  * prevent all hit detection on the layer.
@@ -150,22 +149,22 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
     this.styleVariables_ = {};
 
     /**
-     * @type {Array<StyleAsRule | StyleAsShaders>}
+     * @type {LayerStyle}
      * @private
      */
-    this.styles_ = [];
+    this.style_ = [];
 
     /**
-     * @type {Array<VectorStyleRenderer>}
-     * @private
+     * @type {VectorStyleRenderer}
+     * @public
      */
-    this.styleRenderers_ = [];
+    this.styleRenderer_ = null;
 
     /**
-     * @type {Array<import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers>}
+     * @type {import('../../render/webgl/VectorStyleRenderer.js').WebGLBuffers}
      * @private
      */
-    this.buffers_ = [];
+    this.buffers_ = null;
 
     this.applyOptions_(options);
 
@@ -235,23 +234,19 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    */
   applyOptions_(options) {
     this.styleVariables_ = options.variables;
-    this.styles_ = breakDownFlatStyle(options.style);
+    this.style_ = options.style;
   }
 
   /**
    * @private
    */
   createRenderers_() {
-    this.buffers_ = [];
-    this.styleRenderers_ = this.styles_.map(
-      (style) =>
-        new VectorStyleRenderer(
-          style,
-          this.styleVariables_,
-          this.helper,
-          this.hitDetectionEnabled_,
-          'filter' in style ? style.filter : null,
-        ),
+    this.buffers_ = null;
+    this.styleRenderer_ = new VectorStyleRenderer(
+      this.style_,
+      this.styleVariables_,
+      this.helper,
+      this.hitDetectionEnabled_,
     );
   }
 
@@ -270,11 +265,9 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    * @override
    */
   afterHelperCreated() {
-    if (this.styleRenderers_.length) {
+    if (this.styleRenderer_) {
       // To reuse buffers
-      this.styleRenderers_.forEach((renderer, i) =>
-        renderer.setHelper(this.helper, this.buffers_[i]),
-      );
+      this.styleRenderer_.setHelper(this.helper, this.buffers_);
     } else {
       this.createRenderers_();
     }
@@ -435,18 +428,16 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
         createTransform(),
       );
 
-      const generatePromises = this.styleRenderers_.map((renderer, i) =>
-        renderer.generateBuffers(this.batch_, transform).then((buffers) => {
-          if (this.buffers_[i]) {
-            this.disposeBuffers(this.buffers_[i]);
+      this.styleRenderer_
+        .generateBuffers(this.batch_, transform)
+        .then((buffers) => {
+          if (this.buffers_) {
+            this.disposeBuffers(this.buffers_);
           }
-          this.buffers_[i] = buffers;
-        }),
-      );
-      Promise.all(generatePromises).then(() => {
-        this.ready = true;
-        this.getLayer().changed();
-      });
+          this.buffers_ = buffers;
+          this.ready = true;
+          this.getLayer().changed();
+        });
 
       this.previousExtent_ = frameState.extent.slice();
     }
@@ -487,17 +478,13 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
         world * worldWidth,
         0,
       );
-      for (let i = 0, ii = this.styleRenderers_.length; i < ii; i++) {
-        const renderer = this.styleRenderers_[i];
-        const buffers = this.buffers_[i];
-        if (!buffers) {
-          continue;
-        }
-        renderer.render(buffers, frameState, () => {
-          this.applyUniforms_(buffers.invertVerticesTransform);
-          this.helper.applyHitDetectionUniform(forHitDetection);
-        });
+      if (!this.buffers_) {
+        continue;
       }
+      this.styleRenderer_.render(this.buffers_, frameState, () => {
+        this.applyUniforms_(this.buffers_.invertVerticesTransform);
+        this.helper.applyHitDetectionUniform(forHitDetection);
+      });
     } while (++world < endWorld);
   }
 
@@ -522,7 +509,7 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
       this.hitDetectionEnabled_,
       '`forEachFeatureAtCoordinate` cannot be used on a WebGL layer if the hit detection logic has been disabled using the `disableHitDetection: true` option.',
     );
-    if (!this.styleRenderers_.length || !this.hitDetectionEnabled_) {
+    if (!this.styleRenderer_ || !this.hitDetectionEnabled_) {
       return undefined;
     }
 
@@ -572,11 +559,9 @@ class WebGLVectorLayerRenderer extends WebGLLayerRenderer {
    * @override
    */
   disposeInternal() {
-    this.buffers_.forEach((buffers) => {
-      if (buffers) {
-        this.disposeBuffers(buffers);
-      }
-    });
+    if (this.buffers_) {
+      this.disposeBuffers(this.buffers_);
+    }
     if (this.sourceListenKeys_) {
       this.sourceListenKeys_.forEach(function (key) {
         unlistenByKey(key);

package/renderer/webgl/VectorTileLayer.d.ts

@@ -16,13 +16,13 @@ export namespace Attributes {
     let POSITION: string;
 }
 export default WebGLVectorTileLayerRenderer;
-export type StyleAsShaders = import("../../render/webgl/VectorStyleRenderer.js").AsShaders;
-export type StyleAsRule = import("../../render/webgl/VectorStyleRenderer.js").AsRule;
+export type StyleShaders = import("../../render/webgl/VectorStyleRenderer.js").StyleShaders;
+export type LayerStyle = import("../../style/flat.js").FlatStyleLike | Array<StyleShaders> | StyleShaders;
 export type Options = {
     /**
      * Flat vector style; also accepts shaders
      */
-    style: import("../../style/flat.js").FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders;
+    style: LayerStyle;
     /**
      * Style variables. Each variable must hold a literal value (not
      * an expression). These variables can be used as {@link import ("../../expr/expression.js").ExpressionValue expressions} in the styles properties
@@ -43,14 +43,14 @@ export type Options = {
 };
 export type LayerType = import("../../layer/BaseTile.js").default<any, any>;
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').StyleShaders} StyleShaders
  */
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
+ * @typedef {import('../../style/flat.js').FlatStyleLike | Array<StyleShaders> | StyleShaders} LayerStyle
  */
 /**
  * @typedef {Object} Options
- * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
+ * @property {LayerStyle} style Flat vector style; also accepts shaders
  * @property {import('../../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -78,20 +78,20 @@ declare class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer<im
      */
     private hitDetectionEnabled_;
     /**
-     * @type {Array<StyleAsRule | StyleAsShaders>}
+     * @type {LayerStyle}
      * @private
      */
-    private styles_;
+    private style_;
     /**
      * @type {import('../../style/flat.js').StyleVariables}
      * @private
      */
     private styleVariables_;
     /**
-     * @type {Array<VectorStyleRenderer>}
+     * @type {VectorStyleRenderer}
      * @private
      */
-    private styleRenderers_;
+    private styleRenderer_;
     /**
      * This transform is updated on every frame and is the composition of:
      * - invert of the world->screen transform that was used when rebuilding buffers (see `this.renderTransform_`)

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

@@ -1 +1 @@
-{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;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;yBAJF,6BAA6B"}
+{"version":3,"file":"VectorTileLayer.d.ts","sourceRoot":"","sources":["VectorTileLayer.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;EAIE;;;;;2BAOW,OAAO,2CAA2C,EAAE,YAAY;yBAGhE,OAAO,qBAAqB,EAAE,aAAa,GAAG,KAAK,CAAC,YAAY,CAAC,GAAG,YAAY;;;;;WAK/E,UAAU;;;;;;;;;;;;;;;;;;;;AATxB;;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,eAAkB;IAElB;;;OAGG;IACH,wBAA8C;IAE9C;;;OAGG;IACH,uBAA0B;IAE1B;;;;;;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,yBA2BC;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;uCA5WM,oBAAoB;yBAJF,6BAA6B"}

package/renderer/webgl/VectorTileLayer.js

@@ -4,11 +4,9 @@
 import EventType from '../../events/EventType.js';
 import {getIntersection} from '../../extent.js';
 import {ShaderBuilder} from '../../render/webgl/ShaderBuilder.js';
-import VectorStyleRenderer from '../../render/webgl/VectorStyleRenderer.js';
-import {
-  breakDownFlatStyle,
-  parseLiteralStyle,
-} from '../../render/webgl/style.js';
+import VectorStyleRenderer, {
+  convertStyleToShaders,
+} from '../../render/webgl/VectorStyleRenderer.js';
 import {
   create as createTransform,
   makeInverse as makeInverseTransform,
@@ -39,15 +37,15 @@ export const Attributes = {
 };
 
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsShaders} StyleAsShaders
+ * @typedef {import('../../render/webgl/VectorStyleRenderer.js').StyleShaders} StyleShaders
  */
 /**
- * @typedef {import('../../render/webgl/VectorStyleRenderer.js').AsRule} StyleAsRule
+ * @typedef {import('../../style/flat.js').FlatStyleLike | Array<StyleShaders> | StyleShaders} LayerStyle
  */
 
 /**
  * @typedef {Object} Options
- * @property {import('../../style/flat.js').FlatStyleLike | Array<StyleAsShaders> | StyleAsShaders} style Flat vector style; also accepts shaders
+ * @property {LayerStyle} style Flat vector style; also accepts shaders
  * @property {import('../../style/flat.js').StyleVariables} [variables] Style variables. Each variable must hold a literal value (not
  * an expression). These variables can be used as {@link import("../../expr/expression.js").ExpressionValue expressions} in the styles properties
  * using the `['var', 'varName']` operator.
@@ -86,10 +84,10 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
     this.hitDetectionEnabled_ = !options.disableHitDetection;
 
     /**
-     * @type {Array<StyleAsRule | StyleAsShaders>}
+     * @type {LayerStyle}
      * @private
      */
-    this.styles_ = [];
+    this.style_ = null;
 
     /**
      * @type {import('../../style/flat.js').StyleVariables}
@@ -98,10 +96,10 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
     this.styleVariables_ = options.variables || {};
 
     /**
-     * @type {Array<VectorStyleRenderer>}
+     * @type {VectorStyleRenderer}
      * @private
      */
-    this.styleRenderers_ = [];
+    this.styleRenderer_ = null;
 
     /**
      * This transform is updated on every frame and is the composition of:
@@ -176,7 +174,7 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
    * @private
    */
   applyOptions_(options) {
-    this.styles_ = breakDownFlatStyle(options.style);
+    this.style_ = options.style;
   }
 
   /**
@@ -195,34 +193,20 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
       builder.addUniform(Uniforms.TILE_ZOOM_LEVEL, 'float');
     }
 
-    this.styleRenderers_ = this.styles_.map((style) => {
-      const isShaders = 'builder' in style;
-      /** @type {StyleAsShaders} */
-      let shaders;
-      if (!isShaders) {
-        const parseResult = parseLiteralStyle(
-          style.style,
-          this.styleVariables_,
-          style.filter,
-        );
-        addBuilderParams(parseResult.builder);
-        shaders = {
-          builder: parseResult.builder,
-          attributes: parseResult.attributes,
-          uniforms: parseResult.uniforms,
-        };
-      } else {
-        addBuilderParams(style.builder);
-        shaders = style;
-      }
-      return new VectorStyleRenderer(
-        shaders,
-        this.styleVariables_,
-        this.helper,
-        this.hitDetectionEnabled_,
-        'filter' in style ? style.filter : null,
-      );
-    });
+    const styleShaders = convertStyleToShaders(
+      this.style_,
+      this.styleVariables_,
+    );
+    for (const styleShader of styleShaders) {
+      addBuilderParams(styleShader.builder);
+    }
+
+    this.styleRenderer_ = new VectorStyleRenderer(
+      styleShaders,
+      this.styleVariables_,
+      this.helper,
+      this.hitDetectionEnabled_,
+    );
   }
 
   /**
@@ -254,7 +238,7 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
    * @override
    */
   createTileRepresentation(options) {
-    const tileRep = new TileGeometry(options, this.styleRenderers_);
+    const tileRep = new TileGeometry(options, this.styleRenderer_);
     // redraw the layer when the tile is ready
     const listener = () => {
       if (tileRep.ready) {
@@ -376,22 +360,19 @@ class WebGLVectorTileLayerRenderer extends WebGLBaseTileLayerRenderer {
   ) {
     const gutterExtent = getIntersection(tileExtent, renderExtent, tileExtent);
     const tileZ = tileRepresentation.tile.getTileCoord()[0];
-    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,
-          gutterExtent,
-          buffers.invertVerticesTransform,
-          tileZ,
-          depth,
-        );
-      });
+    const buffers = tileRepresentation.buffers;
+    if (!buffers) {
+      return;
     }
+    this.styleRenderer_.render(buffers, frameState, () => {
+      this.applyUniforms_(
+        alpha,
+        gutterExtent,
+        buffers.invertVerticesTransform,
+        tileZ,
+        depth,
+      );
+    });
   }
 
   /**

package/util.js

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

package/webgl/Helper.d.ts

@@ -55,9 +55,9 @@ export type BufferCacheEntry = {
  */
 export type AttributeDescription = {
     /**
-     * Attribute name to use in shaders
+     * Attribute name to use in shaders; if null, this attribute will not be enabled and is simply used as padding in the buffers
      */
-    name: string;
+    name: string | null;
     /**
      * Number of components per attributes
      */

package/webgl/Helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Helper.d.ts","sourceRoot":"","sources":["Helper.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"Helper.d.ts","sourceRoot":"","sources":["Helper.js"],"names":[],"mappings":"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"}

package/webgl/Helper.js

@@ -66,7 +66,7 @@ export const AttributeType = {
 /**
  * Description of an attribute in a buffer
  * @typedef {Object} AttributeDescription
- * @property {string} name Attribute name to use in shaders
+ * @property {string|null} name Attribute name to use in shaders; if null, this attribute will not be enabled and is simply used as padding in the buffers
  * @property {number} size Number of components per attributes
  * @property {AttributeType} [type] Attribute type, i.e. number of bytes used to store the value. This is
  * determined by the class of typed array which the buffer uses (eg. `Float32Array` for a `FLOAT` attribute).
@@ -1115,13 +1115,16 @@ class WebGLHelper extends Disposable {
     let offset = 0;
     for (let i = 0; i < attributes.length; i++) {
       const attr = attributes[i];
-      this.enableAttributeArray_(
-        attr.name,
-        attr.size,
-        attr.type || FLOAT,
-        stride,
-        offset,
-      );
+      // if a name is not given, simply skip this slot in the buffer
+      if (attr.name) {
+        this.enableAttributeArray_(
+          attr.name,
+          attr.size,
+          attr.type || FLOAT,
+          stride,
+          offset,
+        );
+      }
       offset += attr.size * getByteSizeFromType(attr.type);
     }
   }