ol 10.3.2-dev.1734966546937 → 10.3.2-dev.1735323678164

package/style/flat.js

@@ -99,16 +99,20 @@
  * Fill style properties applied to polygon features.
  *
  * @typedef {Object} FlatFill
- * @property {ColorExpression} [fill-color] The fill color. `'none'` means no fill and no hit detection.
- * @property {StringExpression} [fill-pattern-src] Fill pattern image URL.
+ * @property {ColorExpression} [fill-color] The fill color. `'none'` means no fill and no hit detection (applies to Canvas only).
+ * @property {StringExpression} [fill-pattern-src] Fill pattern image source URI. If `fill-color` is defined as well,
+ * it will be used to tint this image. (Expressions only in Canvas)
  * @property {SizeExpression} [fill-pattern-size] Fill pattern image size in pixels.
  * Can be used together with `fill-pattern-offset` to define the sub-rectangle to use
  * from a fill pattern image sprite sheet.
- * @property {SizeExpression} [fill-pattern-offset] Fill pattern image offset in pixels.
+ * @property {SizeExpression} [fill-pattern-offset=[0, 0]] Offset, which, together with the size and the offset origin, define the
+ * sub-rectangle to use from the original fill pattern image.
+ * @property {import("./Icon.js").IconOrigin} [fill-pattern-offset-origin='top-left'] Origin of the offset: `bottom-left`, `bottom-right`,
+ * `top-left` or `top-right`. (WebGL only)
  */
 
 /**
- * Stroke style properties applied to line strings and polygon boundaries.  To apply a stroke, at least one of
+ * Stroke style properties applied to line strings and polygon boundaries. To apply a stroke, at least one of
  * `stroke-color` or `stroke-width` must be provided.
  *
  * @typedef {Object} FlatStroke
@@ -119,11 +123,23 @@
  * @property {NumberArrayExpression} [stroke-line-dash] Line dash pattern.
  * @property {NumberExpression} [stroke-line-dash-offset=0] Line dash offset.
  * @property {NumberExpression} [stroke-miter-limit=10] Miter limit.
+ * @property {NumberExpression} [stroke-offset] Stroke offset in pixel. A positive value offsets the line to the right,
+ * relative to the direction of the line. (WebGL only)
+ * @property {string} [stroke-pattern-src] Stroke pattern image source URI. If `stroke-color` is defined as well,
+ * it will be used to tint this image. (WebGL only)
+ * @property {SizeExpression} [stroke-pattern-offset=[0, 0]] Offset, which, together with the size and the offset origin,
+ * define the sub-rectangle to use from the original fill pattern image. (WebGL only)
+ * @property {import("./Icon.js").IconOrigin} [stroke-pattern-offset-origin='top-left'] Origin of the offset: `bottom-left`, `bottom-right`,
+ * `top-left` or `top-right`. (WebGL only)
+ * @property {SizeExpression} [stroke-pattern-size] Stroke pattern image size in pixel. Can be used together with `stroke-pattern-offset` to define the
+ * sub-rectangle to use from the origin (sprite) fill pattern image. (WebGL only)
+ * @property {NumberExpression} [stroke-pattern-spacing] Spacing between each pattern occurrence in pixels; 0 if undefined.
  * @property {NumberExpression} [z-index] The zIndex of the style.
  */
 
 /**
- * Label style properties applied to all features.  At a minimum, a `text-value` must be provided.
+ * Label style properties applied to all features. At a minimum, a `text-value` must be provided.
+ * Note: text style is currently not supported in WebGL layers
  *
  * @typedef {Object} FlatText
  * @property {StringExpression} [text-value] Text content (with `\n` for line breaks).
@@ -186,78 +202,80 @@
  * @property {import("./Icon.js").IconAnchorUnits} [icon-anchor-y-units='fraction'] Units in which the anchor y value is
  * specified. A value of `'fraction'` indicates the y value is a fraction of the icon. A value of `'pixels'` indicates
  * the y value in pixels.
- * @property {import("../color.js").Color|string} [icon-color] Color to tint the icon. If not specified,
+ * @property {ColorExpression} [icon-color] Color to tint the icon. If not specified,
  * the icon will be left as is.
  * @property {null|string} [icon-cross-origin] The `crossOrigin` attribute for loaded images. Note that you must provide a
  * `icon-cross-origin` value if you want to access pixel data with the Canvas renderer.
  * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
- * @property {Array<number>} [icon-offset=[0, 0]] Offset, which, together with the size and the offset origin, define the
+ * @property {SizeExpression} [icon-offset=[0, 0]] Offset, which, together with the size and the offset origin, define the
  * sub-rectangle to use from the original icon image.
  * @property {NumberArrayExpression} [icon-displacement=[0,0]] Displacement of the icon.
  * @property {import("./Icon.js").IconOrigin} [icon-offset-origin='top-left'] Origin of the offset: `bottom-left`, `bottom-right`,
  * `top-left` or `top-right`.
  * @property {NumberExpression} [icon-opacity=1] Opacity of the icon.
  * @property {SizeExpression} [icon-scale=1] Scale.
- * @property {number} [icon-width] Width of the icon. If not specified, the actual image width will be used. Cannot be combined
- * with `scale`.
- * @property {number} [icon-height] Height of the icon. If not specified, the actual image height will be used. Cannot be combined
- * with `scale`.
+ * @property {NumberExpression} [icon-width] Width of the icon. If not specified, the actual image width will be used. Cannot be combined
+ * with `scale`. (Expressions only in WebGL)
+ * @property {NumberExpression} [icon-height] Height of the icon. If not specified, the actual image height will be used. Cannot be combined
+ * with `scale`. (Expressions only in WebGL)
  * @property {NumberExpression} [icon-rotation=0] Rotation in radians (positive rotation clockwise).
- * @property {BooleanExpression} [icon-rotate-with-view=false] Whether to rotate the icon with the view.
- * @property {import("../size.js").Size} [icon-size] Icon size in pixel. Can be used together with `icon-offset` to define the
- * sub-rectangle to use from the origin (sprite) icon image.
- * @property {import("./Style.js").DeclutterMode} [icon-declutter-mode] Declutter mode
- * @property {NumberExpression} [z-index] The zIndex of the style.
+ * @property {BooleanExpression} [icon-rotate-with-view=false] Whether to rotate the icon with the view. (Expressions only supported in Canvas)
+ * @property {SizeExpression} [icon-size] Icon size in pixel. Can be used together with `icon-offset` to define the
+ * sub-rectangle to use from the origin (sprite) icon image. (Expressions only in WebGL)
+ * @property {import("./Style.js").DeclutterMode} [icon-declutter-mode] Declutter mode (Canvas only)
+ * @property {NumberExpression} [z-index] The zIndex of the style. (Canvas only)
  */
 
 /**
- * Regular shape style properties for rendering point features.  At least `shape-points` must be provided.
+ * Regular shape style properties for rendering point features. At least `shape-points` must be provided.
  *
  * @typedef {Object} FlatShape
- * @property {number} [shape-points] Number of points for stars and regular polygons. In case of a polygon, the number of points
- * is the number of sides.
+ * @property {NumberExpression} [shape-points] Number of points for stars and regular polygons. In case of a polygon, the number of points
+ * is the number of sides. (Expressions only in WebGL)
  * @property {ColorExpression} [shape-fill-color] The fill color. `'none'` means no fill and no hit detection.
  * @property {ColorExpression} [shape-stroke-color] The stroke color.
  * @property {NumberExpression} [shape-stroke-width] Stroke pixel width.
- * @property {StringExpression} [shape-stroke-line-cap='round'] Line cap style: `butt`, `round`, or `square`.
- * @property {StringExpression} [shape-stroke-line-join='round'] Line join style: `bevel`, `round`, or `miter`.
- * @property {NumberArrayExpression} [shape-stroke-line-dash] Line dash pattern.
- * @property {NumberExpression} [shape-stroke-line-dash-offset=0] Line dash offset.
- * @property {NumberExpression} [shape-stroke-miter-limit=10] Miter limit.
- * @property {number} [shape-radius] Radius of a regular polygon.
- * @property {number} [shape-radius2] Second radius to make a star instead of a regular polygon.
- * @property {number} [shape-angle=0] Shape's angle in radians. A value of 0 will have one of the shape's point facing up.
+ * @property {StringExpression} [shape-stroke-line-cap='round'] Line cap style: `butt`, `round`, or `square`. (Canvas only)
+ * @property {StringExpression} [shape-stroke-line-join='round'] Line join style: `bevel`, `round`, or `miter`. (Canvas only)
+ * @property {NumberArrayExpression} [shape-stroke-line-dash] Line dash pattern. (Canvas only)
+ * @property {NumberExpression} [shape-stroke-line-dash-offset=0] Line dash offset. (Canvas only)
+ * @property {NumberExpression} [shape-stroke-miter-limit=10] Miter limit. (Canvas only)
+ * @property {NumberExpression} [shape-radius] Radius of a regular polygon. (Expressions only in WebGL)
+ * @property {NumberExpression} [shape-radius2] Second radius to make a star instead of a regular polygon. (Expressions only in WebGL)
+ * @property {NumberExpression} [shape-angle=0] Shape's angle in radians. A value of 0 will have one of the shape's point facing up. (Expressions only in WebGL)
  * @property {NumberArrayExpression} [shape-displacement=[0,0]] Displacement of the shape
+ * @property {NumberExpression} [shape-opacity] Shape opacity. (WebGL only)
  * @property {NumberExpression} [shape-rotation=0] Rotation in radians (positive rotation clockwise).
- * @property {BooleanExpression} [shape-rotate-with-view=false] Whether to rotate the shape with the view.
- * @property {SizeExpression} [shape-scale=1] Scale. Unless two dimensional scaling is required a better
+ * @property {BooleanExpression} [shape-rotate-with-view=false] Whether to rotate the shape with the view. (Expression only supported in Canvas)
+ * @property {SizeExpression} [shape-scale=1] Scale. Unless two-dimensional scaling is required a better
  * result may be obtained with appropriate settings for `shape-radius` and `shape-radius2`.
- * @property {import("./Style.js").DeclutterMode} [shape-declutter-mode] Declutter mode.
- * @property {NumberExpression} [z-index] The zIndex of the style.
+ * @property {import("./Style.js").DeclutterMode} [shape-declutter-mode] Declutter mode. (Canvas only)
+ * @property {NumberExpression} [z-index] The zIndex of the style. (Canvas only)
  */
 
 /**
- * Circle style properties for rendering point features.  At least `circle-radius` must be provided.
+ * Circle style properties for rendering point features. At least `circle-radius` must be provided.
  *
  * @typedef {Object} FlatCircle
- * @property {number} [circle-radius] Circle radius.
+ * @property {NumberExpression} [circle-radius] Circle radius.
  * @property {ColorExpression} [circle-fill-color] The fill color. `'none'` means no fill and no hit detection.
  * @property {ColorExpression} [circle-stroke-color] The stroke color.
  * @property {NumberExpression} [circle-stroke-width] Stroke pixel width.
- * @property {StringExpression} [circle-stroke-line-cap='round'] Line cap style: `butt`, `round`, or `square`.
- * @property {StringExpression} [circle-stroke-line-join='round'] Line join style: `bevel`, `round`, or `miter`.
- * @property {NumberArrayExpression} [circle-stroke-line-dash] Line dash pattern.
- * @property {NumberExpression} [circle-stroke-line-dash-offset=0] Line dash offset.
- * @property {NumberExpression} [circle-stroke-miter-limit=10] Miter limit.
+ * @property {StringExpression} [circle-stroke-line-cap='round'] Line cap style: `butt`, `round`, or `square`. (Canvas only)
+ * @property {StringExpression} [circle-stroke-line-join='round'] Line join style: `bevel`, `round`, or `miter`. (Canvas only)
+ * @property {NumberArrayExpression} [circle-stroke-line-dash] Line dash pattern. (Canvas only)
+ * @property {NumberExpression} [circle-stroke-line-dash-offset=0] Line dash offset. (Canvas only)
+ * @property {NumberExpression} [circle-stroke-miter-limit=10] Miter limit. (Canvas only)
  * @property {NumberArrayExpression} [circle-displacement=[0,0]] displacement
- * @property {SizeExpression} [circle-scale=1] Scale. A two dimensional scale will produce an ellipse.
- * Unless two dimensional scaling is required a better result may be obtained with an appropriate setting for `circle-radius`.
+ * @property {SizeExpression} [circle-scale=1] Scale. A two-dimensional scale will produce an ellipse.
+ * Unless two-dimensional scaling is required a better result may be obtained with an appropriate setting for `circle-radius`.
+ * @property {NumberExpression} [circle-opacity] Circle opacity. (WebGL only)
  * @property {NumberExpression} [circle-rotation=0] Rotation in radians
- * (positive rotation clockwise, meaningful only when used in conjunction with a two dimensional scale).
- * @property {BooleanExpression} [circle-rotate-with-view=false] Whether to rotate the shape with the view
- * (meaningful only when used in conjunction with a two dimensional scale).
- * @property {import("./Style.js").DeclutterMode} [circle-declutter-mode] Declutter mode
- * @property {NumberExpression} [z-index] The zIndex of the style.
+ * (positive rotation clockwise, meaningful only when used in conjunction with a two-dimensional scale).
+ * @property {BooleanExpression} [circle-rotate-with-view=false] Whether to rotate the shape with the view (Expression only supported in Canvas)
+ * (meaningful only when used in conjunction with a two-dimensional scale).
+ * @property {import("./Style.js").DeclutterMode} [circle-declutter-mode] Declutter mode (Canvas only)
+ * @property {NumberExpression} [z-index] The zIndex of the style. (Canvas only)
  */
 
 /**
@@ -289,13 +307,13 @@ export function createDefaultStyle() {
 }
 
 /**
- * A rule is used to conditionally apply a style.  If the rule's filter evaluates to true,
+ * A rule is used to conditionally apply a style. If the rule's filter evaluates to true,
  * the style will be applied.
  *
  * @typedef {Object} Rule
  * @property {FlatStyle|Array<FlatStyle>} style The style to be applied if the filter matches.
  * @property {import("../expr/expression.js").EncodedExpression} [filter] The filter used
- * to determine if a style applies.  If no filter is included, the rule always applies
+ * to determine if a style applies. If no filter is included, the rule always applies
  * (unless it is an else rule).
  * @property {boolean} [else] If true, the rule applies only if no other previous rule applies.
  * If the else rule also has a filter, the rule will not apply if the filter does not match.

package/util.js

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

package/webgl/styleparser.d.ts

@@ -26,18 +26,19 @@ export function computeHash(input: any | string): string;
  * @property {import("../render/webgl/VectorStyleRenderer.js").AttributeDefinitions} attributes Attribute definitions
  */
 /**
- * Parses a {@link import("../style/webgl.js").WebGLStyle} object and returns a {@link ShaderBuilder}
+ * Parses a {@link import("../style/flat.js").FlatStyle} object and returns a {@link ShaderBuilder}
  * object that has been configured according to the given style, as well as `attributes` and `uniforms`
  * arrays to be fed to the `WebGLPointsRenderer` class.
  *
  * Also returns `uniforms` and `attributes` properties as expected by the
  * {@link module:ol/renderer/webgl/PointsLayer~WebGLPointsLayerRenderer}.
  *
- * @param {import("../style/webgl.js").WebGLStyle} style Literal style.
- * @param {import('../style/flat.js').StyleVariables} variables Style variables.
+ * @param {import("../style/flat.js").FlatStyle} style Flat style.
+ * @param {import('../style/flat.js').StyleVariables} [variables] Style variables.
+ * @param {import("../expr/expression.js").EncodedExpression} [filter] Filter (if any)
  * @return {StyleParseResult} Result containing shader params, attributes and uniforms.
  */
-export function parseLiteralStyle(style: import("../style/webgl.js").WebGLStyle, variables: import("../style/flat.js").StyleVariables): StyleParseResult;
+export function parseLiteralStyle(style: import("../style/flat.js").FlatStyle, variables?: import("../style/flat.js").StyleVariables, filter?: import("../expr/expression.js").EncodedExpression): StyleParseResult;
 export type StyleParseResult = {
     /**
      * Shader builder pre-configured according to a given style

package/webgl/styleparser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"styleparser.d.ts","sourceRoot":"","sources":["styleparser.js"],"names":[],"mappings":"AA0BA;;;;;;;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;AA4uBD;;;;;GAKG;AAEH;;;;;;;;;;;GAWG;AACH,yCAJW,OAAO,mBAAmB,EAAE,UAAU,aACtC,OAAO,kBAAkB,EAAE,cAAc,GACxC,gBAAgB,CAoK3B;;;;;aAnLa,aAAa;;;;cACb,OAAO,wCAAwC,EAAE,kBAAkB;;;;gBACnE,OAAO,wCAAwC,EAAE,oBAAoB;;8BA/zBvD,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,CAgK3B;;;;;aAhLa,aAAa;;;;cACb,OAAO,wCAAwC,EAAE,kBAAkB;;;;gBACnE,OAAO,wCAAwC,EAAE,oBAAoB;;8BAn0BvD,oBAAoB"}

package/webgl/styleparser.js

@@ -2,6 +2,7 @@
  * Utilities for parsing literal style objects
  * @module ol/webgl/styleparser
  */
+import {assert} from '../asserts.js';
 import {asArray} from '../color.js';
 import {
   BooleanType,
@@ -104,7 +105,7 @@ export function computeHash(input) {
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader builder
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
  * @param {'shape-'|'circle-'|'icon-'} prefix Properties prefix
@@ -196,7 +197,7 @@ function getColorFromDistanceField(
 /**
  * This will parse an image property provided by `<prefix>-src`
  * The image size expression in GLSL will be returned
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {'icon-'|'fill-pattern-'|'stroke-pattern-'} prefix Property prefix
@@ -209,7 +210,11 @@ function parseImageProperties(style, builder, uniforms, prefix, textureId) {
     style[`${prefix}cross-origin`] === undefined
       ? 'anonymous'
       : style[`${prefix}cross-origin`];
-  image.src = style[`${prefix}src`];
+  assert(
+    typeof style[`${prefix}src`] === 'string',
+    `WebGL layers do not support expressions for the ${prefix}src style property`,
+  );
+  image.src = /** @type {string} */ (style[`${prefix}src`]);
 
   // the size is provided asynchronously using a uniform
   uniforms[`u_texture${textureId}_size`] = () => {
@@ -225,7 +230,7 @@ function parseImageProperties(style, builder, uniforms, prefix, textureId) {
 
 /**
  * This will parse an image's offset properties provided by `<prefix>-offset`, `<prefix>-offset-origin` and `<prefix>-size`
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {'icon-'|'fill-pattern-'|'stroke-pattern-'} prefix Property prefix
  * @param {import("../expr/gpu.js").CompilationContext} context Shader compilation context (vertex or fragment)
  * @param {string} imageSize Pixel size of the full image as a GLSL expression
@@ -262,7 +267,7 @@ function parseImageOffsetProperties(
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
@@ -356,7 +361,7 @@ function parseCircleProperties(
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
@@ -494,7 +499,7 @@ function parseShapeProperties(
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
@@ -617,7 +622,7 @@ function parseIconProperties(
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader Builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
@@ -782,7 +787,7 @@ function parseStrokeProperties(
 }
 
 /**
- * @param {import("../style/webgl.js").WebGLStyle} style Style
+ * @param {import("../style/flat.js").FlatStyle} style Style
  * @param {ShaderBuilder} builder Shader Builder
  * @param {Object<string,import("../webgl/Helper").UniformValue>} uniforms Uniforms
  * @param {import("../expr/gpu.js").CompilationContext} vertContext Vertex shader compilation context
@@ -857,18 +862,19 @@ function parseFillProperties(
  */
 
 /**
- * Parses a {@link import("../style/webgl.js").WebGLStyle} object and returns a {@link ShaderBuilder}
+ * Parses a {@link import("../style/flat.js").FlatStyle} object and returns a {@link ShaderBuilder}
  * object that has been configured according to the given style, as well as `attributes` and `uniforms`
  * arrays to be fed to the `WebGLPointsRenderer` class.
  *
  * Also returns `uniforms` and `attributes` properties as expected by the
  * {@link module:ol/renderer/webgl/PointsLayer~WebGLPointsLayerRenderer}.
  *
- * @param {import("../style/webgl.js").WebGLStyle} style Literal style.
- * @param {import('../style/flat.js').StyleVariables} variables Style variables.
+ * @param {import("../style/flat.js").FlatStyle} style Flat style.
+ * @param {import('../style/flat.js').StyleVariables} [variables] Style variables.
+ * @param {import("../expr/expression.js").EncodedExpression} [filter] Filter (if any)
  * @return {StyleParseResult} Result containing shader params, attributes and uniforms.
  */
-export function parseLiteralStyle(style, variables) {
+export function parseLiteralStyle(style, variables, filter) {
   const vertContext = newCompilationContext();
 
   /**
@@ -895,12 +901,8 @@ export function parseLiteralStyle(style, variables) {
   parseStrokeProperties(style, builder, uniforms, vertContext, fragContext);
   parseFillProperties(style, builder, uniforms, vertContext, fragContext);
 
-  if (style.filter) {
-    const parsedFilter = expressionToGlsl(
-      fragContext,
-      style.filter,
-      BooleanType,
-    );
+  if (filter) {
+    const parsedFilter = expressionToGlsl(fragContext, filter, BooleanType);
     builder.setFragmentDiscardExpression(`!${parsedFilter}`);
   }
 

package/style/webgl.d.ts

@@ -1,269 +0,0 @@
-export type ExpressionValue = import("../expr/expression.js").ExpressionValue;
-export type ColorExpression = import("../color.js").Color | string | Array<ExpressionValue>;
-export type BaseProps = {
-    /**
-     * Filter expression. If it resolves to a number strictly greater than 0, the
-     * point will be displayed. If undefined, all points will show.
-     */
-    filter?: import("../expr/expression.js").ExpressionValue | undefined;
-};
-export type FillProps = {
-    /**
-     * Fill color.
-     */
-    "fill-color"?: ColorExpression | undefined;
-    /**
-     * Fill pattern image source URI. If `fill-color` is defined as well, it will be used to tint this image.
-     */
-    "fill-pattern-src"?: string | undefined;
-    /**
-     * Offset, which, together with the size and the offset origin, define the
-     * sub-rectangle to use from the original fill pattern image.
-     */
-    "fill-pattern-offset"?: number[] | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Origin of the offset: `bottom-left`, `bottom-right`,
-     * `top-left` or `top-right`.
-     */
-    "fill-pattern-offset-origin"?: import("./Icon.js").IconOrigin | undefined;
-    /**
-     * Fill pattern image size in pixel. Can be used together with `fill-pattern-offset` to define the
-     * sub-rectangle to use from the origin (sprite) fill pattern image.
-     */
-    "fill-pattern-size"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | undefined;
-};
-export type StrokeProps = {
-    /**
-     * The stroke color.
-     */
-    "stroke-color"?: ColorExpression | undefined;
-    /**
-     * Stroke pixel width.
-     */
-    "stroke-width"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Stroke offset in pixel. A positive value offsets the line to the right, relative to the direction of the line.
-     */
-    "stroke-offset"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Line cap style: `butt`, `round`, or `square`.
-     */
-    "stroke-line-cap"?: string | number | boolean | any[] | import("../color.js").Color | undefined;
-    /**
-     * Line join style: `bevel`, `round`, or `miter`.
-     */
-    "stroke-line-join"?: string | number | boolean | any[] | import("../color.js").Color | undefined;
-    /**
-     * Line dash pattern.
-     */
-    "stroke-line-dash"?: number[] | import("../expr/expression.js").ExpressionValue[] | undefined;
-    /**
-     * Line dash offset.
-     */
-    "stroke-line-dash-offset"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Miter limit.
-     */
-    "stroke-miter-limit"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Stroke pattern image source URI. If `stroke-color` is defined as well, it will be used to tint this image.
-     */
-    "stroke-pattern-src"?: string | undefined;
-    /**
-     * Offset, which, together with the size and the offset origin, define the
-     * sub-rectangle to use from the original fill pattern image.
-     */
-    "stroke-pattern-offset"?: number[] | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Origin of the offset: `bottom-left`, `bottom-right`,
-     * `top-left` or `top-right`.
-     */
-    "stroke-pattern-offset-origin"?: import("./Icon.js").IconOrigin | undefined;
-    /**
-     * Stroke pattern image size in pixel. Can be used together with `stroke-pattern-offset` to define the
-     * sub-rectangle to use from the origin (sprite) fill pattern image.
-     */
-    "stroke-pattern-size"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Spacing between each pattern occurrence in pixels; 0 if undefined.
-     */
-    "stroke-pattern-spacing"?: import("../expr/expression.js").ExpressionValue | undefined;
-};
-export type IconProps = {
-    /**
-     * Image source URI.
-     */
-    "icon-src"?: string | undefined;
-    /**
-     * Anchor. Default value is the icon center.
-     */
-    "icon-anchor"?: number[] | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Origin of the anchor: `bottom-left`, `bottom-right`,
-     * `top-left` or `top-right`.
-     */
-    "icon-anchor-origin"?: import("./Icon.js").IconOrigin | undefined;
-    /**
-     * Units in which the anchor x value is
-     * specified. A value of `'fraction'` indicates the x value is a fraction of the icon. A value of `'pixels'` indicates
-     * the x value in pixels.
-     */
-    "icon-anchor-x-units"?: import("./Icon.js").IconAnchorUnits | undefined;
-    /**
-     * Units in which the anchor y value is
-     * specified. A value of `'fraction'` indicates the y value is a fraction of the icon. A value of `'pixels'` indicates
-     * the y value in pixels.
-     */
-    "icon-anchor-y-units"?: import("./Icon.js").IconAnchorUnits | undefined;
-    /**
-     * Color to tint the icon. If not specified,
-     * the icon will be left as is.
-     */
-    "icon-color"?: ColorExpression | undefined;
-    /**
-     * Opacity of the icon.
-     */
-    "icon-opacity"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * The `crossOrigin` attribute for loaded images. Note that you must provide a
-     * `icon-cross-origin` value if you want to access pixel data with the Canvas renderer.
-     * See https://developer.mozilla.org/en-US/docs/Web/HTML/CORS_enabled_image for more detail.
-     */
-    "icon-cross-origin"?: string | null | undefined;
-    /**
-     * Displacement of the icon.
-     */
-    "icon-displacement"?: number[] | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Scale.
-     */
-    "icon-scale"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Width of the icon. If not specified, the actual image width will be used. Cannot be combined
-     * with `scale`.
-     */
-    "icon-width"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Height of the icon. If not specified, the actual image height will be used. Cannot be combined
-     * with `scale`.
-     */
-    "icon-height"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Rotation in radians (positive rotation clockwise).
-     */
-    "icon-rotation"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Whether to rotate the icon with the view.
-     */
-    "icon-rotate-with-view"?: boolean | undefined;
-    /**
-     * Offset, which, together with the size and the offset origin, define the
-     * sub-rectangle to use from the original icon image.
-     */
-    "icon-offset"?: number[] | import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Origin of the offset: `bottom-left`, `bottom-right`,
-     * `top-left` or `top-right`.
-     */
-    "icon-offset-origin"?: import("./Icon.js").IconOrigin | undefined;
-    /**
-     * Icon size in pixel. Can be used together with `icon-offset` to define the
-     * sub-rectangle to use from the origin (sprite) icon image.
-     */
-    "icon-size"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | undefined;
-};
-export type ShapeProps = {
-    /**
-     * Number of points for stars and regular polygons. In case of a polygon, the number of points
-     * is the number of sides.
-     */
-    "shape-points"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * The fill color.
-     */
-    "shape-fill-color"?: ColorExpression | undefined;
-    /**
-     * The stroke color.
-     */
-    "shape-stroke-color"?: ColorExpression | undefined;
-    /**
-     * Stroke pixel width.
-     */
-    "shape-stroke-width"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Shape opacity.
-     */
-    "shape-opacity"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Radius of a regular polygon.
-     */
-    "shape-radius"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Second radius to make a star instead of a regular polygon.
-     */
-    "shape-radius2"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Shape's angle in radians. A value of 0 will have one of the shape's point facing up.
-     */
-    "shape-angle"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Displacement of the shape
-     */
-    "shape-displacement"?: number[] | import("../expr/expression.js").ExpressionValue[] | undefined;
-    /**
-     * Rotation in radians (positive rotation clockwise).
-     */
-    "shape-rotation"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Whether to rotate the shape with the view.
-     */
-    "shape-rotate-with-view"?: boolean | undefined;
-    /**
-     * Scale. Unless two dimensional scaling is required a better
-     * result may be obtained with appropriate settings for `shape-radius` and `shape-radius2`.
-     */
-    "shape-scale"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | import("../expr/expression.js").ExpressionValue[] | undefined;
-};
-export type CircleProps = {
-    /**
-     * Circle radius.
-     */
-    "circle-radius"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * The fill color.
-     */
-    "circle-fill-color"?: ColorExpression | undefined;
-    /**
-     * The stroke color.
-     */
-    "circle-stroke-color"?: ColorExpression | undefined;
-    /**
-     * Stroke pixel width.
-     */
-    "circle-stroke-width"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Circle opacity.
-     */
-    "circle-opacity"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * displacement
-     */
-    "circle-displacement"?: number[] | import("../expr/expression.js").ExpressionValue[] | undefined;
-    /**
-     * Scale. A two dimensional scale will produce an ellipse.
-     * Unless two dimensional scaling is required a better result may be obtained with an appropriate setting for `circle-radius`.
-     */
-    "circle-scale"?: import("../size.js").Size | import("../expr/expression.js").ExpressionValue | import("../expr/expression.js").ExpressionValue[] | undefined;
-    /**
-     * Rotation in radians
-     * (positive rotation clockwise, meaningful only when used in conjunction with a two dimensional scale).
-     */
-    "circle-rotation"?: import("../expr/expression.js").ExpressionValue | undefined;
-    /**
-     * Whether to rotate the shape with the view
-     * (meaningful only when used in conjunction with a two dimensional scale).
-     */
-    "circle-rotate-with-view"?: boolean | undefined;
-};
-export type WebGLStyle = BaseProps & IconProps & StrokeProps & FillProps & CircleProps & ShapeProps;
-//# sourceMappingURL=webgl.d.ts.map

package/style/webgl.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"webgl.d.ts","sourceRoot":"","sources":["webgl.js"],"names":[],"mappings":"8BAMa,OAAO,uBAAuB,EAAE,eAAe;8BAG/C,OAAO,aAAa,EAAE,KAAK,GAAC,MAAM,GAAC,KAAK,CAAC,eAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAwHzD,SAAS,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU"}