@mapwhit/tilerenderer 0.47.1 → 0.48.0

package/src/style/style_layer_index.js

@@ -5,54 +5,48 @@ const featureFilter = require('../style-spec/feature_filter');
 const groupByLayout = require('../style-spec/group_by_layout');
 
 class StyleLayerIndex {
+  #layerConfigs = {};
+  #layers = {};
+
   constructor(layerConfigs) {
     if (layerConfigs) {
-      this.replace(layerConfigs);
+      this.update(layerConfigs);
     }
   }
 
   replace(layerConfigs) {
-    this._layerConfigs = {};
-    this._layers = {};
-    this.update(layerConfigs, []);
+    this.#layerConfigs = {};
+    this.#layers = {};
+    this.update(layerConfigs);
   }
 
-  update(layerConfigs, removedIds) {
+  update(layerConfigs, removedIds = []) {
     for (const layerConfig of layerConfigs) {
-      this._layerConfigs[layerConfig.id] = layerConfig;
+      this.#layerConfigs[layerConfig.id] = layerConfig;
 
-      const layer = (this._layers[layerConfig.id] = createStyleLayer(layerConfig));
+      const layer = (this.#layers[layerConfig.id] = createStyleLayer(layerConfig));
       layer._featureFilter = featureFilter(layer.filter);
     }
     for (const id of removedIds) {
-      delete this._layerConfigs[id];
-      delete this._layers[id];
+      delete this.#layerConfigs[id];
+      delete this.#layers[id];
     }
 
     this.familiesBySource = {};
 
-    const groups = groupByLayout(values(this._layerConfigs));
+    const groups = groupByLayout(values(this.#layerConfigs));
 
     for (const layerConfigs of groups) {
-      const layers = layerConfigs.map(layerConfig => this._layers[layerConfig.id]);
+      const layers = layerConfigs.map(layerConfig => this.#layers[layerConfig.id]);
 
       const layer = layers[0];
       if (layer.visibility === 'none') {
         continue;
       }
 
-      const sourceId = layer.source || '';
-      let sourceGroup = this.familiesBySource[sourceId];
-      if (!sourceGroup) {
-        sourceGroup = this.familiesBySource[sourceId] = {};
-      }
-
-      const sourceLayerId = layer.sourceLayer || '_geojsonTileLayer';
-      let sourceLayerFamilies = sourceGroup[sourceLayerId];
-      if (!sourceLayerFamilies) {
-        sourceLayerFamilies = sourceGroup[sourceLayerId] = [];
-      }
-
+      const { source = '', sourceLayer = '_geojsonTileLayer' } = layer;
+      const sourceGroup = (this.familiesBySource[source] ??= {});
+      const sourceLayerFamilies = (sourceGroup[sourceLayer] ??= []);
       sourceLayerFamilies.push(layers);
     }
   }

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

@@ -46,20 +46,6 @@ class CompoundExpression {
         signature.length === args.length - 1 // correct param count
     );
 
-    // First parse all the args
-    const parsedArgs = [];
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-      let expected;
-      if (overloads.length === 1) {
-        const params = overloads[0][0];
-        expected = Array.isArray(params) ? params[i - 1] : params.type;
-      }
-      const parsed = context.parse(arg, 1 + parsedArgs.length, expected);
-      if (!parsed) return null;
-      parsedArgs.push(parsed);
-    }
-
     let signatureContext = null;
 
     for (const [params, evaluate] of overloads) {
@@ -67,6 +53,27 @@ class CompoundExpression {
       // we eventually succeed, we haven't polluted `context.errors`.
       signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
 
+      // First parse all the args, potentially coercing to the
+      // types expected by this overload.
+      const parsedArgs = [];
+      let argParseFailed = false;
+      for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        const expectedType = Array.isArray(params) ? params[i - 1] : params.type;
+
+        const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
+        if (!parsed) {
+          argParseFailed = true;
+          break;
+        }
+        parsedArgs.push(parsed);
+      }
+      if (argParseFailed) {
+        // Couldn't coerce args of this overload to expected type, move
+        // on to next one.
+        continue;
+      }
+
       if (Array.isArray(params)) {
         if (params.length !== parsedArgs.length) {
           signatureContext.error(`Expected ${params.length} arguments, but found ${parsedArgs.length} instead.`);
@@ -92,8 +99,15 @@ class CompoundExpression {
     } else {
       const expected = overloads.length ? overloads : availableOverloads;
       const signatures = expected.map(([params]) => stringifySignature(params)).join(' | ');
-      const actualTypes = parsedArgs.map(arg => toString(arg.type)).join(', ');
-      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes}) instead.`);
+      const actualTypes = [];
+      // For error message, re-parse arguments without trying to
+      // apply any coercions
+      for (let i = 1; i < args.length; i++) {
+        const parsed = context.parse(args[i], 1 + actualTypes.length);
+        if (!parsed) return null;
+        actualTypes.push(toString(parsed.type));
+      }
+      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes.join(', ')}) instead.`);
     }
 
     return null;

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

@@ -3,6 +3,7 @@ const assert = require('assert');
 const { ColorType, ValueType, NumberType } = require('../types');
 const { Color, validateRGBA } = require('../values');
 const RuntimeError = require('../runtime_error');
+const { Formatted, FormattedSection } = require('./formatted');
 
 const types = {
   'to-number': NumberType,
@@ -65,6 +66,18 @@ class Coercion {
         error || `Could not parse color from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`
       );
     }
+    if (this.type.kind === 'formatted') {
+      let input;
+      for (const arg of this.args) {
+        input = arg.evaluate(ctx);
+        if (typeof input === 'string') {
+          return new Formatted([new FormattedSection(input, null, null)]);
+        }
+      }
+      throw new RuntimeError(
+        `Could not parse formatted text from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`
+      );
+    }
     let value = null;
     for (const arg of this.args) {
       value = arg.evaluate(ctx);

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

@@ -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;
           }