Variable exprConst

expr: {
    abs: ((input: NumberInput) => Expr<number>);
    accumulated: (() => Expr<ExprValue>);
    acos: ((input: NumberInput) => Expr<number>);
    add: ((...inputs: NumberInput[]) => Expr<number>);
    all: ((...inputs: BooleanInput[]) => Expr<boolean>);
    any: ((...inputs: BooleanInput[]) => Expr<boolean>);
    asin: ((input: NumberInput) => Expr<number>);
    at: ((index: NumberInput, array: Expr<unknown>) => Expr<ExprValue>);
    atan: ((input: NumberInput) => Expr<number>);
    case: ((...args: (Resolvable | [BooleanInput, Resolvable])[]) => Expr<ExprValue>);
    ceil: ((input: NumberInput) => Expr<number>);
    coalesce: ((...inputs: Resolvable[]) => Expr<ExprValue>);
    collator: ((options?: CollatorOptions) => Expr<ExprCollator>);
    concat: ((...inputs: Resolvable[]) => Expr<string>);
    contains: ((needle: Resolvable, haystack: Resolvable) => Expr<boolean>);
    cos: ((input: NumberInput) => Expr<number>);
    cubicBezier: ((x1: number, y1: number, x2: number, y2: number) => InterpolationMethod);
    distance: ((geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<number>);
    distanceFromCenter: (() => Expr<number>);
    divide: ((a: NumberInput, b: NumberInput) => Expr<number>);
    downcase: ((input: StringInput) => Expr<string>);
    e: (() => Expr<number>);
    eq: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    exponential: ((base: number) => InterpolationMethod);
    featureState: ((property: string) => Expr<ExprValue>);
    floor: ((input: NumberInput) => Expr<number>);
    format: ((...segments: [StringInput, FormatSegmentOptions?][]) => Expr<ExprFormatted>);
    geometryType: (() => Expr<string>);
    get: ((property: string, object?: Expr<unknown>) => Expr<ExprValue>);
    gt: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    gte: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    has: ((property: string, object?: Expr<unknown>) => Expr<boolean>);
    heatmapDensity: (() => Expr<number>);
    hsl: ((hue: NumberInput, saturation: NumberInput, lightness: NumberInput) => Expr<ExprColor>);
    hsla: ((hue: NumberInput, saturation: NumberInput, lightness: NumberInput, alpha: NumberInput) => Expr<ExprColor>);
    id: (() => Expr<ExprValue>);
    image: ((name: StringInput) => Expr<ExprImage>);
    indexOf: ((needle: Resolvable, haystack: Resolvable, fromIndex?: NumberInput) => Expr<number>);
    interpolate: ((method: InterpolationMethod, input: Resolvable, ...stops: [number, Resolvable][]) => Expr<ExprValue>);
    interpolateHcl: ((method: InterpolationMethod, input: Resolvable, ...stops: [number, ColorInput][]) => Expr<ExprColor>);
    interpolateLab: ((method: InterpolationMethod, input: Resolvable, ...stops: [number, ColorInput][]) => Expr<ExprColor>);
    intersects: ((geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<boolean>);
    length: ((input: Resolvable) => Expr<number>);
    let: ((bindings: Record<string, Resolvable>, result: Resolvable) => Expr<ExprValue>);
    linear: (() => InterpolationMethod);
    lineProgress: (() => Expr<number>);
    literal: ((value: Record<string, unknown> | unknown[]) => Expr<ExprValue>);
    ln: ((input: NumberInput) => Expr<number>);
    ln2: (() => Expr<number>);
    log10: ((input: NumberInput) => Expr<number>);
    log2: ((input: NumberInput) => Expr<number>);
    lt: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    lte: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    match: ((input: Resolvable, ...casesAndFallback: (Resolvable | [(Resolvable | Resolvable[]), Resolvable])[]) => Expr<ExprValue>);
    max: ((...inputs: NumberInput[]) => Expr<number>);
    min: ((...inputs: NumberInput[]) => Expr<number>);
    mod: ((a: NumberInput, b: NumberInput) => Expr<number>);
    multiply: ((...inputs: NumberInput[]) => Expr<number>);
    neq: ((left: Resolvable, right: Resolvable) => Expr<boolean>);
    not: ((input: BooleanInput) => Expr<boolean>);
    numberFormat: ((input: NumberInput, options?: NumberFormatOptions) => Expr<string>);
    pi: (() => Expr<number>);
    pitch: (() => Expr<number>);
    pow: ((base: NumberInput, exponent: NumberInput) => Expr<number>);
    properties: (() => Expr<Record<string, unknown>>);
    resolvedLocale: ((input: Expr<ExprCollator>) => Expr<string>);
    rgb: ((red: NumberInput, green: NumberInput, blue: NumberInput) => Expr<ExprColor>);
    rgba: ((red: NumberInput, green: NumberInput, blue: NumberInput, alpha: NumberInput) => Expr<ExprColor>);
    round: ((input: NumberInput) => Expr<number>);
    sin: ((input: NumberInput) => Expr<number>);
    slice: ((input: Resolvable, start: NumberInput, end?: NumberInput) => Expr<ExprValue>);
    sqrt: ((input: NumberInput) => Expr<number>);
    step: ((input: Resolvable, defaultOutput: Resolvable, ...stops: [number, Resolvable][]) => Expr<ExprValue>);
    subtract: ((a: NumberInput, b?: NumberInput) => Expr<number>);
    tan: ((input: NumberInput) => Expr<number>);
    toBoolean: ((input: Resolvable) => Expr<boolean>);
    toColor: ((...inputs: Resolvable[]) => Expr<ExprColor>);
    toNumber: ((...inputs: Resolvable[]) => Expr<number>);
    toRgba: ((color: ColorInput) => Expr<number[]>);
    toString: ((input: Resolvable) => Expr<string>);
    typeOf: ((input: Resolvable) => Expr<string>);
    upcase: ((input: StringInput) => Expr<string>);
    var: ((name: string) => Expr<ExprValue>);
    within: ((geometry: Expr<ExprValue> | GeoJsonGeometry) => Expr<boolean>);
    zoom: (() => Expr<number>);
} = ...

Namespace object that groups all expression builder functions.

Type declaration

Example

import { expr } from "@honua/sdk";

const fillColor = expr.step(
  expr.get("assessed_value"),
  "#f7fbff",
  [100_000, "#6baed6"],
  [500_000, "#08306b"],
);

map.addLayer({
  id: "parcel-fill",
  source: "parcels",
  type: "fill",
  paint: { "fill-color": fillColor.toJSON() },
});

Settings

Member Visibility