Type Definitions

An argument validator applies various checks to an encoded expression arguments Returns the parsed arguments if any. Third argument is the array of parsed arguments from previous validators Fourth argument is an optional type hint

EncodedExpression{LiteralValue} {Array}


Expression{LiteralExpression} {CallExpression}


ExpressionValue{Array.<*>} {Color} {string} {number} {boolean}

Base type used for literal style parameters; can be a number literal or the output of an operator, which in turns takes
ExpressionValue
arguments.See below for details on the available operators (with notes for those that are WebGL or Canvas only).
Reading operators:
['band', bandIndex, xOffset, yOffset]
For tile layers only. Fetches pixel values from bandbandIndex
of the source's data. The firstbandIndex
of the source data is1
. Fetched values are in the 0..1 range.TileImage
sources have 4 bands: red, green, blue and alpha.DataTileSource
sources can have any number of bands, depending on the underlying data source andconfiguration
.xOffset
andyOffset
are optional and allow specifying pixel offsets for x and y. This is used for sampling data from neighboring pixels (WebGL only).['get', 'attributeName', typeHint]
fetches a feature property value, similar tofeature.get('attributeName')
A type hint can optionally be specified, in case the resulting expression contains a type ambiguity which will make it invalid. Type hints can be one of: 'string', 'color', 'number', 'boolean', 'number[]'['geometrytype']
returns a feature's geometry type as string, either: 'LineString', 'Point' or 'Polygon'Multi*
values are returned as their singular equivalentCircle
geometries are returned as 'Polygon'GeometryCollection
geometries are returned as the type of the first geometry found in the collection (WebGL only).['resolution']
returns the current resolution['time']
The time in seconds since the creation of the layer (WebGL only).['var', 'varName']
fetches a value from the style variables; will throw an error if that variable is undefined['zoom']
The current zoom level (WebGL only).
Math operators:
['*', value1, value2, ...]
multiplies the values (either numbers or colors)['/', value1, value2]
dividesvalue1
byvalue2
['+', value1, value2, ...]
adds the values['', value1, value2]
subtractsvalue2
fromvalue1
['clamp', value, low, high]
clampsvalue
betweenlow
andhigh
['%', value1, value2]
returns the result ofvalue1 % value2
(modulo)['^', value1, value2]
returns the value ofvalue1
raised to thevalue2
power['abs', value1]
returns the absolute value ofvalue1
['floor', value1]
returns the nearest integer less than or equal tovalue1
['round', value1]
returns the nearest integer tovalue1
['ceil', value1]
returns the nearest integer greater than or equal tovalue1
['sin', value1]
returns the sine ofvalue1
['cos', value1]
returns the cosine ofvalue1
['atan', value1, value2]
returnsatan2(value1, value2)
. Ifvalue2
is not provided, returnsatan(value1)
['sqrt', value1]
returns the square root ofvalue1
Transform operators:
['case', condition1, output1, ...conditionN, outputN, fallback]
selects the first output whose corresponding condition evaluates totrue
. If no match is found, returns thefallback
value. All conditions should beboolean
, output and fallback can be any kind.['match', input, match1, output1, ...matchN, outputN, fallback]
compares theinput
value against all providedmatchX
values, returning the output associated with the first valid match. If no match is found, returns thefallback
value.input
andmatchX
values must all be of the same type, and can benumber
orstring
.outputX
andfallback
values must be of the same type, and can be of any kind.['interpolate', interpolation, input, stop1, output1, ...stopN, outputN]
returns a value by interpolating between pairs of inputs and outputs;interpolation
can either be['linear']
or['exponential', base]
wherebase
is the rate of increase from stop A to stop B (i.e. power to which the interpolation ratio is raised); a value of 1 is equivalent to['linear']
.input
andstopX
values must all be of typenumber
.outputX
values can benumber
orcolor
values. Note:input
will be clamped betweenstop1
andstopN
, meaning that all output values will be comprised betweenoutput1
andoutputN
.['string', value1, value2, ...]
returns the first value in the list that evaluates to a string. An example would be to provide a default value for get:['string', ['get', 'propertyname'], 'default value']]
(Canvas only).['number', value1, value2, ...]
returns the first value in the list that evaluates to a number. An example would be to provide a default value for get:['string', ['get', 'propertyname'], 42]]
(Canvas only).['coalesce', value1, value2, ...]
returns the first value in the list which is not null or undefined. An example would be to provide a default value for get:['coalesce', ['get','propertyname'], 'default value']]
(Canvas only).
Logical operators:
['<', value1, value2]
returnstrue
ifvalue1
is strictly lower thanvalue2
, orfalse
otherwise.['<=', value1, value2]
returnstrue
ifvalue1
is lower than or equalsvalue2
, orfalse
otherwise.['>', value1, value2]
returnstrue
ifvalue1
is strictly greater thanvalue2
, orfalse
otherwise.['>=', value1, value2]
returnstrue
ifvalue1
is greater than or equalsvalue2
, orfalse
otherwise.['==', value1, value2]
returnstrue
ifvalue1
equalsvalue2
, orfalse
otherwise.['!=', value1, value2]
returnstrue
ifvalue1
does not equalvalue2
, orfalse
otherwise.['!', value1]
returnsfalse
ifvalue1
istrue
or greater than0
, ortrue
otherwise.['all', value1, value2, ...]
returnstrue
if all the inputs aretrue
,false
otherwise.['any', value1, value2, ...]
returnstrue
if any of the inputs aretrue
,false
otherwise.['between', value1, value2, value3]
returnstrue
ifvalue1
is contained betweenvalue2
andvalue3
(inclusively), orfalse
otherwise.['in', needle, haystack]
returnstrue
ifneedle
is found inhaystack
, andfalse
otherwise. This operator has the following limitations:haystack
has to be an array of numbers or strings (searching for a substring in a string is not supported yet) Only literal arrays are supported as
haystack
for now; this means thathaystack
cannot be the result of an expression. Ifhaystack
is an array of strings, use theliteral
operator to disambiguate from an expression:['literal', ['abc', 'def', 'ghi']]
Conversion operators:
['array', value1, ...valueN]
creates a numerical array fromnumber
values; please note that the amount of values can currently only be 2, 3 or 4 (WebGL only).['color', red, green, blue, alpha]
or['color', shade, alpha]
creates acolor
value fromnumber
values; thealpha
parameter is optional; if not specified, it will be set to 1 (WebGL only). Note:red
,green
andblue
orshade
components must be values between 0 and 255;alpha
between 0 and 1.['palette', index, colors]
picks acolor
value from an array of colors using the given index; theindex
expression must evaluate to a number; the items in thecolors
array must be strings with hex colors (e.g.'#86A136'
), colors using the rgba[a] functional notation (e.g.'rgb(134, 161, 54)'
or'rgba(134, 161, 54, 1)'
), named colors (e.g.'red'
), or array literals with 3 ([r, g, b]) or 4 ([r, g, b, a]) values (with r, g, and b in the 0255 range and a in the 01 range) (WebGL only).['tostring', value]
converts the input value to a string. If the input is a boolean, the result is "true" or "false". If the input is a number, it is converted to a string as specified by the "NumberToString" algorithm of the ECMAScript Language Specification. If the input is a color, it is converted to a string of the form "rgba(r,g,b,a)". (Canvas only)
Values can either be literals or another operator, as they will be evaluated recursively. Literal values can be of the following types:
boolean
number
number[]
(number arrays can only have a length of 2, 3 or 4)string
Color

LiteralValue{boolean} {number} {string} {Array.<number>}


Third argument is a type hint

ParsingContext{Object}

Properties:
Name Type Description variables
Set.<string> Variables referenced with the 'var' operator.
properties
Set.<string> Properties referenced with the 'get' operator.
featureId
boolean The style uses the feature id.
geometryType
boolean The style uses the feature geometry type.
style
FlatStyle  WebGLStyle The style being parsed