@mapwhit/tilerenderer 0.47.1

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

@@ -0,0 +1,329 @@
+const assert = require('assert');
+
+const ParsingError = require('./parsing_error');
+const ParsingContext = require('./parsing_context');
+const EvaluationContext = require('./evaluation_context');
+const CompoundExpression = require('./compound_expression');
+const Step = require('./definitions/step');
+const Interpolate = require('./definitions/interpolate');
+const Coalesce = require('./definitions/coalesce');
+const Let = require('./definitions/let');
+const definitions = require('./definitions');
+const isConstant = require('./is_constant');
+const RuntimeError = require('./runtime_error');
+const { success, error } = require('../util/result');
+const { supportsPropertyExpression, supportsZoomExpression, supportsInterpolation } = require('../util/properties');
+
+class StyleExpression {
+  constructor(expression, propertySpec) {
+    this.expression = expression;
+    this._warningHistory = {};
+    this._defaultValue = getDefaultValue(propertySpec);
+    if (propertySpec.type === 'enum') {
+      this._enumValues = propertySpec.values;
+    }
+  }
+
+  evaluateWithoutErrorHandling(globals, feature, featureState) {
+    if (!this._evaluator) {
+      this._evaluator = new EvaluationContext();
+    }
+
+    this._evaluator.globals = globals;
+    this._evaluator.feature = feature;
+    this._evaluator.featureState = featureState;
+
+    return this.expression.evaluate(this._evaluator);
+  }
+
+  evaluate(globals, feature, featureState) {
+    if (!this._evaluator) {
+      this._evaluator = new EvaluationContext();
+    }
+
+    this._evaluator.globals = globals;
+    this._evaluator.feature = feature;
+    this._evaluator.featureState = featureState;
+
+    try {
+      const val = this.expression.evaluate(this._evaluator);
+      if (val === null || val === undefined) {
+        return this._defaultValue;
+      }
+      if (this._enumValues && !this._enumValues.includes(val)) {
+        throw new RuntimeError(
+          `Expected value to be one of ${this._enumValues
+            .map(v => JSON.stringify(v))
+            .join(', ')}, but found ${JSON.stringify(val)} instead.`
+        );
+      }
+      return val;
+    } catch (e) {
+      if (!this._warningHistory[e.message]) {
+        this._warningHistory[e.message] = true;
+        if (typeof console !== 'undefined') {
+          console.warn(e.message);
+        }
+      }
+      return this._defaultValue;
+    }
+  }
+}
+
+function isExpression(expression) {
+  return (
+    Array.isArray(expression) &&
+    expression.length > 0 &&
+    typeof expression[0] === 'string' &&
+    expression[0] in definitions
+  );
+}
+
+/**
+ * Parse and typecheck the given style spec JSON expression.  If
+ * options.defaultValue is provided, then the resulting StyleExpression's
+ * `evaluate()` method will handle errors by logging a warning (once per
+ * message) and returning the default value.  Otherwise, it will throw
+ * evaluation errors.
+ *
+ * @private
+ */
+function createExpression(expression, propertySpec) {
+  const parser = new ParsingContext(definitions, [], getExpectedType(propertySpec));
+  const parsed = parser.parse(expression);
+  if (!parsed) {
+    assert(parser.errors.length > 0);
+    return error(parser.errors);
+  }
+
+  return success(new StyleExpression(parsed, propertySpec));
+}
+
+class ZoomConstantExpression {
+  constructor(kind, expression) {
+    this.kind = kind;
+    this._styleExpression = expression;
+    this.isStateDependent = kind !== 'constant' && !isConstant.isStateConstant(expression.expression);
+  }
+
+  evaluateWithoutErrorHandling(globals, feature, featureState) {
+    return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState);
+  }
+
+  evaluate(globals, feature, featureState) {
+    return this._styleExpression.evaluate(globals, feature, featureState);
+  }
+}
+
+class ZoomDependentExpression {
+  constructor(kind, expression, zoomCurve) {
+    this.kind = kind;
+    this.zoomStops = zoomCurve.labels;
+    this._styleExpression = expression;
+    this.isStateDependent = kind !== 'camera' && !isConstant.isStateConstant(expression.expression);
+    if (zoomCurve instanceof Interpolate) {
+      this._interpolationType = zoomCurve.interpolation;
+    }
+  }
+
+  evaluateWithoutErrorHandling(globals, feature, featureState) {
+    return this._styleExpression.evaluateWithoutErrorHandling(globals, feature, featureState);
+  }
+
+  evaluate(globals, feature, featureState) {
+    return this._styleExpression.evaluate(globals, feature, featureState);
+  }
+
+  interpolationFactor(input, lower, upper) {
+    if (this._interpolationType) {
+      return Interpolate.interpolationFactor(this._interpolationType, input, lower, upper);
+    }
+    return 0;
+  }
+}
+
+function createPropertyExpression(expression, propertySpec) {
+  expression = createExpression(expression, propertySpec);
+  if (expression.result === 'error') {
+    return expression;
+  }
+
+  const parsed = expression.value.expression;
+
+  const isFeatureConstant = isConstant.isFeatureConstant(parsed);
+  if (!isFeatureConstant && !supportsPropertyExpression(propertySpec)) {
+    return error([new ParsingError('', 'data expressions not supported')]);
+  }
+
+  const isZoomConstant = isConstant.isGlobalPropertyConstant(parsed, ['zoom']);
+  if (!isZoomConstant && !supportsZoomExpression(propertySpec)) {
+    return error([new ParsingError('', 'zoom expressions not supported')]);
+  }
+
+  const zoomCurve = findZoomCurve(parsed);
+  if (!zoomCurve && !isZoomConstant) {
+    return error([
+      new ParsingError(
+        '',
+        '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.'
+      )
+    ]);
+  }
+  if (zoomCurve instanceof ParsingError) {
+    return error([zoomCurve]);
+  }
+  if (zoomCurve instanceof Interpolate && !supportsInterpolation(propertySpec)) {
+    return error([new ParsingError('', '"interpolate" expressions cannot be used with this property')]);
+  }
+
+  if (!zoomCurve) {
+    return success(
+      isFeatureConstant
+        ? new ZoomConstantExpression('constant', expression.value)
+        : new ZoomConstantExpression('source', expression.value)
+    );
+  }
+
+  return success(
+    isFeatureConstant
+      ? new ZoomDependentExpression('camera', expression.value, zoomCurve)
+      : new ZoomDependentExpression('composite', expression.value, zoomCurve)
+  );
+}
+
+const { isFunction, createFunction } = require('../function');
+const { Color } = require('./values');
+
+// serialization wrapper for old-style stop functions normalized to the
+// expression interface
+class StylePropertyFunction {
+  constructor(parameters, specification) {
+    this._parameters = parameters;
+    this._specification = specification;
+    Object.assign(this, createFunction(this._parameters, this._specification));
+  }
+
+  static deserialize(serialized) {
+    return new StylePropertyFunction(serialized._parameters, serialized._specification);
+  }
+
+  static serialize(input) {
+    return {
+      _parameters: input._parameters,
+      _specification: input._specification
+    };
+  }
+}
+
+function normalizePropertyExpression(value, specification) {
+  if (isFunction(value)) {
+    return new StylePropertyFunction(value, specification);
+  }
+  if (isExpression(value)) {
+    const expression = createPropertyExpression(value, specification);
+    if (expression.result === 'error') {
+      // this should have been caught in validation
+      throw new Error(expression.value.map(err => `${err.key}: ${err.message}`).join(', '));
+    }
+    return expression.value;
+  }
+  let constant = value;
+  if (typeof value === 'string' && specification.type === 'color') {
+    constant = Color.parse(value);
+  }
+  return {
+    kind: 'constant',
+    evaluate: () => constant
+  };
+}
+
+// Zoom-dependent expressions may only use ["zoom"] as the input to a top-level "step" or "interpolate"
+// expression (collectively referred to as a "curve"). The curve may be wrapped in one or more "let" or
+// "coalesce" expressions.
+function findZoomCurve(expression) {
+  let result = null;
+  if (expression instanceof Let) {
+    result = findZoomCurve(expression.result);
+  } else if (expression instanceof Coalesce) {
+    for (const arg of expression.args) {
+      result = findZoomCurve(arg);
+      if (result) {
+        break;
+      }
+    }
+  } else if (
+    (expression instanceof Step || expression instanceof Interpolate) &&
+    expression.input instanceof CompoundExpression &&
+    expression.input.name === 'zoom'
+  ) {
+    result = expression;
+  }
+
+  if (result instanceof ParsingError) {
+    return result;
+  }
+
+  expression.eachChild(child => {
+    const childResult = findZoomCurve(child);
+    if (childResult instanceof ParsingError) {
+      result = childResult;
+    } else if (!result && childResult) {
+      result = new ParsingError(
+        '',
+        '"zoom" expression may only be used as input to a top-level "step" or "interpolate" expression.'
+      );
+    } else if (result && childResult && result !== childResult) {
+      result = new ParsingError(
+        '',
+        'Only one zoom-based "step" or "interpolate" subexpression may be used in an expression.'
+      );
+    }
+  });
+
+  return result;
+}
+
+const { ColorType, StringType, NumberType, BooleanType, ValueType, array } = require('./types');
+
+function getExpectedType(spec) {
+  const types = {
+    color: ColorType,
+    string: StringType,
+    number: NumberType,
+    enum: StringType,
+    boolean: BooleanType
+  };
+
+  if (spec.type === 'array') {
+    return array(types[spec.value] || ValueType, spec.length);
+  }
+
+  return types[spec.type] || null;
+}
+
+function getDefaultValue(spec) {
+  if (spec.type === 'color' && isFunction(spec.default)) {
+    // Special case for heatmap-color: it uses the 'default:' to define a
+    // default color ramp, but createExpression expects a simple value to fall
+    // back to in case of runtime errors
+    return new Color(0, 0, 0, 0);
+  }
+  if (spec.type === 'color') {
+    return Color.parse(spec.default) || null;
+  }
+  if (spec.default === undefined) {
+    return null;
+  }
+  return spec.default;
+}
+
+module.exports = {
+  StyleExpression,
+  isExpression,
+  createExpression,
+  ZoomConstantExpression,
+  ZoomDependentExpression,
+  createPropertyExpression,
+  StylePropertyFunction,
+  normalizePropertyExpression
+};

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

@@ -0,0 +1,63 @@
+const CompoundExpression = require('./compound_expression');
+
+function isFeatureConstant(e) {
+  if (e instanceof CompoundExpression) {
+    if (e.name === 'get' && e.args.length === 1) {
+      return false;
+    }
+    if (e.name === 'feature-state') {
+      return false;
+    }
+    if (e.name === 'has' && e.args.length === 1) {
+      return false;
+    }
+    if (e.name === 'properties' || e.name === 'geometry-type' || e.name === 'id') {
+      return false;
+    }
+    if (/^filter-/.test(e.name)) {
+      return false;
+    }
+  }
+
+  let result = true;
+  e.eachChild(arg => {
+    if (result && !isFeatureConstant(arg)) {
+      result = false;
+    }
+  });
+  return result;
+}
+
+function isStateConstant(e) {
+  if (e instanceof CompoundExpression) {
+    if (e.name === 'feature-state') {
+      return false;
+    }
+  }
+  let result = true;
+  e.eachChild(arg => {
+    if (result && !isStateConstant(arg)) {
+      result = false;
+    }
+  });
+  return result;
+}
+
+function isGlobalPropertyConstant(e, properties) {
+  if (e instanceof CompoundExpression && properties.indexOf(e.name) >= 0) {
+    return false;
+  }
+  let result = true;
+  e.eachChild(arg => {
+    if (result && !isGlobalPropertyConstant(arg, properties)) {
+      result = false;
+    }
+  });
+  return result;
+}
+
+module.exports = {
+  isFeatureConstant,
+  isGlobalPropertyConstant,
+  isStateConstant
+};

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

@@ -0,0 +1,213 @@
+const Scope = require('./scope');
+
+const { checkSubtype } = require('./types');
+const ParsingError = require('./parsing_error');
+const Literal = require('./definitions/literal');
+const Assertion = require('./definitions/assertion');
+const ArrayAssertion = require('./definitions/array');
+const Coercion = require('./definitions/coercion');
+const EvaluationContext = require('./evaluation_context');
+const { CollatorExpression } = require('./definitions/collator');
+const { isGlobalPropertyConstant, isFeatureConstant } = require('./is_constant');
+const Var = require('./definitions/var');
+
+/**
+ * State associated parsing at a given point in an expression tree.
+ * @private
+ */
+class ParsingContext {
+  // The expected type of this expression. Provided only to allow Expression
+  // implementations to infer argument types: Expression#parse() need not
+  // check that the output type of the parsed expression matches
+  // `expectedType`.
+
+  constructor(registry, path = [], expectedType, scope = new Scope(), errors = []) {
+    this.registry = registry;
+    this.path = path;
+    this.key = path.map(part => `[${part}]`).join('');
+    this.scope = scope;
+    this.errors = errors;
+    this.expectedType = expectedType;
+  }
+
+  /**
+   * @param expr the JSON expression to parse
+   * @param index the optional argument index if this expression is an argument of a parent expression that's being parsed
+   * @param options
+   * @param options.omitTypeAnnotations set true to omit inferred type annotations.  Caller beware: with this option set, the parsed expression's type will NOT satisfy `expectedType` if it would normally be wrapped in an inferred annotation.
+   * @private
+   */
+  parse(expr, index, expectedType, bindings, options = {}) {
+    if (index) {
+      return this.concat(index, expectedType, bindings)._parse(expr, options);
+    }
+    return this._parse(expr, options);
+  }
+
+  _parse(expr, options) {
+    if (expr === null || typeof expr === 'string' || typeof expr === 'boolean' || typeof expr === 'number') {
+      expr = ['literal', expr];
+    }
+
+    if (Array.isArray(expr)) {
+      if (expr.length === 0) {
+        return this.error(
+          `Expected an array with at least one element. If you wanted a literal array, use ["literal", []].`
+        );
+      }
+
+      const op = expr[0];
+      if (typeof op !== 'string') {
+        this.error(
+          `Expression name must be a string, but found ${typeof op} instead. If you wanted a literal array, use ["literal", [...]].`,
+          0
+        );
+        return null;
+      }
+
+      const Expr = this.registry[op];
+      if (Expr) {
+        let parsed = Expr.parse(expr, this);
+        if (!parsed) return null;
+
+        if (this.expectedType) {
+          const expected = this.expectedType;
+          const actual = parsed.type;
+
+          // When we expect a number, string, boolean, or array but
+          // have a Value, we can wrap it in a refining assertion.
+          // When we expect a Color but have a String or Value, we
+          // can wrap it in "to-color" coercion.
+          // Otherwise, we do static type-checking.
+          if (
+            (expected.kind === 'string' ||
+              expected.kind === 'number' ||
+              expected.kind === 'boolean' ||
+              expected.kind === 'object') &&
+            actual.kind === 'value'
+          ) {
+            if (!options.omitTypeAnnotations) {
+              parsed = new Assertion(expected, [parsed]);
+            }
+          } else if (expected.kind === 'array' && actual.kind === 'value') {
+            if (!options.omitTypeAnnotations) {
+              parsed = new ArrayAssertion(expected, parsed);
+            }
+          } else if (expected.kind === 'color' && (actual.kind === 'value' || actual.kind === 'string')) {
+            if (!options.omitTypeAnnotations) {
+              parsed = new Coercion(expected, [parsed]);
+            }
+          } else if (this.checkSubtype(this.expectedType, parsed.type)) {
+            return null;
+          }
+        }
+
+        // If an expression's arguments are all literals, we can evaluate
+        // it immediately and replace it with a literal value in the
+        // parsed/compiled result.
+        if (!(parsed instanceof Literal) && isConstant(parsed)) {
+          const ec = new EvaluationContext();
+          try {
+            parsed = new Literal(parsed.type, parsed.evaluate(ec));
+          } catch (e) {
+            this.error(e.message);
+            return null;
+          }
+        }
+
+        return parsed;
+      }
+
+      return this.error(`Unknown expression "${op}". If you wanted a literal array, use ["literal", [...]].`, 0);
+    }
+    if (typeof expr === 'undefined') {
+      return this.error(`'undefined' value invalid. Use null instead.`);
+    }
+    if (typeof expr === 'object') {
+      return this.error(`Bare objects invalid. Use ["literal", {...}] instead.`);
+    }
+    return this.error(`Expected an array, but found ${typeof expr} instead.`);
+  }
+
+  /**
+   * Returns a copy of this context suitable for parsing the subexpression at
+   * index `index`, optionally appending to 'let' binding map.
+   *
+   * Note that `errors` property, intended for collecting errors while
+   * parsing, is copied by reference rather than cloned.
+   * @private
+   */
+  concat(index, expectedType, bindings) {
+    const path = typeof index === 'number' ? this.path.concat(index) : this.path;
+    const scope = bindings ? this.scope.concat(bindings) : this.scope;
+    return new ParsingContext(this.registry, path, expectedType || null, scope, this.errors);
+  }
+
+  /**
+   * Push a parsing (or type checking) error into the `this.errors`
+   * @param error The message
+   * @param keys Optionally specify the source of the error at a child
+   * of the current expression at `this.key`.
+   * @private
+   */
+  error(error, ...keys) {
+    const key = `${this.key}${keys.map(k => `[${k}]`).join('')}`;
+    this.errors.push(new ParsingError(key, error));
+  }
+
+  /**
+   * Returns null if `t` is a subtype of `expected`; otherwise returns an
+   * error message and also pushes it to `this.errors`.
+   */
+  checkSubtype(expected, t) {
+    const error = checkSubtype(expected, t);
+    if (error) this.error(error);
+    return error;
+  }
+}
+
+module.exports = ParsingContext;
+
+function isConstant(expression) {
+  const CompoundExpression = require('./compound_expression');
+
+  if (expression instanceof Var) {
+    return isConstant(expression.boundExpression);
+  }
+  if (expression instanceof CompoundExpression && expression.name === 'error') {
+    return false;
+  }
+  if (expression instanceof CollatorExpression) {
+    // Although the results of a Collator expression with fixed arguments
+    // generally shouldn't change between executions, we can't serialize them
+    // as constant expressions because results change based on environment.
+    return false;
+  }
+
+  const isTypeAnnotation =
+    expression instanceof Coercion || expression instanceof Assertion || expression instanceof ArrayAssertion;
+
+  let childrenConstant = true;
+  expression.eachChild(child => {
+    // We can _almost_ assume that if `expressions` children are constant,
+    // they would already have been evaluated to Literal values when they
+    // were parsed.  Type annotations are the exception, because they might
+    // have been inferred and added after a child was parsed.
+
+    // So we recurse into isConstant() for the children of type annotations,
+    // but otherwise simply check whether they are Literals.
+    if (isTypeAnnotation) {
+      childrenConstant = childrenConstant && isConstant(child);
+    } else {
+      childrenConstant = childrenConstant && child instanceof Literal;
+    }
+  });
+  if (!childrenConstant) {
+    return false;
+  }
+
+  return (
+    isFeatureConstant(expression) &&
+    isGlobalPropertyConstant(expression, ['zoom', 'heatmap-density', 'line-progress', 'is-supported-script'])
+  );
+}

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

@@ -0,0 +1,9 @@
+class ParsingError extends Error {
+  constructor(key, message) {
+    super(message);
+    this.message = message;
+    this.key = key;
+  }
+}
+
+module.exports = ParsingError;

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

@@ -0,0 +1,12 @@
+class RuntimeError {
+  constructor(message) {
+    this.name = 'ExpressionEvaluationError';
+    this.message = message;
+  }
+
+  toJSON() {
+    return this.message;
+  }
+}
+
+module.exports = RuntimeError;

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

@@ -0,0 +1,34 @@
+/**
+ * Tracks `let` bindings during expression parsing.
+ * @private
+ */
+class Scope {
+  constructor(parent, bindings = []) {
+    this.parent = parent;
+    this.bindings = {};
+    for (const [name, expression] of bindings) {
+      this.bindings[name] = expression;
+    }
+  }
+
+  concat(bindings) {
+    return new Scope(this, bindings);
+  }
+
+  get(name) {
+    if (this.bindings[name]) {
+      return this.bindings[name];
+    }
+    if (this.parent) {
+      return this.parent.get(name);
+    }
+    throw new Error(`${name} not found in scope.`);
+  }
+
+  has(name) {
+    if (this.bindings[name]) return true;
+    return this.parent ? this.parent.has(name) : false;
+  }
+}
+
+module.exports = Scope;

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

@@ -0,0 +1,37 @@
+const RuntimeError = require('./runtime_error');
+
+/**
+ * Returns the index of the last stop <= input, or 0 if it doesn't exist.
+ * @private
+ */
+function findStopLessThanOrEqualTo(stops, input) {
+  const n = stops.length;
+  let lowerIndex = 0;
+  let upperIndex = n - 1;
+  let currentIndex = 0;
+  let currentValue;
+  let upperValue;
+
+  while (lowerIndex <= upperIndex) {
+    currentIndex = Math.floor((lowerIndex + upperIndex) / 2);
+    currentValue = stops[currentIndex];
+    upperValue = stops[currentIndex + 1];
+    if (input === currentValue || (input > currentValue && input < upperValue)) {
+      // Search complete
+      return currentIndex;
+    }
+    if (currentValue < input) {
+      lowerIndex = currentIndex + 1;
+    } else if (currentValue > input) {
+      upperIndex = currentIndex - 1;
+    } else {
+      throw new RuntimeError('Input is not a number.');
+    }
+  }
+
+  return Math.max(currentIndex - 1, 0);
+}
+
+module.exports = {
+  findStopLessThanOrEqualTo
+};