@mapwhit/tilerenderer 0.47.2 → 0.48.0

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

@@ -26,21 +26,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,
+  '>': GreaterThan,
+  '<': LessThan,
+  '>=': GreaterThanOrEqual,
+  '<=': LessThanOrEqual,
   array: ArrayAssertion,
   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 +81,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 +116,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 +305,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

@@ -97,6 +97,10 @@ class ParsingContext {
             if (!options.omitTypeAnnotations) {
               parsed = new Coercion(expected, [parsed]);
             }
+          } else if (expected.kind === 'formatted' && (actual.kind === 'value' || actual.kind === 'string')) {
+            if (!options.omitTypeAnnotations) {
+              parsed = new Coercion(expected, [parsed]);
+            }
           } else if (this.checkSubtype(this.expectedType, parsed.type)) {
             return null;
           }

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,

package/src/style-spec/feature_filter/index.js

@@ -24,7 +24,7 @@ function isExpressionFilter(filter) {
     case '>=':
     case '<':
     case '<=':
-      return filter.length === 3 && (Array.isArray(filter[1]) || Array.isArray(filter[2]));
+      return filter.length !== 3 || Array.isArray(filter[1]) || Array.isArray(filter[2]);
 
     case 'any':
     case 'all':