@mapwhit/tilerenderer 0.47.2 → 0.49.0

package/src/style-spec/expression/definitions/comparison.js

@@ -0,0 +1,193 @@
+const { toString, ValueType, BooleanType, CollatorType } = require('../types');
+const Assertion = require('./assertion');
+const { typeOf } = require('../values');
+const RuntimeError = require('../runtime_error');
+
+function isComparableType(op, type) {
+  if (op === '==' || op === '!=') {
+    // equality operator
+    return (
+      type.kind === 'boolean' ||
+      type.kind === 'string' ||
+      type.kind === 'number' ||
+      type.kind === 'null' ||
+      type.kind === 'value'
+    );
+  }
+  // ordering operator
+  return type.kind === 'string' || type.kind === 'number' || type.kind === 'value';
+}
+
+function eq(ctx, a, b) {
+  return a === b;
+}
+function neq(ctx, a, b) {
+  return a !== b;
+}
+function lt(ctx, a, b) {
+  return a < b;
+}
+function gt(ctx, a, b) {
+  return a > b;
+}
+function lteq(ctx, a, b) {
+  return a <= b;
+}
+function gteq(ctx, a, b) {
+  return a >= b;
+}
+
+function eqCollate(ctx, a, b, c) {
+  return c.compare(a, b) === 0;
+}
+function neqCollate(ctx, a, b, c) {
+  return !eqCollate(ctx, a, b, c);
+}
+function ltCollate(ctx, a, b, c) {
+  return c.compare(a, b) < 0;
+}
+function gtCollate(ctx, a, b, c) {
+  return c.compare(a, b) > 0;
+}
+function lteqCollate(ctx, a, b, c) {
+  return c.compare(a, b) <= 0;
+}
+function gteqCollate(ctx, a, b, c) {
+  return c.compare(a, b) >= 0;
+}
+
+/**
+ * Special form for comparison operators, implementing the signatures:
+ * - (T, T, ?Collator) => boolean
+ * - (T, value, ?Collator) => boolean
+ * - (value, T, ?Collator) => boolean
+ *
+ * For inequalities, T must be either value, string, or number. For ==/!=, it
+ * can also be boolean or null.
+ *
+ * Equality semantics are equivalent to Javascript's strict equality (===/!==)
+ * -- i.e., when the arguments' types don't match, == evaluates to false, != to
+ * true.
+ *
+ * When types don't match in an ordering comparison, a runtime error is thrown.
+ *
+ * @private
+ */
+function makeComparison(op, compareBasic, compareWithCollator) {
+  const isOrderComparison = op !== '==' && op !== '!=';
+
+  return class Comparison {
+    constructor(lhs, rhs, collator) {
+      this.type = BooleanType;
+      this.lhs = lhs;
+      this.rhs = rhs;
+      this.collator = collator;
+      this.hasUntypedArgument = lhs.type.kind === 'value' || rhs.type.kind === 'value';
+    }
+
+    static parse(args, context) {
+      if (args.length !== 3 && args.length !== 4) return context.error('Expected two or three arguments.');
+
+      const op = args[0];
+
+      let lhs = context.parse(args[1], 1, ValueType);
+      if (!lhs) return null;
+      if (!isComparableType(op, lhs.type)) {
+        return context.concat(1).error(`"${op}" comparisons are not supported for type '${toString(lhs.type)}'.`);
+      }
+      let rhs = context.parse(args[2], 2, ValueType);
+      if (!rhs) return null;
+      if (!isComparableType(op, rhs.type)) {
+        return context.concat(2).error(`"${op}" comparisons are not supported for type '${toString(rhs.type)}'.`);
+      }
+
+      if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== 'value' && rhs.type.kind !== 'value') {
+        return context.error(`Cannot compare types '${toString(lhs.type)}' and '${toString(rhs.type)}'.`);
+      }
+
+      if (isOrderComparison) {
+        // typing rules specific to less/greater than operators
+        if (lhs.type.kind === 'value' && rhs.type.kind !== 'value') {
+          // (value, T)
+          lhs = new Assertion(rhs.type, [lhs]);
+        } else if (lhs.type.kind !== 'value' && rhs.type.kind === 'value') {
+          // (T, value)
+          rhs = new Assertion(lhs.type, [rhs]);
+        }
+      }
+
+      let collator = null;
+      if (args.length === 4) {
+        if (
+          lhs.type.kind !== 'string' &&
+          rhs.type.kind !== 'string' &&
+          lhs.type.kind !== 'value' &&
+          rhs.type.kind !== 'value'
+        ) {
+          return context.error('Cannot use collator to compare non-string types.');
+        }
+        collator = context.parse(args[3], 3, CollatorType);
+        if (!collator) return null;
+      }
+
+      return new Comparison(lhs, rhs, collator);
+    }
+
+    evaluate(ctx) {
+      const lhs = this.lhs.evaluate(ctx);
+      const rhs = this.rhs.evaluate(ctx);
+
+      if (isOrderComparison && this.hasUntypedArgument) {
+        const lt = typeOf(lhs);
+        const rt = typeOf(rhs);
+        // check that type is string or number, and equal
+        if (lt.kind !== rt.kind || !(lt.kind === 'string' || lt.kind === 'number')) {
+          throw new RuntimeError(
+            `Expected arguments for "${op}" to be (string, string) or (number, number), but found (${lt.kind}, ${rt.kind}) instead.`
+          );
+        }
+      }
+
+      if (this.collator && !isOrderComparison && this.hasUntypedArgument) {
+        const lt = typeOf(lhs);
+        const rt = typeOf(rhs);
+        if (lt.kind !== 'string' || rt.kind !== 'string') {
+          return compareBasic(ctx, lhs, rhs);
+        }
+      }
+
+      return this.collator
+        ? compareWithCollator(ctx, lhs, rhs, this.collator.evaluate(ctx))
+        : compareBasic(ctx, lhs, rhs);
+    }
+
+    eachChild(fn) {
+      fn(this.lhs);
+      fn(this.rhs);
+      if (this.collator) {
+        fn(this.collator);
+      }
+    }
+
+    possibleOutputs() {
+      return [true, false];
+    }
+
+    serialize() {
+      const serialized = [op];
+      this.eachChild(child => {
+        serialized.push(child.serialize());
+      });
+      return serialized;
+    }
+  };
+}
+
+module.exports = {
+  Equals: makeComparison('==', eq, eqCollate),
+  NotEquals: makeComparison('!=', neq, neqCollate),
+  LessThan: makeComparison('<', lt, ltCollate),
+  GreaterThan: makeComparison('>', gt, gtCollate),
+  LessThanOrEqual: makeComparison('<=', lteq, lteqCollate),
+  GreaterThanOrEqual: makeComparison('>=', gteq, gteqCollate)
+};

package/src/style-spec/expression/definitions/formatted.js

@@ -0,0 +1,123 @@
+const { NumberType, ValueType, FormattedType, array, StringType } = require('../types');
+
+class FormattedSection {
+  constructor(text, scale, fontStack) {
+    this.text = text;
+    this.scale = scale;
+    this.fontStack = fontStack;
+  }
+}
+
+class Formatted {
+  constructor(sections) {
+    this.sections = sections;
+  }
+
+  toString() {
+    return this.sections.map(section => section.text).join('');
+  }
+
+  serialize() {
+    const serialized = ['format'];
+    for (const section of this.sections) {
+      serialized.push(section.text);
+      const fontStack = section.fontStack ? ['literal', section.fontStack.split(',')] : null;
+      serialized.push({ 'text-font': fontStack, 'font-scale': section.scale });
+    }
+    return serialized;
+  }
+}
+
+class FormatExpression {
+  constructor(sections) {
+    this.type = FormattedType;
+    this.sections = sections;
+  }
+
+  static parse(args, context) {
+    if (args.length < 3) {
+      return context.error('Expected at least two arguments.');
+    }
+
+    if ((args.length - 1) % 2 !== 0) {
+      return context.error('Expected an even number of arguments.');
+    }
+
+    const sections = [];
+    for (let i = 1; i < args.length - 1; i += 2) {
+      const text = context.parse(args[i], 1, ValueType);
+      if (!text) return null;
+      const kind = text.type.kind;
+      if (kind !== 'string' && kind !== 'value' && kind !== 'null')
+        return context.error("Formatted text type must be 'string', 'value', or 'null'.");
+
+      const options = args[i + 1];
+      if (typeof options !== 'object' || Array.isArray(options))
+        return context.error('Format options argument must be an object.');
+
+      let scale = null;
+      if (options['font-scale']) {
+        scale = context.parse(options['font-scale'], 1, NumberType);
+        if (!scale) return null;
+      }
+
+      let font = null;
+      if (options['text-font']) {
+        font = context.parse(options['text-font'], 1, array(StringType));
+        if (!font) return null;
+      }
+      sections.push({ text, scale, font });
+    }
+
+    return new FormatExpression(sections);
+  }
+
+  evaluate(ctx) {
+    return new Formatted(
+      this.sections.map(
+        section =>
+          new FormattedSection(
+            section.text.evaluate(ctx) || '',
+            section.scale ? section.scale.evaluate(ctx) : null,
+            section.font ? section.font.evaluate(ctx).join(',') : null
+          )
+      )
+    );
+  }
+
+  eachChild(fn) {
+    for (const section of this.sections) {
+      fn(section.text);
+      if (section.scale) {
+        fn(section.scale);
+      }
+      if (section.font) {
+        fn(section.font);
+      }
+    }
+  }
+
+  possibleOutputs() {
+    // Technically the combinatoric set of all children
+    // Usually, this.text will be undefined anyway
+    return [undefined];
+  }
+
+  serialize() {
+    const serialized = ['format'];
+    for (const section of this.sections) {
+      serialized.push(section.text.serialize());
+      const options = {};
+      if (section.scale) {
+        options['font-scale'] = section.scale.serialize();
+      }
+      if (section.font) {
+        options['text-font'] = section.font.serialize();
+      }
+      serialized.push(options);
+    }
+    return serialized;
+  }
+}
+
+module.exports = { Formatted, FormatExpression };

package/src/style-spec/expression/definitions/index.js

@@ -18,7 +18,6 @@ const Let = require('./let');
 const Var = require('./var');
 const Literal = require('./literal');
 const Assertion = require('./assertion');
-const ArrayAssertion = require('./array');
 const Coercion = require('./coercion');
 const At = require('./at');
 const Match = require('./match');
@@ -26,21 +25,29 @@ const Case = require('./case');
 const Step = require('./step');
 const Interpolate = require('./interpolate');
 const Coalesce = require('./coalesce');
-const { Equals, NotEquals } = require('./equals');
+const { Equals, NotEquals, LessThan, GreaterThan, LessThanOrEqual, GreaterThanOrEqual } = require('./comparison');
 const { CollatorExpression } = require('./collator');
+const { Formatted, FormatExpression } = require('./formatted');
 const Length = require('./length');
 
 const expressions = {
   // special forms
   '==': Equals,
   '!=': NotEquals,
-  array: ArrayAssertion,
+  '>': GreaterThan,
+  '<': LessThan,
+  '>=': GreaterThanOrEqual,
+  '<=': LessThanOrEqual,
+  array: Assertion,
   at: At,
   boolean: Assertion,
   case: Case,
   coalesce: Coalesce,
   collator: CollatorExpression,
+  format: FormatExpression,
   interpolate: Interpolate,
+  'interpolate-hcl': Interpolate,
+  'interpolate-lab': Interpolate,
   length: Length,
   let: Let,
   literal: Literal,
@@ -73,32 +80,6 @@ function get(key, obj) {
   return typeof v === 'undefined' ? null : v;
 }
 
-function lt(ctx, [a, b]) {
-  return a.evaluate(ctx) < b.evaluate(ctx);
-}
-function gt(ctx, [a, b]) {
-  return a.evaluate(ctx) > b.evaluate(ctx);
-}
-function lteq(ctx, [a, b]) {
-  return a.evaluate(ctx) <= b.evaluate(ctx);
-}
-function gteq(ctx, [a, b]) {
-  return a.evaluate(ctx) >= b.evaluate(ctx);
-}
-
-function ltCollate(ctx, [a, b, c]) {
-  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) < 0;
-}
-function gtCollate(ctx, [a, b, c]) {
-  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) > 0;
-}
-function lteqCollate(ctx, [a, b, c]) {
-  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) <= 0;
-}
-function gteqCollate(ctx, [a, b, c]) {
-  return c.evaluate(ctx).compare(a.evaluate(ctx), b.evaluate(ctx)) >= 0;
-}
-
 function binarySearch(v, a, i, j) {
   while (i <= j) {
     const m = (i + j) >> 1;
@@ -134,7 +115,7 @@ CompoundExpression.register(expressions, {
       if (type === 'string' || type === 'number' || type === 'boolean') {
         return String(v);
       }
-      if (v instanceof Color) {
+      if (v instanceof Color || v instanceof Formatted) {
         return v.toString();
       }
       return JSON.stringify(v);
@@ -323,38 +304,6 @@ CompoundExpression.register(expressions, {
     // assumes v is a array literal with values sorted in ascending order and of a single type
     (ctx, [k, v]) => binarySearch(ctx.properties()[k.value], v.value, 0, v.value.length - 1)
   ],
-  '>': {
-    type: BooleanType,
-    overloads: [
-      [[NumberType, NumberType], gt],
-      [[StringType, StringType], gt],
-      [[StringType, StringType, CollatorType], gtCollate]
-    ]
-  },
-  '<': {
-    type: BooleanType,
-    overloads: [
-      [[NumberType, NumberType], lt],
-      [[StringType, StringType], lt],
-      [[StringType, StringType, CollatorType], ltCollate]
-    ]
-  },
-  '>=': {
-    type: BooleanType,
-    overloads: [
-      [[NumberType, NumberType], gteq],
-      [[StringType, StringType], gteq],
-      [[StringType, StringType, CollatorType], gteqCollate]
-    ]
-  },
-  '<=': {
-    type: BooleanType,
-    overloads: [
-      [[NumberType, NumberType], lteq],
-      [[StringType, StringType], lteq],
-      [[StringType, StringType, CollatorType], lteqCollate]
-    ]
-  },
   all: {
     type: BooleanType,
     overloads: [

package/src/style-spec/expression/definitions/interpolate.js

@@ -1,12 +1,14 @@
 const UnitBezier = require('@mapbox/unitbezier');
 
 const interpolate = require('../../util/interpolate');
-const { toString, NumberType } = require('../types');
+const { toString, ColorType, NumberType } = require('../types');
 const { findStopLessThanOrEqualTo } = require('../stops');
+const { hcl, lab } = require('../../util/color_spaces');
 
 class Interpolate {
-  constructor(type, interpolation, input, stops) {
+  constructor(type, operator, interpolation, input, stops) {
     this.type = type;
+    this.operator = operator;
     this.interpolation = interpolation;
     this.input = input;
 
@@ -33,7 +35,7 @@ class Interpolate {
   }
 
   static parse(args, context) {
-    let [, interpolation, input, ...rest] = args;
+    let [operator, interpolation, input, ...rest] = args;
 
     if (!Array.isArray(interpolation) || interpolation.length === 0) {
       return context.error('Expected an interpolation type expression.', 1);
@@ -79,7 +81,9 @@ class Interpolate {
     const stops = [];
 
     let outputType = null;
-    if (context.expectedType && context.expectedType.kind !== 'value') {
+    if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
+      outputType = ColorType;
+    } else if (context.expectedType && context.expectedType.kind !== 'value') {
       outputType = context.expectedType;
     }
 
@@ -118,7 +122,7 @@ class Interpolate {
       return context.error(`Type ${toString(outputType)} is not interpolatable.`);
     }
 
-    return new Interpolate(outputType, interpolation, input, stops);
+    return new Interpolate(outputType, operator, interpolation, input, stops);
   }
 
   evaluate(ctx) {
@@ -147,7 +151,13 @@ class Interpolate {
     const outputLower = outputs[index].evaluate(ctx);
     const outputUpper = outputs[index + 1].evaluate(ctx);
 
-    return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
+    if (this.operator === 'interpolate') {
+      return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
+    }
+    if (this.operator === 'interpolate-hcl') {
+      return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
+    }
+    return lab.reverse(lab.interpolate(lab.forward(outputLower), lab.forward(outputUpper), t));
   }
 
   eachChild(fn) {
@@ -175,7 +185,7 @@ class Interpolate {
       interpolation = ['cubic-bezier'].concat(this.interpolation.controlPoints);
     }
 
-    const serialized = ['interpolate', interpolation, this.input.serialize()];
+    const serialized = [this.operator, interpolation, this.input.serialize()];
 
     for (let i = 0; i < this.labels.length; i++) {
       serialized.push(this.labels[i], this.outputs[i].serialize());

package/src/style-spec/expression/definitions/literal.js

@@ -1,5 +1,6 @@
 const assert = require('assert');
 const { isValue, typeOf, Color } = require('../values');
+const { Formatted } = require('./formatted');
 
 class Literal {
   constructor(type, value) {
@@ -51,6 +52,10 @@ class Literal {
       // so we have to implement an equivalent serialization here
       return ['rgba'].concat(this.value.toArray());
     }
+    if (this.value instanceof Formatted) {
+      // Same as Color
+      return this.value.serialize();
+    }
     assert(
       this.value === null ||
         typeof this.value === 'string' ||

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

@@ -4,7 +4,6 @@ const { checkSubtype } = require('./types');
 const ParsingError = require('./parsing_error');
 const Literal = require('./definitions/literal');
 const Assertion = require('./definitions/assertion');
-const ArrayAssertion = require('./definitions/array');
 const Coercion = require('./definitions/coercion');
 const EvaluationContext = require('./evaluation_context');
 const { CollatorExpression } = require('./definitions/collator');
@@ -83,17 +82,18 @@ class ParsingContext {
             (expected.kind === 'string' ||
               expected.kind === 'number' ||
               expected.kind === 'boolean' ||
-              expected.kind === 'object') &&
+              expected.kind === 'object' ||
+              expected.kind === 'array') &&
             actual.kind === 'value'
           ) {
             if (!options.omitTypeAnnotations) {
               parsed = new Assertion(expected, [parsed]);
             }
-          } else if (expected.kind === 'array' && actual.kind === 'value') {
+          } else if (expected.kind === 'color' && (actual.kind === 'value' || actual.kind === 'string')) {
             if (!options.omitTypeAnnotations) {
-              parsed = new ArrayAssertion(expected, parsed);
+              parsed = new Coercion(expected, [parsed]);
             }
-          } else if (expected.kind === 'color' && (actual.kind === 'value' || actual.kind === 'string')) {
+          } else if (expected.kind === 'formatted' && (actual.kind === 'value' || actual.kind === 'string')) {
             if (!options.omitTypeAnnotations) {
               parsed = new Coercion(expected, [parsed]);
             }
@@ -184,8 +184,7 @@ function isConstant(expression) {
     return false;
   }
 
-  const isTypeAnnotation =
-    expression instanceof Coercion || expression instanceof Assertion || expression instanceof ArrayAssertion;
+  const isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
 
   let childrenConstant = true;
   expression.eachChild(child => {

package/src/style-spec/expression/types.js

@@ -7,6 +7,7 @@ const ObjectType = { kind: 'object' };
 const ValueType = { kind: 'value' };
 const ErrorType = { kind: 'error' };
 const CollatorType = { kind: 'collator' };
+const FormattedType = { kind: 'formatted' };
 
 function array(itemType, N) {
   return {
@@ -28,7 +29,16 @@ function toString(type) {
   return type.kind;
 }
 
-const valueMemberTypes = [NullType, NumberType, StringType, BooleanType, ColorType, ObjectType, array(ValueType)];
+const valueMemberTypes = [
+  NullType,
+  NumberType,
+  StringType,
+  BooleanType,
+  ColorType,
+  FormattedType,
+  ObjectType,
+  array(ValueType)
+];
 
 /**
  * Returns null if `t` is a subtype of `expected`; otherwise returns an
@@ -67,6 +77,7 @@ module.exports = {
   StringType,
   BooleanType,
   ColorType,
+  FormattedType,
   ObjectType,
   ValueType,
   ErrorType,