@mapbox/mapbox-gl-style-spec 13.12.0 → 13.13.0

package/expression/compound_expression.js

@@ -22,7 +22,7 @@ class CompoundExpression implements Expression {
     _evaluate: Evaluate;
     args: Array<Expression>;
 
-    static definitions: { [string]: Definition };
+    static definitions: {[_: string]: Definition };
 
     constructor(name: string, type: Type, evaluate: Evaluate, args: Array<Expression>) {
         this.name = name;
@@ -35,12 +35,12 @@ class CompoundExpression implements Expression {
         return this._evaluate(ctx, this.args);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         this.args.forEach(fn);
     }
 
-    possibleOutputs() {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize(): Array<mixed> {
@@ -141,7 +141,7 @@ class CompoundExpression implements Expression {
 
     static register(
         registry: ExpressionRegistry,
-        definitions: { [string]: Definition }
+        definitions: {[_: string]: Definition }
     ) {
         assert(!CompoundExpression.definitions);
         CompoundExpression.definitions = definitions;

package/expression/definitions/assertion.js

@@ -18,7 +18,6 @@ import {typeOf} from '../values';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 const types = {
@@ -101,12 +100,12 @@ class Assertion implements Expression {
         return null;
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         this.args.forEach(fn);
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return [].concat(...this.args.map((arg) => arg.possibleOutputs()));
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
     }
 
     serialize(): Array<mixed> {

package/expression/definitions/at.js

@@ -53,13 +53,13 @@ class At implements Expression {
         return array[index];
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.index);
         fn(this.input);
     }
 
-    possibleOutputs() {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize() {

package/expression/definitions/case.js

@@ -7,7 +7,6 @@ import {BooleanType} from '../types';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 type Branches = Array<[Expression, Expression]>;
@@ -64,7 +63,7 @@ class Case implements Expression {
         return this.otherwise.evaluate(ctx);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         for (const [test, expression] of this.branches) {
             fn(test);
             fn(expression);
@@ -72,10 +71,8 @@ class Case implements Expression {
         fn(this.otherwise);
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return []
-            .concat(...this.branches.map(([_, out]) => out.possibleOutputs()))
-            .concat(this.otherwise.possibleOutputs());
+    outputDefined(): boolean {
+        return this.branches.every(([_, out]) => out.outputDefined()) && this.otherwise.outputDefined();
     }
 
     serialize() {

package/expression/definitions/coalesce.js

@@ -8,7 +8,6 @@ import ResolvedImage from '../types/resolved_image';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 class Coalesce implements Expression {
@@ -76,12 +75,12 @@ class Coalesce implements Expression {
         return result;
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         this.args.forEach(fn);
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return [].concat(...this.args.map((arg) => arg.possibleOutputs()));
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
     }
 
     serialize() {

package/expression/definitions/coercion.js

@@ -13,7 +13,6 @@ import ResolvedImage from '../types/resolved_image';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 const types = {
@@ -108,12 +107,12 @@ class Coercion implements Expression {
         }
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         this.args.forEach(fn);
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return [].concat(...this.args.map((arg) => arg.possibleOutputs()));
+    outputDefined(): boolean {
+        return this.args.every(arg => arg.outputDefined());
     }
 
     serialize() {

package/expression/definitions/collator.js

@@ -50,7 +50,7 @@ export default class CollatorExpression implements Expression {
         return new Collator(this.caseSensitive.evaluate(ctx), this.diacriticSensitive.evaluate(ctx), this.locale ? this.locale.evaluate(ctx) : null);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.caseSensitive);
         fn(this.diacriticSensitive);
         if (this.locale) {
@@ -58,12 +58,12 @@ export default class CollatorExpression implements Expression {
         }
     }
 
-    possibleOutputs() {
+    outputDefined() {
         // Technically the set of possible outputs is the combinatoric set of Collators produced
-        // by all possibleOutputs of locale/caseSensitive/diacriticSensitive
+        // by all possible outputs of locale/caseSensitive/diacriticSensitive
         // But for the primary use of Collators in comparison operators, we ignore the Collator's
-        // possibleOutputs anyway, so we can get away with leaving this undefined for now.
-        return [undefined];
+        // possible outputs anyway, so we can get away with leaving this false for now.
+        return false;
     }
 
     serialize() {

package/expression/definitions/comparison.js

@@ -156,7 +156,7 @@ function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollato
                 compareBasic(ctx, lhs, rhs);
         }
 
-        eachChild(fn: (Expression) => void) {
+        eachChild(fn: (_: Expression) => void) {
             fn(this.lhs);
             fn(this.rhs);
             if (this.collator) {
@@ -164,8 +164,8 @@ function makeComparison(op: ComparisonOperator, compareBasic, compareWithCollato
             }
         }
 
-        possibleOutputs() {
-            return [true, false];
+        outputDefined(): boolean {
+            return true;
         }
 
         serialize() {

package/expression/definitions/format.js

@@ -102,7 +102,7 @@ export default class FormatExpression implements Expression {
         return new Formatted(this.sections.map(evaluateSection));
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         for (const section of this.sections) {
             fn(section.content);
             if (section.scale) {
@@ -117,10 +117,10 @@ export default class FormatExpression implements Expression {
         }
     }
 
-    possibleOutputs() {
+    outputDefined() {
         // Technically the combinatoric set of all children
         // Usually, this.text will be undefined anyway
-        return [undefined];
+        return false;
     }
 
     serialize() {

package/expression/definitions/format_section_override.js

@@ -3,7 +3,6 @@
 import assert from 'assert';
 import type {Expression} from '../expression';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 import type {ZoomConstantExpression} from '../../expression';
 import {NullType} from '../types';
@@ -35,7 +34,7 @@ export default class FormatSectionOverride<T> implements Expression {
         return this.defaultValue.property.specification.default;
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         if (!this.defaultValue.isConstant()) {
             const expr: ZoomConstantExpression<'source'> = ((this.defaultValue.value): any);
             fn(expr._styleExpression.expression);
@@ -43,8 +42,8 @@ export default class FormatSectionOverride<T> implements Expression {
     }
 
     // Cannot be statically evaluated, as the output depends on the evaluation context.
-    possibleOutputs(): Array<Value | void> {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize() {

package/expression/definitions/image.js

@@ -30,22 +30,20 @@ export default class ImageExpression implements Expression {
 
     evaluate(ctx: EvaluationContext) {
         const evaluatedImageName = this.input.evaluate(ctx);
-        let available = false;
 
-        if (ctx.availableImages && ctx.availableImages.indexOf(evaluatedImageName) > -1) {
-            available = true;
-        }
+        const value = ResolvedImage.fromString(evaluatedImageName);
+        if (value && ctx.availableImages) value.available = ctx.availableImages.indexOf(evaluatedImageName) > -1;
 
-        return new ResolvedImage({name: evaluatedImageName, available});
+        return value;
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.input);
     }
 
-    possibleOutputs() {
+    outputDefined() {
         // The output of image is determined by the list of available images in the evaluation context
-        return [undefined];
+        return false;
     }
 
     serialize() {

package/expression/definitions/in.js

@@ -62,7 +62,7 @@ class In implements Expression {
         const needle = (this.needle.evaluate(ctx): any);
         const haystack = (this.haystack.evaluate(ctx): any);
 
-        if (!needle || !haystack) return false;
+        if (needle == null || !haystack) return false;
 
         if (!isComparableRuntimeValue(needle)) {
             throw new RuntimeError(`Expected first argument to be of type boolean, string or number, but found ${toString(typeOf(needle))} instead.`);
@@ -75,13 +75,13 @@ class In implements Expression {
         return haystack.indexOf(needle) >= 0;
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.needle);
         fn(this.haystack);
     }
 
-    possibleOutputs() {
-        return [true, false];
+    outputDefined() {
+        return true;
     }
 
     serialize() {

package/expression/definitions/index.js

@@ -42,6 +42,7 @@ import NumberFormat from './number_format';
 import FormatExpression from './format';
 import ImageExpression from './image';
 import Length from './length';
+import Within from './within';
 
 import type {Varargs} from '../compound_expression';
 import type {ExpressionRegistry} from '../expression';
@@ -79,7 +80,8 @@ const expressions: ExpressionRegistry = {
     'to-color': Coercion,
     'to-number': Coercion,
     'to-string': Coercion,
-    'var': Var
+    'var': Var,
+    'within': Within
 };
 
 function rgba(ctx, [r, g, b, a]) {
@@ -455,7 +457,7 @@ CompoundExpression.register(expressions, {
     'filter-has-id': [
         BooleanType,
         [],
-        (ctx) => ctx.id() !== null
+        (ctx) => (ctx.id() !== null && ctx.id() !== undefined)
     ],
     'filter-type-in': [
         BooleanType,

package/expression/definitions/interpolate.js

@@ -11,7 +11,6 @@ import type {Stops} from '../stops';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 export type InterpolationType =
@@ -180,15 +179,15 @@ class Interpolate implements Expression {
         }
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.input);
         for (const expression of this.outputs) {
             fn(expression);
         }
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return [].concat(...this.outputs.map((output) => output.possibleOutputs()));
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined());
     }
 
     serialize(): Array<mixed> {

package/expression/definitions/length.js

@@ -43,12 +43,12 @@ class Length implements Expression {
         }
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.input);
     }
 
-    possibleOutputs() {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize() {

package/expression/definitions/let.js

@@ -20,7 +20,7 @@ class Let implements Expression {
         return this.result.evaluate(ctx);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         for (const binding of this.bindings) {
             fn(binding[1]);
         }
@@ -55,8 +55,8 @@ class Let implements Expression {
         return new Let(bindings, result);
     }
 
-    possibleOutputs() {
-        return this.result.possibleOutputs();
+    outputDefined() {
+        return this.result.outputDefined();
     }
 
     serialize() {

package/expression/definitions/literal.js

@@ -49,8 +49,8 @@ class Literal implements Expression {
 
     eachChild() {}
 
-    possibleOutputs() {
-        return [this.value];
+    outputDefined() {
+        return true;
     }
 
     serialize(): Array<mixed> {

package/expression/definitions/match.js

@@ -8,7 +8,6 @@ import {ValueType, type Type} from '../types';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 
 // Map input label values to output expression index
 type Cases = {[number | string]: number};
@@ -106,16 +105,14 @@ class Match implements Expression {
         return output.evaluate(ctx);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.input);
         this.outputs.forEach(fn);
         fn(this.otherwise);
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return []
-            .concat(...this.outputs.map((out) => out.possibleOutputs()))
-            .concat(this.otherwise.possibleOutputs());
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined()) && this.otherwise.outputDefined();
     }
 
     serialize(): Array<mixed> {

package/expression/definitions/number_format.js

@@ -103,7 +103,7 @@ export default class NumberFormat implements Expression {
             }).format(this.number.evaluate(ctx));
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.number);
         if (this.locale) {
             fn(this.locale);
@@ -119,8 +119,8 @@ export default class NumberFormat implements Expression {
         }
     }
 
-    possibleOutputs() {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize() {

package/expression/definitions/step.js

@@ -8,7 +8,6 @@ import type {Stops} from '../stops';
 import type {Expression} from '../expression';
 import type ParsingContext from '../parsing_context';
 import type EvaluationContext from '../evaluation_context';
-import type {Value} from '../values';
 import type {Type} from '../types';
 
 class Step implements Expression {
@@ -95,15 +94,15 @@ class Step implements Expression {
         return outputs[index].evaluate(ctx);
     }
 
-    eachChild(fn: (Expression) => void) {
+    eachChild(fn: (_: Expression) => void) {
         fn(this.input);
         for (const expression of this.outputs) {
             fn(expression);
         }
     }
 
-    possibleOutputs(): Array<Value | void> {
-        return [].concat(...this.outputs.map((output) => output.possibleOutputs()));
+    outputDefined(): boolean {
+        return this.outputs.every(out => out.outputDefined());
     }
 
     serialize() {

package/expression/definitions/var.js

@@ -34,8 +34,8 @@ class Var implements Expression {
 
     eachChild() {}
 
-    possibleOutputs() {
-        return [undefined];
+    outputDefined() {
+        return false;
     }
 
     serialize() {