@xweather/mapsgl 1.10.1 → 1.10.2-beta.1

package/dist/mapsgl.css

@@ -1,6 +1,6 @@
 /*!
  * 
- * 	@xweather/mapsgl - 1.10.1
+ * 	@xweather/mapsgl - 1.10.2-beta.1
  * 	(c) 2026 Vaisala Xweather
  * 	License: BSD
  * 	https://www.xweather.com

package/dist/mapsgl.d.ts

@@ -2047,6 +2047,9 @@ export declare type CoordinateBounds = {
     south: number;
     east: number;
 };
+
+/** Any supported regional-model coverage description. */
+export declare type CoverageSpec = EquirectCoverage | LccCoverage | StereoCoverage | RotatedLatLonCoverage | LaeaCoverage | MercatorCoverage;
 
 export declare type CrossTileID = string;
 
@@ -2248,6 +2251,41 @@ export declare const DataSourceType: {
 
 export declare type DataSourceType = ObjectValue<typeof DataSourceType>;
 
+/**
+ * Defines the base properties for a MapsGL server dataset.
+ */
+export declare type DataVariable = {
+    /**
+     * Measurement unit information of the data values.
+     */
+    measurement: {
+        type: Measurement;
+        units: string;
+    } | undefined;
+    /**
+     * Minimum and maximum values for the data.
+     */
+    dataRange: ValueRange;
+    /**
+     * Minimum and maximum values for the output range from 0...255. This controls how the data is spread across
+     * a single color band.
+     */
+    outputRange?: ValueRange;
+    /**
+     * Color-band byte used for no-data (typically `0`). When set, valid encodings start at `noData + 1`
+     * (`outputMin`).
+     *
+     * For multi-band packs of the same dataset code (e.g. precip split across RGB via `splitDataset`),
+     * `noData` applies only to the **first** band — later bands keep the full 0…255 range. Serialization
+     * and request builders strip `noData` from continuation bands; shaders/CPU decode offset only band 0.
+     */
+    noData?: number;
+    /**
+     * Time offset in seconds from the current time to use when requesting the data.
+     */
+    timeOffset?: number;
+};
+
 export declare interface DayNightOverlayOptions {
     /**
      * Overall opacity of the day/night overlay in the range `[0, 1]`.
@@ -2700,6 +2738,21 @@ protected onLoadProgress(e: any): void;
  */
 declare const equalUnits: (units1: MapUnits, units2: MapUnits) => boolean;
 
+/**
+ * Native-projection descriptions for regional model grids. These are pure data shapes shared with
+ * the runtime coverage-mask projections (`webgl-maps/src/utils/coverageProjection.ts`), whose CPU
+ * and GLSL implementations consume them.
+ */
+/** Equirectangular (plate carrée) coverage — grid is linearly spaced in lon/lat. */
+export declare interface EquirectCoverage {
+    type: 'equirectangular';
+    /** Geographic extent of the grid, in degrees. */
+    lonMin: number;
+    lonMax: number;
+    latMin: number;
+    latMax: number;
+}
+
 /**
  * Euler angles describe a rotational transformation by rotating an object on its various axes in
  * specified amounts per axis, and a specified axis order. Euler angles consist of three
@@ -2773,6 +2826,12 @@ export declare type EvaluatorContext = {
     paint?: PaintStyle;
 };
 
+/**
+ * Mapbox-style expression: operator name followed by arguments.
+ * Arguments may be literals or nested expressions (recursive).
+ */
+export declare type Expression = [ExpressionOperator, ...ExpressionValue[]];
+
 /**
  * Mapbox-style expression array, e.g. ['get', 'opacity'] or ['*', ['get', 'x'], 2].
  * Allowed in style config; converted to DataDrivenStyleValue in the PaintStyle constructor.
@@ -2820,6 +2879,102 @@ export declare interface ExpressionOperation {
      */
     chunk: string;
 }
+
+/** Supported expression operator names (first element of an expression array). */
+export declare const ExpressionOperator: {
+    readonly literal: "literal";
+    readonly get: "get";
+    readonly has: "has";
+    readonly var: "var";
+    readonly properties: "properties";
+    readonly zoom: "zoom";
+    readonly coalesce: "coalesce";
+    readonly eq: "==";
+    readonly neq: "!=";
+    readonly lt: "<";
+    readonly lte: "<=";
+    readonly gt: ">";
+    readonly gte: ">=";
+    readonly not: "!";
+    readonly all: "all";
+    readonly any: "any";
+    readonly toNumber: "to-number";
+    readonly toString: "to-string";
+    readonly toDate: "to-date";
+    readonly toLocaleString: "to-locale-string";
+    readonly toUnit: "to-unit";
+    readonly toBoolean: "to-boolean";
+    readonly typeOf: "typeof";
+    readonly number: "number";
+    readonly string: "string";
+    readonly boolean: "boolean";
+    readonly object: "object";
+    readonly add: "+";
+    readonly subtract: "-";
+    readonly mod: "%";
+    readonly pow: "^";
+    readonly multiply: "*";
+    readonly divide: "/";
+    readonly abs: "abs";
+    readonly ceil: "ceil";
+    readonly floor: "floor";
+    readonly round: "round";
+    readonly min: "min";
+    readonly max: "max";
+    readonly sqrt: "sqrt";
+    readonly ln: "ln";
+    readonly ln2: "ln2";
+    readonly log2: "log2";
+    readonly log10: "log10";
+    readonly sin: "sin";
+    readonly cos: "cos";
+    readonly tan: "tan";
+    readonly asin: "asin";
+    readonly acos: "acos";
+    readonly atan: "atan";
+    readonly e: "e";
+    readonly pi: "pi";
+    readonly at: "at";
+    readonly in: "in";
+    readonly regex: "regex";
+    readonly indexOf: "index-of";
+    readonly length: "length";
+    readonly slice: "slice";
+    readonly concat: "concat";
+    readonly downcase: "downcase";
+    readonly upcase: "upcase";
+    readonly step: "step";
+    readonly interpolate: "interpolate";
+    readonly case: "case";
+    readonly match: "match";
+    readonly let: "let";
+    /**
+     * Active map timeline position as **Unix seconds** (from the map controller), not wall clock —
+     * use `now` for that.
+     */
+    readonly mapTime: "map-time";
+    /**
+     * @deprecated Prefer `map-time` — same semantics.
+     */
+    readonly time: "time";
+    /**
+     * Wall-clock time as **Unix seconds** (`Date.now() / 1000` in JS). Distinct from `map-time`,
+     * which is the map timeline playhead.
+     */
+    readonly now: "now";
+    /**
+     * Converts a date or timestamp to Unix seconds so it can be compared with `now` / `map-time`.
+     * Accepts a `Date`, ISO string, millisecond timestamp, or a value already in seconds. Values
+     * already in seconds are left unchanged (not divided by 1000). Duration literals such as
+     * `86400` do not need `to-time`.
+     */
+    readonly toTime: "to-time";
+};
+
+export declare type ExpressionOperator = (typeof ExpressionOperator)[keyof typeof ExpressionOperator];
+
+/** Value that can appear as an expression or as an argument (literal or nested expression). */
+export declare type ExpressionValue = string | number | boolean | null | object | Expression;
 
 export declare type FeatureQueryResult = {
     value: number;
@@ -2874,6 +3029,13 @@ export declare interface FillStyleSpec {
     sort: string | SortProperty;
 }
 
+/**
+ * Mapbox-style filter expression array. Evaluates to boolean (feature included when truthy).
+ * Supports decision expressions (==, !=, <, <=, >, >=, all, any, !, in, regex, case, match, etc.)
+ * and property lookups (get, has).
+ */
+export declare type FilterExpression = ExpressionValue;
+
 /**
  * Bottom-most (lowest in the style stack) admin boundary layer id from a Mapbox/MapLibre
  * style `layers` array. Style order is bottom → top, so the first matching layer is returned.
@@ -3445,6 +3607,16 @@ export declare type InterpolationMode = ObjectValue<typeof InterpolationMode>;
 
 declare const inToM: (ins: number) => number;
 
+/**
+ * Converts inches to millimeters.
+ */
+declare const inToMM: (ins: number) => number;
+
+/**
+ * Converts an inches-based rate (in/hr) to a millimeters-based rate (mm/sec).
+ */
+declare const inToMMRate: (ins: number) => number;
+
 /**
  * Returns whether a style layer looks like an administrative boundary line.
  * Matches Mapbox Streets (`admin-*-boundary*`, `source-layer: admin`) and common
@@ -3479,6 +3651,21 @@ export declare type LabelItem = {
     span?: number;
 };
 
+/** Spherical Lambert Azimuthal Equal-Area coverage (OPERA-style). Offsets/spacing in km. */
+export declare interface LaeaCoverage {
+    type: 'laea';
+    nx: number;
+    ny: number;
+    /** Projection centre, in degrees. */
+    lon0: number;
+    lat0: number;
+    /** Projected position of grid cell (0,0): x of the upper-left column, y of the lower-left row, in km. */
+    xUlKm: number;
+    yLlKm: number;
+    dxKm: number;
+    dyKm: number;
+}
+
 /**
  * A `Layer` object used to configure a single Aeris Maps layer.
  */
@@ -3874,6 +4061,19 @@ export declare interface LayerSpecification {
     paint: Partial<PaintStyleSpec>;
 }
 
+/**
+ * Loading progress broken down by map layer identifier, keyed by the same id `getLayer()` takes.
+ *
+ * Derived from the sources each layer consumes, so it always agrees with the combined figure it
+ * accompanies. Two consequences worth knowing:
+ *
+ * - Layers that **share** a source each report that source's progress, so the per-layer totals sum
+ *   to more than the combined total. That is intended — each layer really is waiting on that data.
+ * - A composite weather layer contributes one entry per *store* layer it created
+ *   (`base.admin_2_boundaries.line`, …), not one for the weather layer code.
+ */
+export declare type LayersProgress = Record<string, SerializedProgress>;
+
 /**
  * Timing configuration options for a layer.
  */
@@ -3983,6 +4183,25 @@ export declare const LayerType: {
 
 export declare type LayerType = ObjectValue<typeof LayerType>;
 
+/** Lambert Conformal Conic coverage (HRRR, NAM, NBM, RTMA, …). Offsets/spacing in km. */
+export declare interface LccCoverage {
+    type: 'lcc';
+    /** Grid dimensions in cells. */
+    nx: number;
+    ny: number;
+    /** Central meridian and origin/standard parallels, in degrees. */
+    lon0: number;
+    lat0: number;
+    lat1: number;
+    lat2: number;
+    /** Projected position of grid cell (0,0), in km. */
+    x0Km: number;
+    y0Km: number;
+    /** Cell spacing in km. */
+    dxKm: number;
+    dyKm: number;
+}
+
 /**
  * The LeafletMapController is a MapController implementation for Leaflet maps.
  */
@@ -4322,6 +4541,7 @@ export declare type MapboxMap = mapboxgl.Map;
 export declare class MapboxMapController extends MapController<MapboxMap> implements MapProvider {
 
 get container(): HTMLElement;
+    
     get libraryInfo(): MapLibraryInfo;
     constructor(map: MapboxMap, opts: MapAdapterOptions);
     initialize(): Promise<void>;
@@ -4455,6 +4675,26 @@ get needsViewportUpdate(): boolean;
      * The frames per second (FPS) of the context.
      */
     get fps(): number;
+    /**
+     * Current data loading progress, in the same shape as the `load:progress` event payload.
+     *
+     * Use this to read loading state at an arbitrary moment — on mount, or when a component
+     * appears partway through a load — rather than waiting for the next `load:progress` tick.
+     * `progress` is every active layer combined; `layers` breaks the same figure down by layer id.
+     *
+     * Layers sharing a data source each report that source's progress, so the per-layer totals can
+     * sum to more than `progress.total`. See `LayersProgress`.
+     * @readonly
+     */
+    get loadingProgress(): {
+        progress: SerializedProgress;
+        layers: LayersProgress;
+    };
+    /**
+     * Whether any data source on the map is currently loading.
+     * @readonly
+     */
+    get isLoading(): boolean;
     /**
      * Returns an array of active data sources that have been added to the map.
      * @readonly
@@ -5218,6 +5458,54 @@ export declare class MapResult {
     headers(): Headers;
 }
 
+/**
+ * Defines the set of properties used by a dataset when requesting data from the MapsGL API tile server.
+ * Lives in the spec package deliberately: nothing here consumes it, but it is the cross-platform
+ * wire shape every SDK's tile requests must produce from {@link WeatherVariable} data.
+ */
+export declare type MapsGLDataDescriptor = {
+    /**
+     * The dataset code used by the MapsGL server.
+     */
+    id: string;
+    /**
+     * Measurement unit information of the data values.
+     */
+    measurement?: {
+        type: Measurement;
+        units: string;
+    } | null;
+    /**
+     * Minimum value to return for the data in the data's native units.
+     */
+    dataMin: number;
+    /**
+     * Maximum value to return for the data in the data's native units.
+     */
+    dataMax: number;
+    /**
+     * Value from 0...255 to use for encoding no-data values. Typically this is `0`.
+     *
+     * On multi-band packs of the same `id` (e.g. precip RGB), only the first descriptor should set
+     * `noData`; continuation bands omit it so they encode across the full 0…255 range. Shader skip
+     * and decode check/offset that primary band only.
+     */
+    noData?: number;
+    /**
+     * Value from 0...255 to use for encoding the minimum value in the output range. Typically this is `0` unless a
+     * value is provided for `noData`, in which case it is `1` (on the primary band of a multi-band pack only).
+     */
+    outputMin?: number;
+    /**
+     * Value from 0...255 to use for encoding the maximum value in the output range. Typically this is `255`.
+     */
+    outputMax?: number;
+    /**
+     * Time offset in seconds from the current time to use when requesting the data.
+     */
+    timeOffset?: number;
+};
+
 /**
  * The units of measurement for the map.
  */
@@ -5429,9 +5717,42 @@ export declare class Matrix4 extends Matrix<mat4> {
 declare const mbToHg: (mb: number) => number;
 
 declare const mbToPa: (mb: number) => number;
+
+/**
+ * `'temperature-delta'` is a distinct measurement from `'temperature'`: converting a *change* in
+ * temperature (e.g. a 24-hour delta) needs scale-only conversion (`FtoCUnit`-style), not the
+ * offset conversion an absolute temperature needs (`FtoC`-style) — a real, portable distinction
+ * every platform's unit-conversion logic needs to know, not just a webgl-maps implementation
+ * detail. Named to match the native Swift (`UnitTemperatureDelta`) and Kotlin
+ * (`MeasurementType.TEMPERATURE_DELTA`) types already generated for it.
+ */
+export declare type Measurement = keyof typeof Units | 'height' | 'snowfall' | 'intensity' | 'temperature-delta';
+
+/**
+ * Spherical Mercator coverage (NBM Hawaii / Puerto Rico / Guam). Standard web-Mercator-style
+ * projection with true scale at the equator: `x = R·(lon−lon0)`, `y = R·ln(tan(π/4 + lat/2))`.
+ * Offsets/spacing in km.
+ */
+export declare interface MercatorCoverage {
+    type: 'mercator';
+    nx: number;
+    ny: number;
+    /** Reference longitude (degrees) — grid cell (0,0) sits at `lon0` when `x0Km` is 0. */
+    lon0: number;
+    /** Projected position of grid cell (0,0), in km. */
+    x0Km: number;
+    y0Km: number;
+    dxKm: number;
+    dyKm: number;
+}
 
 export declare type MessageHandler = (result: any) => any;
 
+/**
+ * Converts miles to meters.
+ */
+declare const miToM: (mi: number) => number;
+
 /**
  * Converts precipitation rate in mm/hr (or mm/s if perSecond=true) to dBZ.
  * This is the inverse of the dbzToMMRate formula:
@@ -5539,7 +5860,7 @@ export declare class PaintStyle {
     fillSort(data?: StylableData): SortProperty;
     strokeColor(data?: StylableData): Color;
     strokeOpacity(data?: StylableData): number;
-    strokeThickness(data?: StylableData): number;
+    strokeThickness(data?: StylableData, fallback?: number): number;
     strokeLineJoin(data?: StylableData): LineJoin;
     strokeLineCap(data?: StylableData): LineCap;
     radius(data?: StylableData): number;
@@ -6200,6 +6521,22 @@ constructor(data: Uint8Array, dimension: number, pad?: number);
     private _idx;
 }
 
+/** Rotated latitude/longitude coverage (HRDPS). Pole/spacing in degrees. */
+export declare interface RotatedLatLonCoverage {
+    type: 'rotlat';
+    nx: number;
+    ny: number;
+    /** South-pole location (eccodes convention), in degrees. */
+    poleLon: number;
+    poleLat: number;
+    /** First grid point in rotated coordinates, in degrees. */
+    lon1: number;
+    lat1: number;
+    /** Angular cell spacing in rotated degrees. */
+    dlon: number;
+    dlat: number;
+}
+
 export declare type SampleChannel = typeof SupportedSampleChannels[number];
 
 /**
@@ -6309,6 +6646,22 @@ export declare interface SampleStyleSpec {
     drawRange: Partial<ValueRange>;
 }
 
+/**
+ * A serialized representation of the progress of a task.
+ *
+ * Public: this is the shape of `progress` on the `load:progress` event, of every value in
+ * `LayersProgress`, and of `MapController#loadingProgress`. Do not mark it `@internal` —
+ * api-extractor would trim it from the published declarations while the getter still referenced
+ * it, leaving it undeclared for consumers (see XMAPSGLSDK-335).
+ */
+export declare type SerializedProgress = {
+    total: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    progress: number;
+};
+
 /**
  * The type of shader.
  */
@@ -6644,6 +6997,25 @@ export declare class State<T> extends EventDispatcher {
  */
 export declare type StaticOrFunctionStyleValue<T> = T | ((data: StylableData) => T);
 
+/**
+ * Spherical polar stereographic coverage (NBM Alaska). Uses `ρ = R·tan(π/4 − sign·lat/2)` with true
+ * scale on the equatorial plane (validated against the model's grid bounds). Offsets/spacing in km.
+ */
+export declare interface StereoCoverage {
+    type: 'stereo';
+    nx: number;
+    ny: number;
+    /** Central meridian (degrees) — the meridian aligned with the −y axis. */
+    lon0: number;
+    /** Hemisphere: `+1` for the north pole, `-1` for the south pole. */
+    sign: number;
+    /** Projected position of grid cell (0,0), in km. */
+    x0Km: number;
+    y0Km: number;
+    dxKm: number;
+    dyKm: number;
+}
+
 /**
  * Stroke style properties control how one or more polylines get rendered on a map. These properties also control
  * strokes around circles and other vector shapes.
@@ -8268,6 +8640,68 @@ export declare type TypedArray = Float64Array | Float32Array | Uint16Array | Int
  */
 export declare type UnitConverter = (value: number, from: string, to: string) => number;
 
+/**
+ * The supported units of measurement.
+ */
+declare const Units: {
+    readonly temperature: {
+        readonly C: "C";
+        readonly F: "F";
+    };
+    readonly speed: {
+        readonly kmh: "km/h";
+        readonly mph: "mph";
+        readonly ms: "m/s";
+        readonly kts: "kts";
+    };
+    readonly pressure: {
+        readonly mb: "mb";
+        readonly pa: "Pa";
+        readonly hPa: "hPa";
+        readonly hg: "inHg";
+    };
+    readonly distance: {
+        readonly m: "m";
+        readonly km: "km";
+        readonly ft: "ft";
+        readonly mi: "mi";
+    };
+    readonly precipitation: {
+        readonly mm: "mm";
+        readonly cm: "cm";
+        readonly in: "in";
+        readonly m: "m";
+        readonly ft: "ft";
+    };
+    readonly direction: {
+        readonly deg: "°";
+    };
+    readonly time: {
+        readonly hr: "hr";
+        readonly min: "min";
+        readonly sec: "sec";
+        readonly ms: "ms";
+    };
+    readonly rate: {
+        readonly mmhr: "mm/hr";
+        readonly inhr: "in/hr";
+        readonly mms: "mm/sec";
+        readonly dbz: "dBZ";
+    };
+    readonly concentration: {
+        readonly ppm: "ppm";
+        readonly ugm3: "ug/m^3";
+    };
+    readonly ratio: {
+        readonly percent: "%";
+    };
+    readonly index: {
+        readonly uvi: "uvi";
+        readonly aqi: "aqi";
+        readonly aqhi: "aqhi";
+    };
+};
+
 export declare const units: {
     Units: {
         readonly temperature: {
@@ -8463,6 +8897,11 @@ export declare const utils: {
  */
 export declare type UVOffset = [number, number, number, number];
 
+export declare type ValueRange = {
+    min: number;
+    max: number;
+};
+
 /**
  * Base class for all vectors.
  */
@@ -8697,6 +9136,19 @@ export declare class VectorTileSource extends TileSource<VectorTileData, VectorS
     
 }
 
+/**
+ * Defines the properties for a vector weather variable.
+ */
+export declare type VectorWeatherVariable = DataVariable & {
+    /**
+     * The dataset codes used by the MapsGL server for the U and V vector components.
+     */
+    code: {
+        u: string;
+        v: string;
+    };
+};
+
 export declare const version: string;
 
 export declare interface ViewBounds {
@@ -8973,6 +9425,16 @@ export declare type WeatherLayerStyle = `${WeatherLayerType}` | 'composite';
 
 export declare type WeatherLayerType = Exclude<LayerType, 'particles' | 'query' | 'voronoi' | 'data' | 'debug'>;
 
+/**
+ * Defines the properties for a weather variable.
+ */
+export declare type WeatherVariable = DataVariable & {
+    /**
+     * The dataset code used by the MapsGL server.
+     */
+    code: string;
+};
+
 export declare type WebGLContext = WebGLRenderingContext | WebGL2RenderingContext;
 
 /**