maplibre-gl 2.2.1 → 2.3.1-pre.2

package/src/source/tile_id.ts

@@ -2,8 +2,6 @@ import {getTileBBox} from '@mapbox/whoots-js';
 import EXTENT from '../data/extent';
 import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../geo/mercator_coordinate';
-
-import assert from 'assert';
 import {register} from '../util/web_worker_transfer';
 import {mat4} from 'gl-matrix';
 
@@ -14,9 +12,11 @@ export class CanonicalTileID {
     key: string;
 
     constructor(z: number, x: number, y: number) {
-        assert(z >= 0 && z <= 25);
-        assert(x >= 0 && x < Math.pow(2, z));
-        assert(y >= 0 && y < Math.pow(2, z));
+
+        if (z < 0 || z > 25 || y < 0 || y >= Math.pow(2, z) || x < 0 || x >= Math.pow(2, z)) {
+            throw new Error(`x=${x}, y=${y}, z=${z} outside of bounds. 0<=x<${Math.pow(2, z)}, 0<=y<${Math.pow(2, z)} 0<=z<=25 `);
+        }
+
         this.z = z;
         this.x = x;
         this.y = y;
@@ -79,7 +79,7 @@ export class OverscaledTileID {
     posMatrix: mat4;
 
     constructor(overscaledZ: number, wrap: number, z: number, x: number, y: number) {
-        assert(overscaledZ >= z);
+        if (overscaledZ < z) throw new Error(`overscaledZ should be >= z; overscaledZ = ${overscaledZ}; z = ${z}`);
         this.overscaledZ = overscaledZ;
         this.wrap = wrap;
         this.canonical = new CanonicalTileID(z, +x, +y);
@@ -95,7 +95,7 @@ export class OverscaledTileID {
     }
 
     scaledTo(targetZ: number) {
-        assert(targetZ <= this.overscaledZ);
+        if (targetZ > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${targetZ}; overscaledZ = ${this.overscaledZ}`);
         const zDifference = this.canonical.z - targetZ;
         if (targetZ > this.canonical.z) {
             return new OverscaledTileID(targetZ, this.wrap, this.canonical.z, this.canonical.x, this.canonical.y);
@@ -110,7 +110,7 @@ export class OverscaledTileID {
      * when withWrap == false, implements the same as this.scaledTo(z).wrapped().key.
      */
     calculateScaledKey(targetZ: number, withWrap: boolean): string {
-        assert(targetZ <= this.overscaledZ);
+        if (targetZ > this.overscaledZ) throw new Error(`targetZ > this.overscaledZ; targetZ = ${targetZ}; overscaledZ = ${this.overscaledZ}`);
         const zDifference = this.canonical.z - targetZ;
         if (targetZ > this.canonical.z) {
             return calculateKey(this.wrap * +withWrap, targetZ, this.canonical.z, this.canonical.x, this.canonical.y);

package/src/source/worker.ts

@@ -4,7 +4,6 @@ import StyleLayerIndex from '../style/style_layer_index';
 import VectorTileWorkerSource from './vector_tile_worker_source';
 import RasterDEMTileWorkerSource from './raster_dem_tile_worker_source';
 import GeoJSONWorkerSource from './geojson_worker_source';
-import assert from 'assert';
 import {plugin as globalRTLTextPlugin} from './rtl_text_plugin';
 import {enforceCacheSizeLimit} from '../util/tile_request_cache';
 import {isWorker} from '../util/util';
@@ -121,7 +120,6 @@ export default class Worker {
     loadTile(mapId: string, params: WorkerTileParameters & {
         type: string;
     }, callback: WorkerTileCallback) {
-        assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
     }
 
@@ -132,21 +130,18 @@ export default class Worker {
     reloadTile(mapId: string, params: WorkerTileParameters & {
         type: string;
     }, callback: WorkerTileCallback) {
-        assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
     }
 
     abortTile(mapId: string, params: TileParameters & {
         type: string;
     }, callback: WorkerTileCallback) {
-        assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
     }
 
     removeTile(mapId: string, params: TileParameters & {
         type: string;
     }, callback: WorkerTileCallback) {
-        assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
     }
 
@@ -159,8 +154,6 @@ export default class Worker {
     } & {
         type: string;
     }, callback: WorkerTileCallback) {
-        assert(params.type);
-        assert(params.source);
 
         if (!this.workerSources[mapId] ||
             !this.workerSources[mapId][params.type] ||

package/src/source/worker_tile.ts

@@ -8,7 +8,6 @@ import LineBucket from '../data/bucket/line_bucket';
 import FillBucket from '../data/bucket/fill_bucket';
 import FillExtrusionBucket from '../data/bucket/fill_extrusion_bucket';
 import {warnOnce, mapObject} from '../util/util';
-import assert from 'assert';
 import ImageAtlas from '../render/image_atlas';
 import GlyphAtlas from '../render/glyph_atlas';
 import EvaluationParameters from '../style/evaluation_parameters';
@@ -105,7 +104,9 @@ class WorkerTile {
             for (const family of layerFamilies[sourceLayerId]) {
                 const layer = family[0];
 
-                assert(layer.source === this.source);
+                if (layer.source !== this.source) {
+                    warnOnce(`layer.source = ${layer.source} does not equal this.source = ${this.source}`);
+                }
                 if (layer.minzoom && this.zoom < Math.floor(layer.minzoom)) continue;
                 if (layer.maxzoom && this.zoom >= layer.maxzoom) continue;
                 if (layer.visibility === 'none') continue;
@@ -189,7 +190,15 @@ class WorkerTile {
                     const bucket = buckets[key];
                     if (bucket instanceof SymbolBucket) {
                         recalculateLayers(bucket.layers, this.zoom, availableImages);
-                        performSymbolLayout(bucket, glyphMap, glyphAtlas.positions, iconMap, imageAtlas.iconPositions, this.showCollisionBoxes, this.tileID.canonical);
+                        performSymbolLayout({
+                            bucket,
+                            glyphMap,
+                            glyphPositions: glyphAtlas.positions,
+                            imageMap: iconMap,
+                            imagePositions: imageAtlas.iconPositions,
+                            showCollisionBoxes: this.showCollisionBoxes,
+                            canonical: this.tileID.canonical
+                        });
                     } else if (bucket.hasPattern &&
                         (bucket instanceof LineBucket ||
                          bucket instanceof FillBucket ||

package/src/style/format_section_override.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import type {Expression} from '../style-spec/expression/expression';
 import type EvaluationContext from '../style-spec/expression/evaluation_context';
 import type {Type} from '../style-spec/expression/types';
@@ -14,7 +13,7 @@ export default class FormatSectionOverride<T> implements Expression {
     defaultValue: PossiblyEvaluatedPropertyValue<T>;
 
     constructor(defaultValue: PossiblyEvaluatedPropertyValue<T>) {
-        assert(defaultValue.property.overrides !== undefined);
+        if (defaultValue.property.overrides === undefined) throw new Error('overrides must be provided to instantiate FormatSectionOverride class');
         this.type = defaultValue.property.overrides ? defaultValue.property.overrides.runtimeType : NullType;
         this.defaultValue = defaultValue;
     }

package/src/style/properties.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import {clone, extend, easeCubicInOut} from '../util/util';
 import * as interpolate from '../style-spec/util/interpolate';
 import Color from '../style-spec/util/color';
@@ -488,7 +487,7 @@ export class DataConstantProperty<T> implements Property<T, T> {
     }
 
     possiblyEvaluate(value: PropertyValue<T, T>, parameters: EvaluationParameters): T {
-        assert(!value.isDataDriven());
+        if (value.isDataDriven()) throw new Error('Value should not be data driven');
         return value.expression.evaluate(parameters);
     }
 
@@ -668,7 +667,6 @@ export class CrossFadedProperty<T> implements Property<T, CrossFaded<T>> {
             const constant = value.expression.evaluate(parameters, null, {}, canonical, availableImages);
             return this._calculate(constant, constant, constant, parameters);
         } else {
-            assert(!value.isDataDriven());
             return this._calculate(
                 value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom - 1.0), parameters)),
                 value.expression.evaluate(new EvaluationParameters(Math.floor(parameters.zoom), parameters)),

package/src/style/style.ts

@@ -1,5 +1,3 @@
-import assert from 'assert';
-
 import {Event, ErrorEvent, Evented} from '../util/evented';
 import StyleLayer from './style_layer';
 import createStyleLayer from './create_style_layer';
@@ -402,11 +400,13 @@ class Style extends Evented {
             }
             for (const id in this._updatedSources) {
                 const action = this._updatedSources[id];
-                assert(action === 'reload' || action === 'clear');
+
                 if (action === 'reload') {
                     this._reloadSource(id);
                 } else if (action === 'clear') {
                     this._clearSource(id);
+                } else {
+                    throw new Error(`Invalid action ${action}`);
                 }
             }
 
@@ -677,9 +677,9 @@ class Style extends Evented {
     setGeoJSONSourceData(id: string, data: GeoJSON.GeoJSON | string) {
         this._checkLoaded();
 
-        assert(this.sourceCaches[id] !== undefined, 'There is no source with this ID');
+        if (this.sourceCaches[id] === undefined) throw new Error(`There is no source with this ID=${id}`);
         const geojsonSource: GeoJSONSource = (this.sourceCaches[id].getSource() as any);
-        assert(geojsonSource.type === 'geojson');
+        if (geojsonSource.type !== 'geojson') throw new Error(`geojsonSource.type is ${geojsonSource.type}, which is !== 'geojson`);
 
         geojsonSource.setData(data);
         this._changed = true;

package/src/style/style_layer/custom_style_layer.ts

@@ -1,6 +1,5 @@
 import StyleLayer from '../style_layer';
 import type Map from '../../ui/map';
-import assert from 'assert';
 import {mat4} from 'gl-matrix';
 import {LayerSpecification} from '../../style-spec/types.g';
 
@@ -206,7 +205,7 @@ class CustomStyleLayer extends StyleLayer {
     hasTransition() { return false; }
 
     serialize(): LayerSpecification {
-        assert(false, 'Custom layers cannot be serialized');
+        throw new Error('Custom layers cannot be serialized');
     }
 
     onAdd = (map: Map) => {

package/src/style/style_layer/symbol_style_layer.ts

@@ -1,6 +1,5 @@
 import StyleLayer from '../style_layer';
 
-import assert from 'assert';
 import SymbolBucket, {SymbolFeature} from '../../data/bucket/symbol_bucket';
 import resolveTokens from '../../util/resolve_tokens';
 import properties, {SymbolLayoutPropsPossiblyEvaluated, SymbolPaintPropsPossiblyEvaluated} from './symbol_style_layer_properties.g';
@@ -110,8 +109,7 @@ class SymbolStyleLayer extends StyleLayer {
     }
 
     queryIntersectsFeature(): boolean {
-        assert(false); // Should take a different path in FeatureIndex
-        return false;
+        throw new Error('Should take a different path in FeatureIndex');
     }
 
     _setPaintOverrides() {

package/src/style-spec/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 17.0.1
+
+* Generated typings file as not created in the build process and was added in this version [#1470](https://github.com/maplibre/maplibre-gl-js/pull/1470)
+
+## 17.0.0
+
+### Breaking changes
+
+* Renamed `ParsingError` to `ExpressionParsingError` as there were two with the same name and added typescript typings [1468](https://github.com/maplibre/maplibre-gl-js/pull/1468)
+
 ## 16.1.0
 
 ### ✨ Features and improvements

package/src/style-spec/composite.test.ts

@@ -1,11 +1,10 @@
-// @ts-nocheck
-
 import composite from './composite';
+import {LineLayerSpecification} from './types.g';
 
 describe('composite', () => {
     test('composites Mapbox vector sources', () => {
         const result = composite({
-            'version': 7,
+            'version': 7 as any,
             'sources': {
                 'mapbox-a': {
                     'type': 'vector',
@@ -34,13 +33,13 @@ describe('composite', () => {
             }
         });
 
-        expect(result.layers[0].source).toBe('a,b');
-        expect(result.layers[1].source).toBe('a,b');
+        expect((result.layers[0] as LineLayerSpecification).source).toBe('a,b');
+        expect((result.layers[1] as LineLayerSpecification).source).toBe('a,b');
     });
 
     test('does not composite vector + raster', () => {
         const result = composite({
-            'version': 7,
+            'version': 7 as any,
             'sources': {
                 'a': {
                     'type': 'vector',
@@ -59,7 +58,7 @@ describe('composite', () => {
 
     test('incorrect url match', () => {
         const result = composite({
-            'version': 7,
+            'version': 7 as any,
             'sources': {
                 'a': {
                     'type': 'vector',
@@ -79,7 +78,7 @@ describe('composite', () => {
     test('composites Mapbox vector sources with conflicting source layer names', () => {
         expect(() => {
             composite({
-                'version': 7,
+                'version': 7 as any,
                 'sources': {
                     'mapbox-a': {
                         'type': 'vector',

package/src/style-spec/expression/compound_expression.ts

@@ -2,7 +2,6 @@ import {toString} from './types';
 
 import ParsingContext from './parsing_context';
 import EvaluationContext from './evaluation_context';
-import assert from 'assert';
 
 import type {Expression, ExpressionRegistry} from './expression';
 import type {Type} from './types';
@@ -114,8 +113,6 @@ class CompoundExpression implements Expression {
             }
         }
 
-        assert(!signatureContext || signatureContext.errors.length > 0);
-
         if (overloads.length === 1) {
             context.errors.push(...signatureContext.errors);
         } else {
@@ -142,7 +139,6 @@ class CompoundExpression implements Expression {
         registry: ExpressionRegistry,
         definitions: {[_: string]: Definition}
     ) {
-        assert(!CompoundExpression.definitions);
         CompoundExpression.definitions = definitions;
         for (const name in definitions) {
             registry[name] = CompoundExpression;

package/src/style-spec/expression/definitions/assertion.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 
 import {
     ObjectType,
@@ -69,7 +68,7 @@ class Assertion implements Expression {
 
             type = array(itemType, N);
         } else {
-            assert(types[name], name);
+            if (!types[name]) throw new Error(`Types doesn't contain name = ${name}`);
             type = types[name];
         }
 
@@ -94,8 +93,7 @@ class Assertion implements Expression {
             }
         }
 
-        assert(false);
-        return null;
+        throw new Error();
     }
 
     eachChild(fn: (_: Expression) => void) {

package/src/style-spec/expression/definitions/case.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 
 import {BooleanType} from '../types';
 
@@ -48,7 +47,7 @@ class Case implements Expression {
         const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
         if (!otherwise) return null;
 
-        assert(outputType);
+        if (!outputType) throw new Error('Can\'t infer output type');
         return new Case((outputType as any), branches, otherwise);
     }
 

package/src/style-spec/expression/definitions/coalesce.ts

@@ -1,5 +1,3 @@
-import assert from 'assert';
-
 import {checkSubtype, ValueType} from '../types';
 import ResolvedImage from '../types/resolved_image';
 
@@ -34,7 +32,7 @@ class Coalesce implements Expression {
             outputType = outputType || parsed.type;
             parsedArgs.push(parsed);
         }
-        assert(outputType);
+        if (!outputType) throw new Error('No output type');
 
         // Above, we parse arguments without inferred type annotation so that
         // they don't produce a runtime error for `null` input, which would

package/src/style-spec/expression/definitions/coercion.ts

@@ -1,5 +1,3 @@
-import assert from 'assert';
-
 import {BooleanType, ColorType, NumberType, StringType, ValueType} from '../types';
 import {Color, Padding, toString as valueToString, validateRGBA} from '../values';
 import RuntimeError from '../runtime_error';
@@ -32,6 +30,7 @@ class Coercion implements Expression {
     constructor(type: Type, args: Array<Expression>) {
         this.type = type;
         this.args = args;
+
     }
 
     static parse(args: ReadonlyArray<unknown>, context: ParsingContext): Expression {
@@ -39,8 +38,7 @@ class Coercion implements Expression {
             return context.error('Expected at least one argument.') as null;
 
         const name: string = (args[0] as any);
-        assert(types[name], name);
-
+        if (!types[name]) throw new Error(`Can't parse ${name} as it is not part of the known types`);
         if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
             return context.error('Expected one argument.') as null;
 

package/src/style-spec/expression/definitions/match.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 
 import {typeOf} from '../values';
 import {ValueType} from '../types';
@@ -92,8 +91,6 @@ class Match implements Expression {
         const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
         if (!otherwise) return null;
 
-        assert(inputType && outputType);
-
         if (input.type.kind !== 'value' && context.concat(1).checkSubtype(((inputType as any)), input.type)) {
             return null;
         }

package/src/style-spec/expression/index.ts

@@ -1,7 +1,6 @@
-import assert from 'assert';
 
 import extend from '../util/extend';
-import ParsingError from './parsing_error';
+import ExpressionParsingError from './parsing_error';
 import ParsingContext from './parsing_context';
 import EvaluationContext from './evaluation_context';
 import CompoundExpression from './compound_expression';
@@ -135,7 +134,7 @@ export function isExpression(expression: unknown) {
  *
  * @private
  */
-export function createExpression(expression: unknown, propertySpec?: StylePropertySpecification | null): Result<StyleExpression, Array<ParsingError>> {
+export function createExpression(expression: unknown, propertySpec?: StylePropertySpecification | null): Result<StyleExpression, Array<ExpressionParsingError>> {
     const parser = new ParsingContext(definitions, [], propertySpec ? getExpectedType(propertySpec) : undefined);
 
     // For string-valued properties, coerce to string at the top level rather than asserting.
@@ -143,7 +142,6 @@ export function createExpression(expression: unknown, propertySpec?: StyleProper
         propertySpec && propertySpec.type === 'string' ? {typeAnnotation: 'coerce'} : undefined);
 
     if (!parsed) {
-        assert(parser.errors.length > 0);
         return error(parser.errors);
     }
 
@@ -287,7 +285,7 @@ export type CompositeExpression = {
 
 export type StylePropertyExpression = ConstantExpression | SourceExpression | CameraExpression | CompositeExpression;
 
-export function createPropertyExpression(expressionInput: unknown, propertySpec: StylePropertySpecification): Result<StylePropertyExpression, Array<ParsingError>> {
+export function createPropertyExpression(expressionInput: unknown, propertySpec: StylePropertySpecification): Result<StylePropertyExpression, Array<ExpressionParsingError>> {
     const expression = createExpression(expressionInput, propertySpec);
     if (expression.result === 'error') {
         return expression;
@@ -297,21 +295,21 @@ export function createPropertyExpression(expressionInput: unknown, propertySpec:
 
     const isFeatureConstant = isConstant.isFeatureConstant(parsed);
     if (!isFeatureConstant && !supportsPropertyExpression(propertySpec)) {
-        return error([new ParsingError('', 'data expressions not supported')]);
+        return error([new ExpressionParsingError('', 'data expressions not supported')]);
     }
 
     const isZoomConstant = isConstant.isGlobalPropertyConstant(parsed, ['zoom']);
     if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
-        return error([new ParsingError('', 'zoom expressions not supported')]);
+        return error([new ExpressionParsingError('', 'zoom expressions not supported')]);
     }
 
     const zoomCurve = findZoomCurve(parsed);
     if (!zoomCurve && !isZoomConstant) {
-        return error([new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
-    } else if (zoomCurve instanceof ParsingError) {
+        return error([new ExpressionParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.')]);
+    } else if (zoomCurve instanceof ExpressionParsingError) {
         return error([zoomCurve]);
     } else if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
-        return error([new ParsingError('', '"interpolate" expressions cannot be used with this property')]);
+        return error([new ExpressionParsingError('', '"interpolate" expressions cannot be used with this property')]);
     }
 
     if (!zoomCurve) {
@@ -394,7 +392,7 @@ export function normalizePropertyExpression<T>(
 // Zoom-dependent expressions may only use ["zoom"] as the input to a top-level "step" or "interpolate"
 // expression (collectively referred to as a "curve"). The curve may be wrapped in one or more "let" or
 // "coalesce" expressions.
-function findZoomCurve(expression: Expression): Step | Interpolate | ParsingError | null {
+function findZoomCurve(expression: Expression): Step | Interpolate | ExpressionParsingError | null {
     let result = null;
     if (expression instanceof Let) {
         result = findZoomCurve(expression.result);
@@ -414,18 +412,18 @@ function findZoomCurve(expression: Expression): Step | Interpolate | ParsingErro
         result = expression;
     }
 
-    if (result instanceof ParsingError) {
+    if (result instanceof ExpressionParsingError) {
         return result;
     }
 
     expression.eachChild((child) => {
         const childResult = findZoomCurve(child);
-        if (childResult instanceof ParsingError) {
+        if (childResult instanceof ExpressionParsingError) {
             result = childResult;
         } else if (!result && childResult) {
-            result = new ParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
+            result = new ExpressionParsingError('', '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.');
         } else if (result && childResult && result !== childResult) {
-            result = new ParsingError('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
+            result = new ExpressionParsingError('', 'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.');
         }
     });
 

package/src/style-spec/expression/parsing_context.ts

@@ -1,6 +1,6 @@
 import Scope from './scope';
 import {checkSubtype} from './types';
-import ParsingError from './parsing_error';
+import ExpressionParsingError from './parsing_error';
 import Literal from './definitions/literal';
 import Assertion from './definitions/assertion';
 import Coercion from './definitions/coercion';
@@ -23,7 +23,7 @@ class ParsingContext {
     path: Array<number>;
     key: string;
     scope: Scope;
-    errors: Array<ParsingError>;
+    errors: Array<ExpressionParsingError>;
 
     // The expected type of this expression. Provided only to allow Expression
     // implementations to infer argument types: Expression#parse() need not
@@ -36,7 +36,7 @@ class ParsingContext {
         path: Array<number> = [],
         expectedType?: Type | null,
         scope: Scope = new Scope(),
-        errors: Array<ParsingError> = []
+        errors: Array<ExpressionParsingError> = []
     ) {
         this.registry = registry;
         this.path = path;
@@ -183,7 +183,7 @@ class ParsingContext {
      */
     error(error: string, ...keys: Array<number>) {
         const key = `${this.key}${keys.map(k => `[${k}]`).join('')}`;
-        this.errors.push(new ParsingError(key, error));
+        this.errors.push(new ExpressionParsingError(key, error));
     }
 
     /**

package/src/style-spec/expression/parsing_error.ts

@@ -1,4 +1,4 @@
-class ParsingError extends Error {
+class ExpressionParsingError extends Error {
     key: string;
     message: string;
     constructor(key: string, message: string) {
@@ -8,4 +8,4 @@ class ParsingError extends Error {
     }
 }
 
-export default ParsingError;
+export default ExpressionParsingError;

package/src/style-spec/expression/values.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 
 import Color from '../util/color';
 import Collator from './types/collator';
@@ -107,7 +106,6 @@ export function typeOf(value: Value): Type {
 
         return array(itemType || ValueType, length);
     } else {
-        assert(typeof value === 'object');
         return ObjectType;
     }
 }

package/src/style-spec/feature_filter/feature_filter.test.ts

@@ -5,11 +5,11 @@ import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../../geo/mercator_coordinate';
 import EXTENT from '../../data/extent';
 import {CanonicalTileID} from '../../source/tile_id';
-import {ExpressionFilterSpecification, FilterSpecification} from '../types.g';
+import {ExpressionFilterSpecification, ExpressionInputType, ExpressionSpecification, FilterSpecification} from '../types.g';
 import {Feature} from '../expression';
 
 describe('filter', () => {
-    test('exprssions transpilation test', () => {
+    test('expressions transpilation test', () => {
         function compileTimeCheck(_: ExpressionFilterSpecification) {
             expect(true).toBeTruthy();
         }
@@ -36,6 +36,43 @@ describe('filter', () => {
         compileTimeCheck(['match', ['get', 'TYPE'], ['TARGETPOINT:HOSPITAL'], true, false]);
         compileTimeCheck(['match', ['get', 'TYPE'], ['ADIZ', 'AMA', 'AWY', 'CLASS', 'NO-FIR', 'OCA', 'OTA', 'P', 'RAS', 'RCA', 'UTA', 'UTA-P'], true, false]);
         compileTimeCheck(['==', ['get', 'MILITARYAIRPORT'], 1]);
+        compileTimeCheck(['interpolate', ['linear'], ['line-progress'], 0, 10, 0.5, 100, 1, 1000]); // number output
+        compileTimeCheck(['interpolate', ['linear'], ['line-progress'], 0, 'red', 0.5, 'green', 1, 'blue']); // color output
+        compileTimeCheck(['interpolate', ['linear'], ['line-progress'], 0, [10, 20, 30], 0.5, [20, 30, 40], 1, [30, 40, 80]]); // number array output!
+        compileTimeCheck(['interpolate-hcl', ['linear'], ['line-progress'], 0, 'red', 0.5, 'green', 1, 'blue']);
+        compileTimeCheck(['interpolate-lab', ['linear'], ['line-progress'], 0, 'red', 0.5, 'green', 1, 'blue']);
+        compileTimeCheck(['step', ['get', 'point_count'], '#df2d43', 50, '#df2d43', 200, '#df2d43']);
+        compileTimeCheck(['step', ['get', 'point_count'], 20, 50, 30, 200, 40]);
+        compileTimeCheck(['step', ['get', 'point_count'], 0.6, 50, 0.7, 200, 0.8]);
+
+        // checks, where parts of the expression are injected from constants
+        // as in most cases the styling is read from JSON, these are rather optional tests.
+        // due to typescript inferring rather broad types, this is only possible in few places without specifying a type for the constant.
+        const colorStops = [0, 'red', 0.5, 'green', 1, 'blue'];
+        compileTimeCheck([
+            'interpolate',
+            ['linear'],
+            ['line-progress'],
+            ...colorStops
+        ]);
+        compileTimeCheck([
+            'interpolate-hcl',
+            ['linear'],
+            ['line-progress'],
+            ...colorStops
+        ]);
+        compileTimeCheck([
+            'interpolate-lab',
+            ['linear'],
+            ['line-progress'],
+            ...colorStops
+        ]);
+        const [firstOutput, ...steps] = ['#df2d43', 50, '#df2d43', 200, '#df2d43'];
+        compileTimeCheck(['step', ['get', 'point_count'], firstOutput, ...steps]);
+        const strings = ['first', 'second', 'third'];
+        compileTimeCheck(['concat', ...strings]);
+        const values: (ExpressionInputType | ExpressionSpecification)[] = [['get', 'name'], ['get', 'code'], 'NONE']; // type is necessary!
+        compileTimeCheck(['coalesce', ...values]);
     });
 
     test('expression, zoom', () => {