maplibre-compose-expressions/dev.sargunv.maplibrecompose.expressions.dsl

Package-level declarations

The Kotlin DSL for creating MapLibre expressions. This is the primary API you'll be using to create expressions.

Types

Case

data class Case

Condition

data class Condition<T : ExpressionValue>

Feature

object Feature

Object to access feature-related data, see feature

FormatSpan

data class FormatSpan

Represents a component of a format expression. See span.

Variable

@JvmInline

value class Variable<T : ExpressionValue>

Represents a variable bound with withVariable. Reference the bound expression with use.

Properties

val Expression<FloatValue>.dp: Expression<DpValue>

Converts a numeric Expression to a DpValue expression.

val E: Expression<FloatValue>

Returns the mathematical constant e

val Expression<FloatValue>.em: Expression<TextUnitValue>

Converts a numeric Expression to an TextUnitValue expression in EM

feature

val feature: Feature

Accesses to feature-related data

LN_2

val LN_2: Expression<FloatValue>

Returns mathematical constant ln(2) = natural logarithm of 2.

milliseconds

val Expression<FloatValue>.milliseconds: Expression<MillisecondsValue>

Converts a numeric Expression in milliseconds to a MillisecondsValue expression.

val PI: Expression<FloatValue>

Returns the mathematical constant π

seconds

val Expression<FloatValue>.seconds: Expression<MillisecondsValue>

Converts a numeric Expression in seconds to a MillisecondsValue expression.

val Expression<FloatValue>.sp: Expression<TextUnitValue>

Converts a numeric Expression to an TextUnitValue expression in SP.

Functions

abs

fun <U, V : NumberValue> abs(value: Expression<V>): Expression<V>

Returns the absolute value of value, i.e. always a positive value.

acos

fun acos(value: Expression<FloatValue>): Expression<FloatValue>

Returns the arccosine of value.

all

fun all(vararg expressions: Expression<BooleanValue>): Expression<BooleanValue>

Returns whether all expressions are true.

and

infix fun Expression<BooleanValue>.and(other: Expression<BooleanValue>): Expression<BooleanValue>

Returns whether both this and other expressions are true.

any

fun any(vararg expressions: Expression<BooleanValue>): Expression<BooleanValue>

Returns whether any expressions are true.

asBoolean

fun Expression<*>.asBoolean(vararg fallbacks: Expression<*>): Expression<BooleanValue>

Asserts that this value is a boolean.

asDpOffset

fun Expression<*>.asDpOffset(): Expression<DpOffsetValue>

Asserts that this is a list of numbers of length 2.

asEnum

inline fun <T : Enum<T>, EnumValue<T>> Expression<*>.asEnum(vararg fallbacks: Expression<*>): Expression<T>

Asserts that this value is an entry of the enum specified by T.

asin

fun asin(value: Expression<FloatValue>): Expression<FloatValue>

Returns the arcsine of value.

asList

fun Expression<*>.asList(type: Expression<ExpressionType> = nil(), length: Expression<IntValue> = nil()): Expression<ListValue<*>>

Asserts that this is a list (optionally with a specific item type and length).

asMap

fun Expression<*>.asMap(vararg fallbacks: Expression<*>): Expression<MapValue<*>>

Asserts that this value is a map.

asNumber

fun Expression<*>.asNumber(vararg fallbacks: Expression<*>): Expression<FloatValue>

Asserts that this value is a number.

asOffset

fun Expression<*>.asOffset(): Expression<FloatOffsetValue>

Asserts that this is a list of numbers of length 2.

asPadding

fun Expression<*>.asPadding(): Expression<DpPaddingValue>

Asserts that this is a list of numbers of length 4.

asString

fun Expression<*>.asString(vararg fallbacks: Expression<*>): Expression<StringValue>

Asserts that this value is a string.

asVector

fun <U, V : NumberValue> Expression<*>.asVector(length: Expression<IntValue> = nil()): Expression<V>

Asserts that this is a list of numbers, optionally with a specific length.

atan

fun atan(value: Expression<FloatValue>): Expression<FloatValue>

Returns the arctangent of value.

case

fun <O : ExpressionValue> case(label: Number, output: Expression<O>): Case<FloatValue, O>

fun <O : ExpressionValue> case(label: String, output: Expression<O>): Case<StringValue, O>

@JvmName(name = "numbersCase")

fun <O : ExpressionValue> case(label: List<Number>, output: Expression<O>): Case<FloatValue, O>

@JvmName(name = "stringsCase")

fun <O : ExpressionValue> case(label: List<String>, output: Expression<O>): Case<StringValue, O>

Create a Case, see switch

ceil

fun ceil(value: Expression<FloatValue>): Expression<IntValue>

Returns the smallest integer that is greater than or equal to value.

coalesce

fun <T : ExpressionValue> coalesce(vararg values: Expression<T>): Expression<T>

Evaluates each expression in values in turn until the first non-null value is obtained, and returns that value.

collator

fun collator(caseSensitive: Expression<BooleanValue>? = null, diacriticSensitive: Expression<BooleanValue>? = null, locale: Expression<StringValue>? = null): Expression<CollatorValue>

fun collator(caseSensitive: Boolean? = null, diacriticSensitive: Boolean? = null, locale: String? = null): Expression<CollatorValue>

Returns a collator for use in locale-dependent comparison operations. The caseSensitive and diacriticSensitive options default to false. The locale argument specifies the IETF language tag of the locale to use. If none is provided, the default locale is used. If the requested locale is not available, the collator will use a system-defined fallback locale. Use resolvedLocale to test the results of locale fallback behavior.

condition

fun <T : ExpressionValue> condition(test: Expression<BooleanValue>, output: Expression<T>): Condition<T>

Create a Condition, see case

const

fun <T : EnumValue<T>> const(value: T): EnumLiteral<T>

Creates a literal expression for an enum value implementing EnumValue.

fun const(padding: PaddingValues.Absolute): DpPaddingLiteral

Creates a literal expression for a PaddingValues.Absolute value.

fun const(offset: Offset): OffsetLiteral

Creates a literal expression for an Offset value.

fun const(color: Color): ColorLiteral

Creates a literal expression for a Color value.

fun const(dp: Dp): DpLiteral

Creates a literal expression for a Dp value.

fun const(dpOffset: DpOffset): DpOffsetLiteral

Creates a literal expression for a DpOffset value.

fun const(textUnit: TextUnit): TextUnitCalculation

Creates a literal expression for a specified TextUnit value in SP or EM. It can be provided in either unit, and will resolve to one at runtime depending on the property it is used in.

fun const(bool: Boolean): BooleanLiteral

Creates a literal expression for a Boolean value.

fun const(float: Float): FloatLiteral

Creates a literal expression for a dimensionless Float value.

fun const(int: Int): IntLiteral

Creates a literal expression for an dimensionless Int value.

fun const(string: String): StringLiteral

Creates a literal expression for a String value.

fun <T : ExpressionValue> const(list: List<Literal<T, *>>): ListLiteral<T>

Creates a literal expression for a list.

@JvmName(name = "constNumberList")

fun const(list: List<Number>): Literal<VectorValue<Number>, *>

Creates a literal expression for a list of numbers.

@JvmName(name = "constStringList")

fun const(list: List<String>): ListLiteral<StringValue>

Creates a literal expression for a list of strings.

fun const(duration: Duration): MillisecondsLiteral

Creates a literal expression for a Duration value.

contains

@JvmName(name = "containsList")

fun <T : ExpressionValue> Expression<ListValue<T>>.contains(item: Expression<T>): Expression<BooleanValue>

Returns whether this list contains the item.

@JvmName(name = "containsString")

fun Expression<StringValue>.contains(substring: Expression<StringValue>): Expression<BooleanValue>

@JvmName(name = "containsString")

fun Expression<StringValue>.contains(substring: String): Expression<BooleanValue>

@JvmName(name = "containsString")

fun String.contains(substring: Expression<StringValue>): Expression<BooleanValue>

Returns whether this string contains the substring.

convertToBoolean

fun Expression<*>.convertToBoolean(): Expression<BooleanValue>

Converts this expression to a boolean expression.

convertToColor

fun Expression<*>.convertToColor(vararg fallbacks: Expression<*>): Expression<ColorValue>

Converts this expression to a color expression.

convertToNumber

fun Expression<*>.convertToNumber(vararg fallbacks: Expression<*>): Expression<FloatValue>

Converts this expression to a number.

convertToString

fun Expression<*>.convertToString(): Expression<StringValue>

Converts this expression to a string.

cos

fun cos(value: Expression<FloatValue>): Expression<FloatValue>

Returns the cosine of value.

cubicBezier

fun cubicBezier(x1: Expression<FloatValue>, y1: Expression<FloatValue>, x2: Expression<FloatValue>, y2: Expression<FloatValue>): Expression<InterpolationValue>

fun cubicBezier(x1: Float, y1: Float, x2: Float, y2: Float): Expression<InterpolationValue>

Interpolates using the cubic bezier curve defined by the given control points between the pairs of stops.

distance

fun distance(geometry: Expression<GeoJsonValue>): Expression<FloatValue>

Returns the shortest distance in meters between the evaluated feature and geometry.

div

@JvmName(name = "divUnitBoth")

operator fun <U, V : NumberValue> Expression<V>.div(divisor: Expression<V>): Expression<FloatValue>

@JvmName(name = "divUnitLeftOnly")

operator fun <U, V : NumberValue> Expression<V>.div(divisor: Expression<FloatValue>): Expression<V>

operator fun Expression<FloatValue>.div(divisor: Expression<FloatValue>): Expression<FloatValue>

Returns the result of floating point division of this number expression by divisor.

fun eq(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is equal to the right string expression. An optional collator (see collator function) can be specified to control locale-dependent string comparisons.

infix fun Expression<EquatableValue>.eq(other: Expression<EquatableValue>): Expression<BooleanValue>

Returns whether this expression is equal to other.

exponential

fun exponential(base: Expression<FloatValue>): Expression<InterpolationValue>

fun exponential(base: Float): Expression<InterpolationValue>

Interpolates exponentially between the stops.

floor

fun floor(value: Expression<FloatValue>): Expression<IntValue>

Returns the largest integer that is less than or equal to value.

format

fun format(vararg spans: FormatSpan): Expression<FormattedValue>

Returns a formatted string for displaying mixed-format text in the textField property (see dev.sargunv.maplibrecompose.compose.layer.SymbolLayer). The input may contain a string literal or expression, including an image expression.

formatToString

fun Expression<NumberValue<*>>.formatToString(locale: Expression<StringValue>? = null, currency: Expression<StringValue>? = null, minFractionDigits: Expression<IntValue>? = null, maxFractionDigits: Expression<IntValue>? = null): Expression<StringValue>

fun Expression<NumberValue<*>>.formatToString(locale: String? = null, currency: String? = null, minFractionDigits: Int? = null, maxFractionDigits: Int? = null): Expression<StringValue>

Converts this number into a string representation using the provided formatting rules.

get

@JvmName(name = "getAt")

operator fun <T : ExpressionValue> Expression<ListValue<T>>.get(index: Expression<IntValue>): Expression<T>

@JvmName(name = "getAt")

operator fun <T : ExpressionValue> Expression<ListValue<T>>.get(index: Int): Expression<T>

Returns the item at index.

operator fun <T : ExpressionValue> Expression<MapValue<T>>.get(key: Expression<StringValue>): Expression<T>

operator fun <T : ExpressionValue> Expression<MapValue<T>>.get(key: String): Expression<T>

Returns the value corresponding the given key or null if it is not present in this map.

fun gt(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is strictly greater than the right string expression. An optional collator (see collator) can be specified to control locale-dependent string comparisons.

infix fun <T> Expression<ComparableValue<T>>.gt(other: Expression<ComparableValue<T>>): Expression<BooleanValue>

Returns whether this expression is strictly greater than other.

gte

fun gte(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is greater than or equal to the right string expression. An optional collator (see collator) can be specified to control locale-dependent string comparisons.

gte

infix fun <T> Expression<ComparableValue<T>>.gte(other: Expression<ComparableValue<T>>): Expression<BooleanValue>

Returns whether this expression is greater than or equal to other.

has

fun Expression<MapValue<*>>.has(key: Expression<StringValue>): Expression<BooleanValue>

fun Expression<MapValue<*>>.has(key: String): Expression<BooleanValue>

Returns whether the given key is in this map.

heatmapDensity

fun heatmapDensity(): Expression<FloatValue>

Gets the kernel density estimation of a pixel in a heatmap layer, which is a relative measure of how many data points are crowded around a particular pixel. Can only be used in the expression for the color parameter in a HeatmapLayer dev.sargunv.maplibrecompose.compose.layer.HeatmapLayer.

image

fun image(value: Expression<StringValue>): Expression<ImageValue>

fun image(value: String): Expression<ImageValue>

fun image(value: ImageBitmap, sdf: Boolean = false): Expression<ImageValue>

fun image(value: Painter, size: DpSize? = null, sdf: Boolean = false): Expression<ImageValue>

Returns an image type for use in iconImage (see dev.sargunv.maplibrecompose.compose.layer.SymbolLayer), pattern entries (see dev.sargunv.maplibrecompose.compose.layer.BackgroundLayer, dev.sargunv.maplibrecompose.compose.layer.FillLayer, dev.sargunv.maplibrecompose.compose.layer.FillExtrusionLayer, dev.sargunv.maplibrecompose.compose.layer.LineLayer) and as a section in the format expression.

indexOf

@JvmName(name = "indexOfList")

fun <T : ExpressionValue> Expression<ListValue<T>>.indexOf(item: Expression<T>, startIndex: Expression<IntValue>? = null): Expression<IntValue>

@JvmName(name = "indexOfList")

fun <T : ExpressionValue> Expression<ListValue<T>>.indexOf(item: Expression<T>, startIndex: Int? = null): Expression<IntValue>

Returns the first index at which the item is located in this list, or -1 if it cannot be found. Accepts an optional startIndex from where to begin the search.

@JvmName(name = "indexOfString")

fun Expression<StringValue>.indexOf(substring: Expression<StringValue>, startIndex: Expression<IntValue>? = null): Expression<IntValue>

@JvmName(name = "indexOfString")

fun Expression<StringValue>.indexOf(substring: String, startIndex: Int? = null): Expression<IntValue>

@JvmName(name = "indexOfString")

fun String.indexOf(substring: Expression<StringValue>, startIndex: Expression<IntValue>? = null): Expression<IntValue>

Returns the first index at which the substring is located in this string, or -1 if it cannot be found. Accepts an optional startIndex from where to begin the search.

interpolate

fun <T, V : InterpolateableValue<T>> interpolate(type: Expression<InterpolationValue>, input: Expression<FloatValue>, vararg stops: Pair<Number, Expression<V>>): Expression<V>

Produces continuous, smooth results by interpolating between pairs of input and output values (stops), given the input value.

interpolateHcl

fun interpolateHcl(type: Expression<InterpolationValue>, input: Expression<FloatValue>, vararg stops: Pair<Number, Expression<ColorValue>>): Expression<ColorValue>

Produces continuous, smooth results by interpolating between pairs of input and output values (stops), given the input value. Works like interpolate, but the interpolation is performed in the Hue-Chroma-Luminance color space.

interpolateLab

fun interpolateLab(type: Expression<InterpolationValue>, input: Expression<FloatValue>, vararg stops: Pair<Number, Expression<ColorValue>>): Expression<ColorValue>

isScriptSupported

fun Expression<StringValue>.isScriptSupported(): Expression<BooleanValue>

Returns true if this string is expected to render legibly. Returns false if this string contains sections that cannot be rendered without potential loss of meaning (e.g. Indic scripts that require complex text shaping).

length

@JvmName(name = "lengthOfList")

fun Expression<ListValue<*>>.length(): Expression<IntValue>

Gets the length of a this list.

@JvmName(name = "lengthOfString")

fun Expression<StringValue>.length(): Expression<IntValue>

Gets the length of this string.

linear

fun linear(): Expression<InterpolationValue>

Interpolates linearly between the pairs of stops.

fun ln(value: Expression<FloatValue>): Expression<FloatValue>

Returns the natural logarithm of value.

log10

fun log10(value: Expression<FloatValue>): Expression<FloatValue>

Returns the base-ten logarithm of value.

log2

fun log2(value: Expression<FloatValue>): Expression<FloatValue>

Returns the base-two logarithm of value.

lowercase

fun Expression<StringValue>.lowercase(): Expression<StringValue>

Returns this string converted to lowercase. Follows the Unicode Default Case Conversion algorithm and the locale-insensitive case mappings in the Unicode Character Database.

fun lt(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is strictly less than the right string expression. An optional collator (see collator) can be specified to control locale-dependent string comparisons.

infix fun <T> Expression<ComparableValue<T>>.lt(other: Expression<ComparableValue<T>>): Expression<BooleanValue>

Returns whether this expression is strictly less than other.

lte

fun lte(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is less than or equal to the right string expression. An optional collator (see collator) can be specified to control locale-dependent string comparisons.

lte

infix fun <T> Expression<ComparableValue<T>>.lte(other: Expression<ComparableValue<T>>): Expression<BooleanValue>

Returns whether this string expression is less than or equal to other.

max

fun <U, V : NumberValue> max(vararg numbers: Expression<V>): Expression<V>

Returns the greatest of all given numbers.

min

fun <U, V : NumberValue> min(vararg numbers: Expression<V>): Expression<V>

Returns the smallest of all given numbers.

minus

operator fun <U, V : NumberValue> Expression<V>.minus(other: Expression<NumberValue>): Expression<V>

Returns the result of subtracting other from this number expression.

neq

fun neq(left: Expression<StringValue>, right: Expression<StringValue>, collator: Expression<CollatorValue>): Expression<BooleanValue>

Returns whether the left string expression is not equal to the right string expression. An optional collator (see collator) can be specified to control locale-dependent string comparisons.

neq

infix fun Expression<EquatableValue>.neq(other: Expression<EquatableValue>): Expression<BooleanValue>

Returns whether this expression is not equal to other.

nil

fun nil(): Expression<Nothing>

Creates a literal expression for a null value.

not

@JvmName(name = "notOperator")

operator fun Expression<BooleanValue>.not(): Expression<BooleanValue>

Negates this expression.

offset

fun offset(x: Dp, y: Dp): DpOffsetLiteral

Creates a literal expression for a 2D DpOffset.

fun offset(x: TextUnit, y: TextUnit): Expression<TextUnitOffsetValue>

Creates a literal expression for a 2D TextUnit offset.

fun offset(x: Float, y: Float): OffsetLiteral

Creates a literal expression for a 2D Offset.

infix fun Expression<BooleanValue>.or(other: Expression<BooleanValue>): Expression<BooleanValue>

Returns whether any of this or the other expressions are true.

plus

operator fun <U, V : NumberValue> Expression<V>.plus(other: Expression<V>): Expression<V>

Returns the sum of this number expression with other.

@JvmName(name = "concat")

operator fun Expression<StringValue>.plus(other: Expression<StringValue>): Expression<StringValue>

Concatenates this string expression with other.

pow

fun Expression<FloatValue>.pow(exponent: Expression<FloatValue>): Expression<FloatValue>

fun Expression<FloatValue>.pow(exponent: Float): Expression<FloatValue>

Returns the result of raising this number expression to the power of exponent.

rem

operator fun <U, V : NumberValue> Expression<V>.rem(divisor: Expression<IntValue>): Expression<V>

Returns the remainder after integer division of this number expression by divisor.

resolvedLocale

fun resolvedLocale(collator: Expression<CollatorValue>): Expression<StringValue>

Returns the IETF language tag of the locale being used by the provided collator. This can be used to determine the default system locale, or to determine if a requested locale was successfully loaded.

rgbColor

fun rgbColor(red: Expression<IntValue>, green: Expression<IntValue>, blue: Expression<IntValue>, alpha: Expression<FloatValue>? = null): Expression<ColorValue>

Creates a color value from red, green, and blue components, which must range between 0 and 255, and optionally an alpha component which must range between 0 and 1.

round

fun round(value: Expression<FloatValue>): Expression<IntValue>

Rounds value to the nearest integer. Halfway values are rounded away from zero.

sin

fun sin(value: Expression<FloatValue>): Expression<FloatValue>

Returns the sine of value.

slice

fun <T : ExpressionValue> Expression<ListValue<T>>.slice(startIndex: Expression<IntValue>, endIndex: Expression<IntValue>? = null): Expression<ListValue<T>>

fun <T : ExpressionValue> Expression<ListValue<T>>.slice(startIndex: Int, endIndex: Int? = null): Expression<ListValue<T>>

Returns the items in this list from the startIndex (inclusive) to the end of this list if endIndex is not specified or null, otherwise to endIndex (exclusive).

span

fun span(value: Expression<FormattableValue>): FormatSpan

Configures an image in a format expression.

fun span(value: Expression<StringValue>, textFont: Expression<StringValue>? = null, textColor: Expression<ColorValue>? = null, textSize: Expression<TextUnitValue>? = null): FormatSpan

fun span(value: String, textFont: String? = null, textColor: Color? = null, textSize: TextUnit? = null): FormatSpan

Configures a span of text in a format expression.

sqrt

fun sqrt(value: Expression<FloatValue>): Expression<FloatValue>

Returns the square root of value.

step

fun <T : ExpressionValue> step(input: Expression<FloatValue>, fallback: Expression<T>, vararg stops: Pair<Number, Expression<T>>): Expression<T>

Produces discrete, stepped results by evaluating a piecewise-constant function defined by pairs of input and output values (stops). Returns the output value of the stop just less than the input, or the fallback if the input is less than the first stop.

substring

fun Expression<StringValue>.substring(startIndex: Expression<IntValue>, endIndex: Expression<IntValue>? = null): Expression<StringValue>

fun Expression<StringValue>.substring(startIndex: Int, endIndex: Int? = null): Expression<StringValue>

Returns a substring from this string from the startIndex (inclusive) to the end of the string if endIndex is not specified or null, otherwise to endIndex (exclusive).

switch

fun <T : ExpressionValue> switch(vararg conditions: Condition<T>, fallback: Expression<T>): Expression<T>

Selects the first output from the given conditions whose corresponding test condition evaluates to true, or the fallback value otherwise.

fun switch(input: Expression, vararg cases: Case<I, O>, fallback: Expression<O>): Expression<O>

Selects the output from the given cases whose label value matches the input, or the fallback value if no match is found.

tan

fun tan(value: Expression<FloatValue>): Expression<FloatValue>

Returns the tangent of value.

textVariableAnchorOffset

fun textVariableAnchorOffset(vararg pairs: Pair<SymbolAnchor, Offset>): Literal<TextVariableAnchorOffsetValue, List<*>>

Creates a literal expression for TextVariableAnchorOffsetValue, used by dev.sargunv.maplibrecompose.compose.layer.SymbolLayer's textVariableAnchorOffset parameter.

times

@JvmName(name = "timesUnitLeft")

operator fun <U, V : NumberValue> Expression<V>.times(other: Expression<FloatValue>): Expression<V>

@JvmName(name = "timesUnitRight")

operator fun <U, V : NumberValue> Expression<FloatValue>.times(other: Expression<V>): Expression<V>

operator fun Expression<FloatValue>.times(other: Expression<FloatValue>): Expression<FloatValue>

Returns the product of this number expression with other.

toRgbaComponents

fun Expression<ColorValue>.toRgbaComponents(): Expression<VectorValue<Number>>

Returns a four-element list, containing the color's red, green, blue, and alpha components, in that order.

type

fun Expression<*>.type(): Expression<ExpressionType>

Returns a string describing the type of this expression.

unaryMinus

operator fun <U, V : NumberValue> Expression<V>.unaryMinus(): Expression<V>

Negates this number expression.

uppercase

fun Expression<StringValue>.uppercase(): Expression<StringValue>

Returns this string converted to uppercase. Follows the Unicode Default Case Conversion algorithm and the locale-insensitive case mappings in the Unicode Character Database.

use

fun <T : ExpressionValue> Variable<T>.use(): Expression<T>

References a Variable bound in withVariable.

within

fun within(geometry: Expression<GeoJsonValue>): Expression<BooleanValue>

Returns true if the evaluated feature is fully contained inside a boundary of the input geometry, false otherwise. The input value can be a valid GeoJSON of type Polygon, MultiPolygon, Feature, or FeatureCollection. Supported features for evaluation:

withVariable

inline fun <V : ExpressionValue, R : ExpressionValue> withVariable(name: String, value: Expression<V>, block: (Variable<V>) -> Expression<R>): Expression<R>

Binds expression value to a Variable with the given name, which can then be referenced inside the block using use. For example:

zoom

fun zoom(): Expression<FloatValue>

Gets the current zoom level. Note that in layer style properties, zoom may only appear as the input to a top-level step or interpolate (, interpolateHcl, interpolateLab, ...) expression.