@mapwhit/tilerenderer 0.47.1

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

@@ -0,0 +1,73 @@
+const assert = require('assert');
+
+const { BooleanType } = require('../types');
+
+class Case {
+  constructor(type, branches, otherwise) {
+    this.type = type;
+    this.branches = branches;
+    this.otherwise = otherwise;
+  }
+
+  static parse(args, context) {
+    if (args.length < 4) return context.error(`Expected at least 3 arguments, but found only ${args.length - 1}.`);
+    if (args.length % 2 !== 0) return context.error('Expected an odd number of arguments.');
+
+    let outputType;
+    if (context.expectedType && context.expectedType.kind !== 'value') {
+      outputType = context.expectedType;
+    }
+
+    const branches = [];
+    for (let i = 1; i < args.length - 1; i += 2) {
+      const test = context.parse(args[i], i, BooleanType);
+      if (!test) return null;
+
+      const result = context.parse(args[i + 1], i + 1, outputType);
+      if (!result) return null;
+
+      branches.push([test, result]);
+
+      outputType = outputType || result.type;
+    }
+
+    const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
+    if (!otherwise) return null;
+
+    assert(outputType);
+    return new Case(outputType, branches, otherwise);
+  }
+
+  evaluate(ctx) {
+    for (const [test, expression] of this.branches) {
+      if (test.evaluate(ctx)) {
+        return expression.evaluate(ctx);
+      }
+    }
+    return this.otherwise.evaluate(ctx);
+  }
+
+  eachChild(fn) {
+    for (const [test, expression] of this.branches) {
+      fn(test);
+      fn(expression);
+    }
+    fn(this.otherwise);
+  }
+
+  possibleOutputs() {
+    return []
+      .concat(...this.branches.map(branch => branch[1].possibleOutputs()))
+      .concat(this.otherwise.possibleOutputs());
+  }
+
+  serialize() {
+    const serialized = ['case'];
+    this.eachChild(child => {
+      serialized.push(child.serialize());
+    });
+    return serialized;
+  }
+}
+
+module.exports = Case;

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

@@ -0,0 +1,68 @@
+const assert = require('assert');
+
+const { checkSubtype, ValueType } = require('../types');
+
+class Coalesce {
+  constructor(type, args) {
+    this.type = type;
+    this.args = args;
+  }
+
+  static parse(args, context) {
+    if (args.length < 2) {
+      return context.error('Expectected at least one argument.');
+    }
+    let outputType = null;
+    const expectedType = context.expectedType;
+    if (expectedType && expectedType.kind !== 'value') {
+      outputType = expectedType;
+    }
+    const parsedArgs = [];
+
+    for (const arg of args.slice(1)) {
+      const parsed = context.parse(arg, 1 + parsedArgs.length, outputType, undefined, {
+        omitTypeAnnotations: true
+      });
+      if (!parsed) return null;
+      outputType = outputType || parsed.type;
+      parsedArgs.push(parsed);
+    }
+    assert(outputType);
+
+    // Above, we parse arguments without inferred type annotation so that
+    // they don't produce a runtime error for `null` input, which would
+    // preempt the desired null-coalescing behavior.
+    // Thus, if any of our arguments would have needed an annotation, we
+    // need to wrap the enclosing coalesce expression with it instead.
+    const needsAnnotation = expectedType && parsedArgs.some(arg => checkSubtype(expectedType, arg.type));
+
+    return needsAnnotation ? new Coalesce(ValueType, parsedArgs) : new Coalesce(outputType, parsedArgs);
+  }
+
+  evaluate(ctx) {
+    let result = null;
+    for (const arg of this.args) {
+      result = arg.evaluate(ctx);
+      if (result !== null) break;
+    }
+    return result;
+  }
+
+  eachChild(fn) {
+    this.args.forEach(fn);
+  }
+
+  possibleOutputs() {
+    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
+  }
+
+  serialize() {
+    const serialized = ['coalesce'];
+    this.eachChild(child => {
+      serialized.push(child.serialize());
+    });
+    return serialized;
+  }
+}
+
+module.exports = Coalesce;

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

@@ -0,0 +1,96 @@
+const assert = require('assert');
+
+const { ColorType, ValueType, NumberType } = require('../types');
+const { Color, validateRGBA } = require('../values');
+const RuntimeError = require('../runtime_error');
+
+const types = {
+  'to-number': NumberType,
+  'to-color': ColorType
+};
+
+/**
+ * Special form for error-coalescing coercion expressions "to-number",
+ * "to-color".  Since these coercions can fail at runtime, they accept multiple
+ * arguments, only evaluating one at a time until one succeeds.
+ *
+ * @private
+ */
+class Coercion {
+  constructor(type, args) {
+    this.type = type;
+    this.args = args;
+  }
+
+  static parse(args, context) {
+    if (args.length < 2) return context.error('Expected at least one argument.');
+
+    const name = args[0];
+    assert(types[name], name);
+
+    const type = types[name];
+
+    const parsed = [];
+    for (let i = 1; i < args.length; i++) {
+      const input = context.parse(args[i], i, ValueType);
+      if (!input) return null;
+      parsed.push(input);
+    }
+
+    return new Coercion(type, parsed);
+  }
+
+  evaluate(ctx) {
+    if (this.type.kind === 'color') {
+      let input;
+      let error;
+      for (const arg of this.args) {
+        input = arg.evaluate(ctx);
+        error = null;
+        if (typeof input === 'string') {
+          const c = ctx.parseColor(input);
+          if (c) return c;
+        } else if (Array.isArray(input)) {
+          if (input.length < 3 || input.length > 4) {
+            error = `Invalid rbga value ${JSON.stringify(input)}: expected an array containing either three or four numeric values.`;
+          } else {
+            error = validateRGBA(input[0], input[1], input[2], input[3]);
+          }
+          if (!error) {
+            return new Color(input[0] / 255, input[1] / 255, input[2] / 255, input[3]);
+          }
+        }
+      }
+      throw new RuntimeError(
+        error || `Could not parse color from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`
+      );
+    }
+    let value = null;
+    for (const arg of this.args) {
+      value = arg.evaluate(ctx);
+      if (value === null) continue;
+      const num = Number(value);
+      if (isNaN(num)) continue;
+      return num;
+    }
+    throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
+  }
+
+  eachChild(fn) {
+    this.args.forEach(fn);
+  }
+
+  possibleOutputs() {
+    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
+  }
+
+  serialize() {
+    const serialized = [`to-${this.type.kind}`];
+    this.eachChild(child => {
+      serialized.push(child.serialize());
+    });
+    return serialized;
+  }
+}
+
+module.exports = Coercion;

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

@@ -0,0 +1,102 @@
+const { StringType, BooleanType, CollatorType } = require('../types');
+
+class Collator {
+  constructor(caseSensitive, diacriticSensitive, locale) {
+    if (caseSensitive) this.sensitivity = diacriticSensitive ? 'variant' : 'case';
+    else this.sensitivity = diacriticSensitive ? 'accent' : 'base';
+
+    this.locale = locale;
+    this.collator = new Intl.Collator(this.locale ? this.locale : [], {
+      sensitivity: this.sensitivity,
+      usage: 'search'
+    });
+  }
+
+  compare(lhs, rhs) {
+    return this.collator.compare(lhs, rhs);
+  }
+
+  resolvedLocale() {
+    // We create a Collator without "usage: search" because we don't want
+    // the search options encoded in our result (e.g. "en-u-co-search")
+    return new Intl.Collator(this.locale ? this.locale : []).resolvedOptions().locale;
+  }
+}
+
+class CollatorExpression {
+  constructor(caseSensitive, diacriticSensitive, locale) {
+    this.type = CollatorType;
+    this.locale = locale;
+    this.caseSensitive = caseSensitive;
+    this.diacriticSensitive = diacriticSensitive;
+  }
+
+  static parse(args, context) {
+    if (args.length !== 2) return context.error('Expected one argument.');
+
+    const options = args[1];
+    if (typeof options !== 'object' || Array.isArray(options))
+      return context.error('Collator options argument must be an object.');
+
+    const caseSensitive = context.parse(
+      options['case-sensitive'] === undefined ? false : options['case-sensitive'],
+      1,
+      BooleanType
+    );
+    if (!caseSensitive) return null;
+
+    const diacriticSensitive = context.parse(
+      options['diacritic-sensitive'] === undefined ? false : options['diacritic-sensitive'],
+      1,
+      BooleanType
+    );
+    if (!diacriticSensitive) return null;
+
+    let locale = null;
+    if (options['locale']) {
+      locale = context.parse(options['locale'], 1, StringType);
+      if (!locale) return null;
+    }
+
+    return new CollatorExpression(caseSensitive, diacriticSensitive, locale);
+  }
+
+  evaluate(ctx) {
+    return new Collator(
+      this.caseSensitive.evaluate(ctx),
+      this.diacriticSensitive.evaluate(ctx),
+      this.locale ? this.locale.evaluate(ctx) : null
+    );
+  }
+
+  eachChild(fn) {
+    fn(this.caseSensitive);
+    fn(this.diacriticSensitive);
+    if (this.locale) {
+      fn(this.locale);
+    }
+  }
+
+  possibleOutputs() {
+    // Technically the set of possible outputs is the combinatoric set of Collators produced
+    // by all possibleOutputs 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];
+  }
+
+  serialize() {
+    const options = {};
+    options['case-sensitive'] = this.caseSensitive.serialize();
+    options['diacritic-sensitive'] = this.diacriticSensitive.serialize();
+    if (this.locale) {
+      options['locale'] = this.locale.serialize();
+    }
+    return ['collator', options];
+  }
+}
+
+module.exports = {
+  Collator,
+  CollatorExpression
+};

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

@@ -0,0 +1,93 @@
+const { toString, ValueType, BooleanType, CollatorType } = require('../types');
+
+function isComparableType(type) {
+  return type.kind === 'string' || type.kind === 'number' || type.kind === 'boolean' || type.kind === 'null';
+}
+
+/**
+ * Special form for ==, !=, implementing the following signatures:
+ * - (T1: Comparable, T2: Comparable) => boolean { T1 == T2 }
+ * - (Comparable, value) => boolean
+ * - (value, Comparable) => boolean
+ *
+ * Where Comparable = string | number | boolean | null.
+ *
+ * Evaluation semantics for the value cases are equivalent to Javascript's
+ * strict equality (===/!==) -- i.e., when the value argument's type doesn't
+ * match that of the Comparable argument, == evaluates to false, != to true.
+ *
+ * @private
+ */
+function makeComparison(op, negate) {
+  return class Comparison {
+    constructor(lhs, rhs, collator) {
+      this.type = BooleanType;
+      this.lhs = lhs;
+      this.rhs = rhs;
+      this.collator = collator;
+    }
+
+    static parse(args, context) {
+      if (args.length !== 3 && args.length !== 4) return context.error('Expected two or three arguments.');
+
+      const lhs = context.parse(args[1], 1, ValueType);
+      if (!lhs) return null;
+      const rhs = context.parse(args[2], 2, ValueType);
+      if (!rhs) return null;
+
+      if (!isComparableType(lhs.type) && !isComparableType(rhs.type)) {
+        return context.error(
+          `Expected at least one argument to be a string, number, boolean, or null, but found (${toString(lhs.type)}, ${toString(rhs.type)}) instead.`
+        );
+      }
+
+      if (lhs.type.kind !== rhs.type.kind && lhs.type.kind !== 'value' && rhs.type.kind !== 'value') {
+        return context.error(`Cannot compare ${toString(lhs.type)} and ${toString(rhs.type)}.`);
+      }
+
+      let collator = null;
+      if (args.length === 4) {
+        if (lhs.type.kind !== 'string' && rhs.type.kind !== 'string') {
+          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 equal = this.collator
+        ? this.collator.evaluate(ctx).compare(this.lhs.evaluate(ctx), this.rhs.evaluate(ctx)) === 0
+        : this.lhs.evaluate(ctx) === this.rhs.evaluate(ctx);
+
+      return negate ? !equal : equal;
+    }
+
+    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('==', false),
+  NotEquals: makeComparison('!=', true)
+};