@mapwhit/tilerenderer 0.50.0 → 0.51.1

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

@@ -1,330 +0,0 @@
-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._evaluator = new EvaluationContext();
-    this._defaultValue = getDefaultValue(propertySpec);
-    this._enumValues = propertySpec.type === 'enum' ? propertySpec.values : null;
-  }
-
-  evaluateWithoutErrorHandling(globals, feature, featureState) {
-    this._evaluator.globals = globals;
-    this._evaluator.feature = feature;
-    this._evaluator.featureState = featureState;
-
-    return this.expression.evaluate(this._evaluator);
-  }
-
-  evaluate(globals, feature, featureState) {
-    this._evaluator.globals = globals;
-    this._evaluator.feature = feature || null;
-    this._evaluator.featureState = featureState || null;
-
-    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));
-
-  // For string-valued properties, coerce to string at the top level rather than asserting.
-  const parsed = parser.parse(
-    expression,
-    undefined,
-    undefined,
-    undefined,
-    propertySpec.type === 'string' ? { typeAnnotation: 'coerce' } : undefined
-  );
-
-  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, FormattedType, array } = require('./types');
-
-function getExpectedType(spec) {
-  const types = {
-    color: ColorType,
-    string: StringType,
-    number: NumberType,
-    enum: StringType,
-    boolean: BooleanType,
-    formatted: FormattedType
-  };
-
-  if (spec.type === 'array') {
-    return array(types[spec.value] || ValueType, spec.length);
-  }
-
-  return types[spec.type];
-}
-
-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

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

@@ -1,221 +0,0 @@
-const assert = require('assert');
-const Scope = require('./scope');
-
-const { checkSubtype } = require('./types');
-const ParsingError = require('./parsing_error');
-const Literal = require('./definitions/literal');
-const Assertion = require('./definitions/assertion');
-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];
-    }
-
-    function annotate(parsed, type, typeAnnotation) {
-      if (typeAnnotation === 'assert') {
-        return new Assertion(type, [parsed]);
-      }
-      if (typeAnnotation === 'coerce') {
-        return new Coercion(type, [parsed]);
-      }
-      return parsed;
-    }
-
-    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, wrap it in an assertion.
-          // When we expect a color or formatted string, but have a string or value, wrap it in a coercion.
-          // Otherwise, we do static type-checking.
-          //
-          // These behaviors are overridable for:
-          //   * The "coalesce" operator, which needs to omit type annotations.
-          //   * String-valued properties (e.g. `text-field`), where coercion is more convenient than assertion.
-          //
-          if (
-            (expected.kind === 'string' ||
-              expected.kind === 'number' ||
-              expected.kind === 'boolean' ||
-              expected.kind === 'object' ||
-              expected.kind === 'array') &&
-            actual.kind === 'value'
-          ) {
-            parsed = annotate(parsed, expected, options.typeAnnotation || 'assert');
-          } else if (
-            (expected.kind === 'color' || expected.kind === 'formatted') &&
-            (actual.kind === 'value' || actual.kind === 'string')
-          ) {
-            parsed = annotate(parsed, expected, options.typeAnnotation || 'coerce');
-          } else if (this.checkSubtype(expected, actual)) {
-            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;
-
-  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

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

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

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

@@ -1,34 +0,0 @@
-/**
- * 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;