@mapwhit/tilerenderer 0.49.0 → 0.51.0

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,68 +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, {
-        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

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

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