@mapwhit/tilerenderer 0.50.0 → 0.51.1

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

@@ -1,116 +0,0 @@
-const assert = require('assert');
-
-const {
-  ObjectType,
-  ValueType,
-  StringType,
-  NumberType,
-  BooleanType,
-  checkSubtype,
-  toString,
-  array
-} = require('../types');
-const RuntimeError = require('../runtime_error');
-const { typeOf } = require('../values');
-
-const types = {
-  string: StringType,
-  number: NumberType,
-  boolean: BooleanType,
-  object: ObjectType
-};
-
-class Assertion {
-  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.');
-
-    let i = 1;
-    let type;
-
-    const name = args[0];
-    if (name === 'array') {
-      let itemType;
-      if (args.length > 2) {
-        const type = args[1];
-        if (typeof type !== 'string' || !(type in types) || type === 'object')
-          return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
-        itemType = types[type];
-        i++;
-      } else {
-        itemType = ValueType;
-      }
-
-      let N;
-      if (args.length > 3) {
-        if (args[2] !== null && (typeof args[2] !== 'number' || args[2] < 0 || args[2] !== Math.floor(args[2]))) {
-          return context.error('The length argument to "array" must be a positive integer literal', 2);
-        }
-        N = args[2];
-        i++;
-      }
-
-      type = array(itemType, N);
-    } else {
-      assert(types[name], name);
-      type = types[name];
-    }
-
-    const parsed = [];
-    for (; i < args.length; i++) {
-      const input = context.parse(args[i], i, ValueType);
-      if (!input) return null;
-      parsed.push(input);
-    }
-
-    return new Assertion(type, parsed);
-  }
-
-  evaluate(ctx) {
-    for (let i = 0; i < this.args.length; i++) {
-      const value = this.args[i].evaluate(ctx);
-      const error = checkSubtype(this.type, typeOf(value));
-      if (!error) {
-        return value;
-      }
-      if (i === this.args.length - 1) {
-        throw new RuntimeError(
-          `Expected value to be of type ${toString(this.type)}, but found ${toString(typeOf(value))} instead.`
-        );
-      }
-    }
-
-    assert(false);
-    return null;
-  }
-
-  eachChild(fn) {
-    this.args.forEach(fn);
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
-  }
-
-  serialize() {
-    const type = this.type;
-    const serialized = [type.kind];
-    if (type.kind === 'array') {
-      const itemType = type.itemType;
-      if (itemType.kind === 'string' || itemType.kind === 'number' || itemType.kind === 'boolean') {
-        serialized.push(itemType.kind);
-        const N = type.N;
-        if (typeof N === 'number' || this.args.length > 1) {
-          serialized.push(N);
-        }
-      }
-    }
-    return serialized.concat(this.args.map(arg => arg.serialize()));
-  }
-}
-
-module.exports = Assertion;

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

@@ -1,57 +0,0 @@
-const { array, ValueType, NumberType } = require('../types');
-
-const RuntimeError = require('../runtime_error');
-
-class At {
-  constructor(type, index, input) {
-    this.type = type;
-    this.index = index;
-    this.input = input;
-  }
-
-  static parse(args, context) {
-    if (args.length !== 3) return context.error(`Expected 2 arguments, but found ${args.length - 1} instead.`);
-
-    const index = context.parse(args[1], 1, NumberType);
-    const input = context.parse(args[2], 2, array(context.expectedType || ValueType));
-
-    if (!index || !input) return null;
-
-    const t = input.type;
-    return new At(t.itemType, index, input);
-  }
-
-  evaluate(ctx) {
-    const index = this.index.evaluate(ctx);
-    const array = this.input.evaluate(ctx);
-
-    if (index < 0) {
-      throw new RuntimeError(`Array index out of bounds: ${index} < 0.`);
-    }
-
-    if (index >= array.length) {
-      throw new RuntimeError(`Array index out of bounds: ${index} > ${array.length - 1}.`);
-    }
-
-    if (index !== Math.floor(index)) {
-      throw new RuntimeError(`Array index must be an integer, but found ${index} instead.`);
-    }
-
-    return array[index];
-  }
-
-  eachChild(fn) {
-    fn(this.index);
-    fn(this.input);
-  }
-
-  possibleOutputs() {
-    return [undefined];
-  }
-
-  serialize() {
-    return ['at', this.index.serialize(), this.input.serialize()];
-  }
-}
-
-module.exports = At;

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

@@ -1,73 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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, { typeAnnotation: 'omit' });
-      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

@@ -1,120 +0,0 @@
-const assert = require('assert');
-
-const { BooleanType, ColorType, NumberType, StringType, ValueType } = require('../types');
-const { Color, toString: valueToString, validateRGBA } = require('../values');
-const RuntimeError = require('../runtime_error');
-const { FormatExpression } = require('../definitions/format');
-const { Formatted } = require('../types/formatted');
-
-const types = {
-  'to-boolean': BooleanType,
-  'to-color': ColorType,
-  'to-number': NumberType,
-  'to-string': StringType
-};
-
-/**
- * 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);
-
-    if ((name === 'to-boolean' || name === 'to-string') && args.length !== 2)
-      return context.error('Expected one argument.');
-
-    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 === 'boolean') {
-      return Boolean(this.args[0].evaluate(ctx));
-    }
-    if (this.type.kind === 'color') {
-      let input;
-      let error;
-      for (const arg of this.args) {
-        input = arg.evaluate(ctx);
-        error = null;
-        if (input instanceof Color) {
-          return input;
-        }
-        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)}'`
-      );
-    }
-    if (this.type.kind === 'number') {
-      let value = null;
-      for (const arg of this.args) {
-        value = arg.evaluate(ctx);
-        if (value === null) return 0;
-        const num = Number(value);
-        if (isNaN(num)) continue;
-        return num;
-      }
-      throw new RuntimeError(`Could not convert ${JSON.stringify(value)} to number.`);
-    }
-    if (this.type.kind === 'formatted') {
-      // There is no explicit 'to-formatted' but this coercion can be implicitly
-      // created by properties that expect the 'formatted' type.
-      return Formatted.fromString(valueToString(this.args[0].evaluate(ctx)));
-    }
-    return valueToString(this.args[0].evaluate(ctx));
-  }
-
-  eachChild(fn) {
-    this.args.forEach(fn);
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.args.map(arg => arg.possibleOutputs()));
-  }
-
-  serialize() {
-    if (this.type.kind === 'formatted') {
-      return new FormatExpression([{ text: this.args[0], scale: null, font: null }]).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

@@ -1,80 +0,0 @@
-const { StringType, BooleanType, CollatorType } = require('../types');
-const { Collator } = require('../types/collator');
-
-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/comparison.js

@@ -1,193 +0,0 @@
-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)
-};