maplibre-gl 2.3.0 → 2.4.0

package/src/source/rtl_text_plugin.ts

@@ -1,7 +1,6 @@
 import {Event, Evented} from '../util/evented';
 import {getArrayBuffer} from '../util/ajax';
 import browser from '../util/browser';
-import assert from 'assert';
 import {isWorker} from '../util/util';
 
 const status = {
@@ -113,20 +112,20 @@ export const plugin: {
         return pluginStatus === status.loading;
     },
     setState(state: PluginState) { // Worker thread only: this tells the worker threads that the plugin is available on the Main thread
-        assert(isWorker(), 'Cannot set the state of the rtl-text-plugin when not in the web-worker context');
+        if (!isWorker()) throw new Error('Cannot set the state of the rtl-text-plugin when not in the web-worker context');
 
         pluginStatus = state.pluginStatus;
         pluginURL = state.pluginURL;
     },
     isParsed(): boolean {
-        assert(isWorker(), 'rtl-text-plugin is only parsed on the worker-threads');
+        if (!isWorker()) throw new Error('rtl-text-plugin is only parsed on the worker-threads');
 
         return plugin.applyArabicShaping != null &&
             plugin.processBidirectionalText != null &&
             plugin.processStyledBidirectionalText != null;
     },
     getPluginURL(): string {
-        assert(isWorker(), 'rtl-text-plugin url can only be queried from the worker threads');
+        if (!isWorker()) throw new Error('rtl-text-plugin url can only be queried from the worker threads');
         return pluginURL;
     }
 };

package/src/source/source_cache.ts

@@ -10,7 +10,6 @@ import Context from '../gl/context';
 import Point from '@mapbox/point-geometry';
 import browser from '../util/browser';
 import {OverscaledTileID} from './tile_id';
-import assert from 'assert';
 import SourceFeatureState from './source_state';
 
 import type {Source} from './source';
@@ -556,7 +555,6 @@ class SourceCache extends Evented {
             const ids = Object.keys(retain);
             for (const id of ids) {
                 const tileID = retain[id];
-                assert(tileID.key === id);
 
                 const tile = this._tiles[id];
                 if (!tile || tile.fadeEndTime && tile.fadeEndTime <= browser.now()) continue;

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;

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}`);
                 }
             }
 
@@ -499,6 +499,7 @@ class Style extends Evented {
 
         // remove terrain
         if (!options) {
+            if (this.terrain) this.terrain.sourceCache.destruct();
             this.terrain = null;
             this.map.transform.updateElevation(this.terrain);
 
@@ -677,9 +678,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';
@@ -25,7 +24,7 @@ import type {BucketParameters} from '../../data/bucket';
 import type {SymbolLayoutProps, SymbolPaintProps} from './symbol_style_layer_properties.g';
 import type EvaluationParameters from '../evaluation_parameters';
 import type {LayerSpecification} from '../../style-spec/types.g';
-import type {Feature, SourceExpression, CompositeExpression} from '../../style-spec/expression';
+import type {Feature, SourceExpression} from '../../style-spec/expression';
 import type {Expression} from '../../style-spec/expression/expression';
 import type {CanonicalTileID} from '../../source/tile_id';
 import {FormattedType} from '../../style-spec/expression/types';
@@ -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() {
@@ -124,12 +122,11 @@ class SymbolStyleLayer extends StyleLayer {
             const styleExpression = new StyleExpression(override, overriden.property.specification);
             let expression = null;
             if (overriden.value.kind === 'constant' || overriden.value.kind === 'source') {
-                expression = (new ZoomConstantExpression('source', styleExpression) as SourceExpression);
+                expression = new ZoomConstantExpression('source', styleExpression) as SourceExpression;
             } else {
-                expression = (new ZoomDependentExpression('composite',
+                expression = new ZoomDependentExpression('composite',
                     styleExpression,
-                    overriden.value.zoomStops,
-                    (overriden.value as any)._interpolationType) as CompositeExpression);
+                    overriden.value.zoomStops);
             }
             this.paint._values[overridable] = new PossiblyEvaluatedPropertyValue(overriden.property,
                 expression,

package/src/style-spec/CHANGELOG.md

@@ -6,7 +6,7 @@
 
 ### 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)
+* 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
 
@@ -55,7 +55,7 @@
 ## 13.16.0
 
 ### ✨ Features and improvements
-* Added `volatile` source property to control storing the tiles in local storage. ([9702](https://github.com/mapbox/mapbox-gl-js/pull/9702))
+* Added `volatile` source property to control storing the tiles in local storage. ([#9702](https://github.com/mapbox/mapbox-gl-js/pull/9702))
 
 * Added `clusterMinPoints` option for clustered GeoJSON sources that defines the minimum number of points to form a cluster. ([#9748](https://github.com/mapbox/mapbox-gl-js/pull/9748))
 

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,4 +1,3 @@
-import assert from 'assert';
 
 import extend from '../util/extend';
 import ExpressionParsingError from './parsing_error';
@@ -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);
     }
 

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', () => {

package/src/style-spec/function/convert.ts

@@ -1,4 +1,4 @@
-import assert from 'assert';
+
 import type {StylePropertySpecification} from '../style-spec';
 
 export default convertFunction;
@@ -138,7 +138,6 @@ function convertPropertyFunction(parameters, propertySpec, stops) {
     const type = getFunctionType(parameters, propertySpec);
     const get = ['get', parameters.property];
     if (type === 'categorical' && typeof stops[0][0] === 'boolean') {
-        assert(parameters.stops.length > 0 && parameters.stops.length <= 2);
         const expression: any = ['case'];
         for (const stop of stops) {
             expression.push(['==', get, stop[0]], stop[1]);
@@ -236,7 +235,6 @@ function getFunctionType(parameters, propertySpec) {
     if (parameters.type) {
         return parameters.type;
     } else {
-        assert(propertySpec.expression);
         return (propertySpec.expression as any).interpolated ? 'exponential' : 'interval';
     }
 }

package/src/style-spec/types.g.ts

@@ -24,7 +24,7 @@ export type InterpolationSpecification =
     | ['linear'] 
     | ['exponential', number | ExpressionSpecification] 
     | ['cubic-bezier', number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification, number | ExpressionSpecification]
-    
+
 export type ExpressionSpecification = 
     // types
     | ['array', unknown | ExpressionSpecification] // array
@@ -70,31 +70,26 @@ export type ExpressionSpecification =
     | ['any', ...(boolean | ExpressionSpecification)[]] // boolean
     | ['case', boolean | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
         ...(boolean | ExpressionInputType | ExpressionSpecification)[], ExpressionInputType | ExpressionSpecification]
-    | ['coalesce', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(ExpressionInputType | ExpressionSpecification)[]]
+    | ['coalesce', ...(ExpressionInputType | ExpressionSpecification)[]] // at least two inputs required
     | ['match', ExpressionInputType | ExpressionSpecification, 
         ExpressionInputType | ExpressionInputType[], ExpressionInputType | ExpressionSpecification, 
         ...(ExpressionInputType | ExpressionInputType[] | ExpressionSpecification)[], // repeated as above
         ExpressionInputType]
     | ['within', unknown | ExpressionSpecification]
     // Ramps, scales, curves
-    | ['interpolate', InterpolationSpecification, 
-        number | ExpressionSpecification, number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(number | ExpressionInputType | ExpressionSpecification)[]]
-    | ['interpolate-hcl', InterpolationSpecification,
-        number | ExpressionSpecification, number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(number | ColorSpecification | ExpressionSpecification)[]]
-    | ['interpolate-lab', InterpolationSpecification,
-        number | ExpressionSpecification, number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(number | ColorSpecification | ExpressionSpecification)[]]
-    | ['step', number | ExpressionSpecification, number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(number | ExpressionInputType | ExpressionSpecification)[]]
+    | ['interpolate', InterpolationSpecification, number | ExpressionSpecification, 
+        ...(number | number[] | ColorSpecification)[]] // alternating number and number | number[] | ColorSpecification
+    | ['interpolate-hcl', InterpolationSpecification, number | ExpressionSpecification, 
+        ...(number | ColorSpecification)[]] // alternating number and ColorSpecificaton
+    | ['interpolate-lab', InterpolationSpecification, number | ExpressionSpecification, 
+        ...(number | ColorSpecification)[]] // alternating number and ColorSpecification
+    | ['step', number | ExpressionSpecification, ExpressionInputType | ExpressionSpecification,
+        ...(number | ExpressionInputType | ExpressionSpecification)[]] // alternating number and ExpressionInputType | ExpressionSpecification
     // Variable binding
     | ['let', string, ExpressionInputType | ExpressionSpecification, ...(string | ExpressionInputType | ExpressionSpecification)[]]
     | ['var', string]
     // String
-    | ['concat', ExpressionInputType | ExpressionSpecification, ExpressionInputType | ExpressionSpecification, 
-        ...(ExpressionInputType | ExpressionSpecification)[]] // string
+    | ['concat', ...(ExpressionInputType | ExpressionSpecification)[]] // at least two inputs required -> string
     | ['downcase', string | ExpressionSpecification] // string
     | ['is-supported-script', string | ExpressionSpecification] // boolean
     | ['resolved-locale', CollatorExpressionSpecification] // string
@@ -109,7 +104,7 @@ export type ExpressionSpecification =
     | ['/', number | ExpressionSpecification, number | ExpressionSpecification] // number
     | ['%', number | ExpressionSpecification, number | ExpressionSpecification] // number
     | ['^', number | ExpressionSpecification, number | ExpressionSpecification] // number
-    | ['+', number | ExpressionSpecification, number | ExpressionSpecification, ...(number | ExpressionSpecification)[]] // number
+    | ['+', ...(number | ExpressionSpecification)[]] // at least two inputs required -> number
     | ['abs', number | ExpressionSpecification] // number
     | ['acos', number | ExpressionSpecification] // number
     | ['asin', number | ExpressionSpecification] // number

package/src/symbol/collision_index.ts

@@ -6,7 +6,6 @@ import * as intersectionTests from '../util/intersection_tests';
 import GridIndex from './grid_index';
 import {mat4, vec4} from 'gl-matrix';
 import ONE_EM from '../symbol/one_em';
-import assert from 'assert';
 
 import * as projection from '../symbol/projection';
 
@@ -181,7 +180,6 @@ class CollisionIndex {
             for (let i = 1; i < last.path.length; i++) {
                 projectedPath.push(last.path[i]);
             }
-            assert(projectedPath.length >= 2);
 
             // Tolerate a slightly longer distance than one diameter between two adjacent circles
             const circleDist = radius * 2.5;
@@ -229,7 +227,6 @@ class CollisionIndex {
 
             for (const seg of segments) {
                 // interpolate positions for collision circles. Add a small padding to both ends of the segment
-                assert(seg.length > 0);
                 interpolator.reset(seg, radius * 0.25);
 
                 let numCircles = 0;