@mapwhit/tilerenderer 0.50.0 → 0.51.0

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

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

@@ -1,97 +0,0 @@
-const { NumberType, ValueType, FormattedType, array, StringType } = require('../types');
-const { Formatted, FormattedSection } = require('../types/formatted');
-const { toString } = require('../values');
-
-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(
-            toString(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 };