@mapwhit/tilerenderer 0.49.0 → 0.51.0

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

@@ -1,245 +0,0 @@
-const UnitBezier = require('@mapbox/unitbezier');
-
-const interpolate = require('../../util/interpolate');
-const { toString, ColorType, NumberType } = require('../types');
-const { findStopLessThanOrEqualTo } = require('../stops');
-const { hcl, lab } = require('../../util/color_spaces');
-
-class Interpolate {
-  constructor(type, operator, interpolation, input, stops) {
-    this.type = type;
-    this.operator = operator;
-    this.interpolation = interpolation;
-    this.input = input;
-
-    this.labels = [];
-    this.outputs = [];
-    for (const [label, expression] of stops) {
-      this.labels.push(label);
-      this.outputs.push(expression);
-    }
-  }
-
-  static interpolationFactor(interpolation, input, lower, upper) {
-    let t = 0;
-    if (interpolation.name === 'exponential') {
-      t = exponentialInterpolation(input, interpolation.base, lower, upper);
-    } else if (interpolation.name === 'linear') {
-      t = exponentialInterpolation(input, 1, lower, upper);
-    } else if (interpolation.name === 'cubic-bezier') {
-      const c = interpolation.controlPoints;
-      const ub = new UnitBezier(c[0], c[1], c[2], c[3]);
-      t = ub.solve(exponentialInterpolation(input, 1, lower, upper));
-    }
-    return t;
-  }
-
-  static parse(args, context) {
-    let [operator, interpolation, input, ...rest] = args;
-
-    if (!Array.isArray(interpolation) || interpolation.length === 0) {
-      return context.error('Expected an interpolation type expression.', 1);
-    }
-
-    if (interpolation[0] === 'linear') {
-      interpolation = { name: 'linear' };
-    } else if (interpolation[0] === 'exponential') {
-      const base = interpolation[1];
-      if (typeof base !== 'number') return context.error('Exponential interpolation requires a numeric base.', 1, 1);
-      interpolation = {
-        name: 'exponential',
-        base
-      };
-    } else if (interpolation[0] === 'cubic-bezier') {
-      const controlPoints = interpolation.slice(1);
-      if (controlPoints.length !== 4 || controlPoints.some(t => typeof t !== 'number' || t < 0 || t > 1)) {
-        return context.error(
-          'Cubic bezier interpolation requires four numeric arguments with values between 0 and 1.',
-          1
-        );
-      }
-
-      interpolation = {
-        name: 'cubic-bezier',
-        controlPoints: controlPoints
-      };
-    } else {
-      return context.error(`Unknown interpolation type ${String(interpolation[0])}`, 1, 0);
-    }
-
-    if (args.length - 1 < 4) {
-      return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-    }
-
-    if ((args.length - 1) % 2 !== 0) {
-      return context.error('Expected an even number of arguments.');
-    }
-
-    input = context.parse(input, 2, NumberType);
-    if (!input) return null;
-
-    const stops = [];
-
-    let outputType = null;
-    if (operator === 'interpolate-hcl' || operator === 'interpolate-lab') {
-      outputType = ColorType;
-    } else if (context.expectedType && context.expectedType.kind !== 'value') {
-      outputType = context.expectedType;
-    }
-
-    for (let i = 0; i < rest.length; i += 2) {
-      const label = rest[i];
-      const value = rest[i + 1];
-
-      const labelKey = i + 3;
-      const valueKey = i + 4;
-
-      if (typeof label !== 'number') {
-        return context.error(
-          'Input/output pairs for "interpolate" expressions must be defined using literal numeric values (not computed expressions) for the input values.',
-          labelKey
-        );
-      }
-
-      if (stops.length && stops[stops.length - 1][0] >= label) {
-        return context.error(
-          'Input/output pairs for "interpolate" expressions must be arranged with input values in strictly ascending order.',
-          labelKey
-        );
-      }
-
-      const parsed = context.parse(value, valueKey, outputType);
-      if (!parsed) return null;
-      outputType = outputType || parsed.type;
-      stops.push([label, parsed]);
-    }
-
-    if (
-      outputType.kind !== 'number' &&
-      outputType.kind !== 'color' &&
-      !(outputType.kind === 'array' && outputType.itemType.kind === 'number' && typeof outputType.N === 'number')
-    ) {
-      return context.error(`Type ${toString(outputType)} is not interpolatable.`);
-    }
-
-    return new Interpolate(outputType, operator, interpolation, input, stops);
-  }
-
-  evaluate(ctx) {
-    const labels = this.labels;
-    const outputs = this.outputs;
-
-    if (labels.length === 1) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const value = this.input.evaluate(ctx);
-    if (value <= labels[0]) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const stopCount = labels.length;
-    if (value >= labels[stopCount - 1]) {
-      return outputs[stopCount - 1].evaluate(ctx);
-    }
-
-    const index = findStopLessThanOrEqualTo(labels, value);
-    const lower = labels[index];
-    const upper = labels[index + 1];
-    const t = Interpolate.interpolationFactor(this.interpolation, value, lower, upper);
-
-    const outputLower = outputs[index].evaluate(ctx);
-    const outputUpper = outputs[index + 1].evaluate(ctx);
-
-    if (this.operator === 'interpolate') {
-      return interpolate[this.type.kind.toLowerCase()](outputLower, outputUpper, t);
-    }
-    if (this.operator === 'interpolate-hcl') {
-      return hcl.reverse(hcl.interpolate(hcl.forward(outputLower), hcl.forward(outputUpper), t));
-    }
-    return lab.reverse(lab.interpolate(lab.forward(outputLower), lab.forward(outputUpper), t));
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-    for (const expression of this.outputs) {
-      fn(expression);
-    }
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.outputs.map(output => output.possibleOutputs()));
-  }
-
-  serialize() {
-    let interpolation;
-    if (this.interpolation.name === 'linear') {
-      interpolation = ['linear'];
-    } else if (this.interpolation.name === 'exponential') {
-      if (this.interpolation.base === 1) {
-        interpolation = ['linear'];
-      } else {
-        interpolation = ['exponential', this.interpolation.base];
-      }
-    } else {
-      interpolation = ['cubic-bezier'].concat(this.interpolation.controlPoints);
-    }
-
-    const serialized = [this.operator, interpolation, this.input.serialize()];
-
-    for (let i = 0; i < this.labels.length; i++) {
-      serialized.push(this.labels[i], this.outputs[i].serialize());
-    }
-    return serialized;
-  }
-}
-
-/**
- * Returns a ratio that can be used to interpolate between exponential function
- * stops.
- * How it works: Two consecutive stop values define a (scaled and shifted) exponential function `f(x) = a * base^x + b`, where `base` is the user-specified base,
- * and `a` and `b` are constants affording sufficient degrees of freedom to fit
- * the function to the given stops.
- *
- * Here's a bit of algebra that lets us compute `f(x)` directly from the stop
- * values without explicitly solving for `a` and `b`:
- *
- * First stop value: `f(x0) = y0 = a * base^x0 + b`
- * Second stop value: `f(x1) = y1 = a * base^x1 + b`
- * => `y1 - y0 = a(base^x1 - base^x0)`
- * => `a = (y1 - y0)/(base^x1 - base^x0)`
- *
- * Desired value: `f(x) = y = a * base^x + b`
- * => `f(x) = y0 + a * (base^x - base^x0)`
- *
- * From the above, we can replace the `a` in `a * (base^x - base^x0)` and do a
- * little algebra:
- * ```
- * a * (base^x - base^x0) = (y1 - y0)/(base^x1 - base^x0) * (base^x - base^x0)
- *                     = (y1 - y0) * (base^x - base^x0) / (base^x1 - base^x0)
- * ```
- *
- * If we let `(base^x - base^x0) / (base^x1 base^x0)`, then we have
- * `f(x) = y0 + (y1 - y0) * ratio`.  In other words, `ratio` may be treated as
- * an interpolation factor between the two stops' output values.
- *
- * (Note: a slightly different form for `ratio`,
- * `(base^(x-x0) - 1) / (base^(x1-x0) - 1) `, is equivalent, but requires fewer
- * expensive `Math.pow()` operations.)
- *
- * @private
- */
-function exponentialInterpolation(input, base, lowerValue, upperValue) {
-  const difference = upperValue - lowerValue;
-  const progress = input - lowerValue;
-
-  if (difference === 0) {
-    return 0;
-  }
-  if (base === 1) {
-    return progress / difference;
-  }
-  return (base ** progress - 1) / (base ** difference - 1);
-}
-
-module.exports = Interpolate;

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

@@ -1,54 +0,0 @@
-const { NumberType, toString } = require('../types');
-
-const { typeOf } = require('../values');
-const RuntimeError = require('../runtime_error');
-
-class Length {
-  constructor(input) {
-    this.type = NumberType;
-    this.input = input;
-  }
-
-  static parse(args, context) {
-    if (args.length !== 2) return context.error(`Expected 1 argument, but found ${args.length - 1} instead.`);
-
-    const input = context.parse(args[1], 1);
-    if (!input) return null;
-
-    if (input.type.kind !== 'array' && input.type.kind !== 'string' && input.type.kind !== 'value')
-      return context.error(`Expected argument of type string or array, but found ${toString(input.type)} instead.`);
-
-    return new Length(input);
-  }
-
-  evaluate(ctx) {
-    const input = this.input.evaluate(ctx);
-    if (typeof input === 'string') {
-      return input.length;
-    }
-    if (Array.isArray(input)) {
-      return input.length;
-    }
-    throw new RuntimeError(
-      `Expected value to be of type string or array, but found ${toString(typeOf(input))} instead.`
-    );
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-  }
-
-  possibleOutputs() {
-    return [undefined];
-  }
-
-  serialize() {
-    const serialized = ['length'];
-    this.eachChild(child => {
-      serialized.push(child.serialize());
-    });
-    return serialized;
-  }
-}
-
-module.exports = Length;

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

@@ -1,60 +0,0 @@
-class Let {
-  constructor(bindings, result) {
-    this.type = result.type;
-    this.bindings = [].concat(bindings);
-    this.result = result;
-  }
-
-  evaluate(ctx) {
-    return this.result.evaluate(ctx);
-  }
-
-  eachChild(fn) {
-    for (const binding of this.bindings) {
-      fn(binding[1]);
-    }
-    fn(this.result);
-  }
-
-  static parse(args, context) {
-    if (args.length < 4) return context.error(`Expected at least 3 arguments, but found ${args.length - 1} instead.`);
-
-    const bindings = [];
-    for (let i = 1; i < args.length - 1; i += 2) {
-      const name = args[i];
-
-      if (typeof name !== 'string') {
-        return context.error(`Expected string, but found ${typeof name} instead.`, i);
-      }
-
-      if (/[^a-zA-Z0-9_]/.test(name)) {
-        return context.error(`Variable names must contain only alphanumeric characters or '_'.`, i);
-      }
-
-      const value = context.parse(args[i + 1], i + 1);
-      if (!value) return null;
-
-      bindings.push([name, value]);
-    }
-
-    const result = context.parse(args[args.length - 1], args.length - 1, undefined, bindings);
-    if (!result) return null;
-
-    return new Let(bindings, result);
-  }
-
-  possibleOutputs() {
-    return this.result.possibleOutputs();
-  }
-
-  serialize() {
-    const serialized = ['let'];
-    for (const [name, expr] of this.bindings) {
-      serialized.push(name, expr.serialize());
-    }
-    serialized.push(this.result.serialize());
-    return serialized;
-  }
-}
-
-module.exports = Let;

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

@@ -1,69 +0,0 @@
-const assert = require('assert');
-const { isValue, typeOf, Color } = require('../values');
-const { Formatted } = require('./formatted');
-
-class Literal {
-  constructor(type, value) {
-    this.type = type;
-    this.value = value;
-  }
-
-  static parse(args, context) {
-    if (args.length !== 2)
-      return context.error(`'literal' expression requires exactly one argument, but found ${args.length - 1} instead.`);
-
-    if (!isValue(args[1])) return context.error('invalid value');
-
-    const value = args[1];
-    let type = typeOf(value);
-
-    // special case: infer the item type if possible for zero-length arrays
-    const expected = context.expectedType;
-    if (
-      type.kind === 'array' &&
-      type.N === 0 &&
-      expected &&
-      expected.kind === 'array' &&
-      (typeof expected.N !== 'number' || expected.N === 0)
-    ) {
-      type = expected;
-    }
-
-    return new Literal(type, value);
-  }
-
-  evaluate() {
-    return this.value;
-  }
-
-  eachChild() {}
-
-  possibleOutputs() {
-    return [this.value];
-  }
-
-  serialize() {
-    if (this.type.kind === 'array' || this.type.kind === 'object') {
-      return ['literal', this.value];
-    }
-    if (this.value instanceof Color) {
-      // Constant-folding can generate Literal expressions that you
-      // couldn't actually generate with a "literal" expression,
-      // so we have to implement an equivalent serialization here
-      return ['rgba'].concat(this.value.toArray());
-    }
-    if (this.value instanceof Formatted) {
-      // Same as Color
-      return this.value.serialize();
-    }
-    assert(
-      this.value === null ||
-        typeof this.value === 'string' ||
-        typeof this.value === 'number' ||
-        typeof this.value === 'boolean'
-    );
-    return this.value;
-  }
-}
-
-module.exports = Literal;

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

@@ -1,142 +0,0 @@
-const assert = require('assert');
-
-const { typeOf } = require('../values');
-const { ValueType } = require('../types');
-
-// Map input label values to output expression index
-
-class Match {
-  constructor(inputType, outputType, input, cases, outputs, otherwise) {
-    this.inputType = inputType;
-    this.type = outputType;
-    this.input = input;
-    this.cases = cases;
-    this.outputs = outputs;
-    this.otherwise = otherwise;
-  }
-
-  static parse(args, context) {
-    if (args.length < 5) return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-    if (args.length % 2 !== 1) return context.error('Expected an even number of arguments.');
-
-    let inputType;
-    let outputType;
-    if (context.expectedType && context.expectedType.kind !== 'value') {
-      outputType = context.expectedType;
-    }
-    const cases = {};
-    const outputs = [];
-    for (let i = 2; i < args.length - 1; i += 2) {
-      let labels = args[i];
-      const value = args[i + 1];
-
-      if (!Array.isArray(labels)) {
-        labels = [labels];
-      }
-
-      const labelContext = context.concat(i);
-      if (labels.length === 0) {
-        return labelContext.error('Expected at least one branch label.');
-      }
-
-      for (const label of labels) {
-        if (typeof label !== 'number' && typeof label !== 'string') {
-          return labelContext.error('Branch labels must be numbers or strings.');
-        }
-        if (typeof label === 'number' && Math.abs(label) > Number.MAX_SAFE_INTEGER) {
-          return labelContext.error(`Branch labels must be integers no larger than ${Number.MAX_SAFE_INTEGER}.`);
-        }
-        if (typeof label === 'number' && Math.floor(label) !== label) {
-          return labelContext.error('Numeric branch labels must be integer values.');
-        }
-        if (!inputType) {
-          inputType = typeOf(label);
-        } else if (labelContext.checkSubtype(inputType, typeOf(label))) {
-          return null;
-        }
-
-        if (typeof cases[String(label)] !== 'undefined') {
-          return labelContext.error('Branch labels must be unique.');
-        }
-
-        cases[String(label)] = outputs.length;
-      }
-
-      const result = context.parse(value, i, outputType);
-      if (!result) return null;
-      outputType = outputType || result.type;
-      outputs.push(result);
-    }
-
-    const input = context.parse(args[1], 1, ValueType);
-    if (!input) return null;
-
-    const otherwise = context.parse(args[args.length - 1], args.length - 1, outputType);
-    if (!otherwise) return null;
-
-    assert(inputType && outputType);
-
-    if (input.type.kind !== 'value' && context.concat(1).checkSubtype(inputType, input.type)) {
-      return null;
-    }
-
-    return new Match(inputType, outputType, input, cases, outputs, otherwise);
-  }
-
-  evaluate(ctx) {
-    const input = this.input.evaluate(ctx);
-    const output = (typeOf(input) === this.inputType && this.outputs[this.cases[input]]) || this.otherwise;
-    return output.evaluate(ctx);
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-    this.outputs.forEach(fn);
-    fn(this.otherwise);
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.outputs.map(out => out.possibleOutputs())).concat(this.otherwise.possibleOutputs());
-  }
-
-  serialize() {
-    const serialized = ['match', this.input.serialize()];
-
-    // Sort so serialization has an arbitrary defined order, even though
-    // branch order doesn't affect evaluation
-    const sortedLabels = Object.keys(this.cases).sort();
-
-    // Group branches by unique match expression to support condensed
-    // serializations of the form [case1, case2, ...] -> matchExpression
-    const groupedByOutput = [];
-    const outputLookup = {}; // lookup index into groupedByOutput for a given output expression
-    for (const label of sortedLabels) {
-      const outputIndex = outputLookup[this.cases[label]];
-      if (outputIndex === undefined) {
-        // First time seeing this output, add it to the end of the grouped list
-        outputLookup[this.cases[label]] = groupedByOutput.length;
-        groupedByOutput.push([this.cases[label], [label]]);
-      } else {
-        // We've seen this expression before, add the label to that output's group
-        groupedByOutput[outputIndex][1].push(label);
-      }
-    }
-
-    const coerceLabel = label => (this.inputType.kind === 'number' ? Number(label) : label);
-
-    for (const [outputIndex, labels] of groupedByOutput) {
-      if (labels.length === 1) {
-        // Only a single label matches this output expression
-        serialized.push(coerceLabel(labels[0]));
-      } else {
-        // Array of literal labels pointing to this output expression
-        serialized.push(labels.map(coerceLabel));
-      }
-      serialized.push(this.outputs[outputIndex].serialize());
-    }
-    serialized.push(this.otherwise.serialize());
-    return serialized;
-  }
-}
-
-module.exports = Match;

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

@@ -1,116 +0,0 @@
-const { NumberType } = require('../types');
-
-const { findStopLessThanOrEqualTo } = require('../stops');
-
-class Step {
-  constructor(type, input, stops) {
-    this.type = type;
-    this.input = input;
-
-    this.labels = [];
-    this.outputs = [];
-    for (const [label, expression] of stops) {
-      this.labels.push(label);
-      this.outputs.push(expression);
-    }
-  }
-
-  static parse(args, context) {
-    let [, input, ...rest] = args;
-
-    if (args.length - 1 < 4) {
-      return context.error(`Expected at least 4 arguments, but found only ${args.length - 1}.`);
-    }
-
-    if ((args.length - 1) % 2 !== 0) {
-      return context.error('Expected an even number of arguments.');
-    }
-
-    input = context.parse(input, 1, NumberType);
-    if (!input) return null;
-
-    const stops = [];
-
-    let outputType = null;
-    if (context.expectedType && context.expectedType.kind !== 'value') {
-      outputType = context.expectedType;
-    }
-
-    rest.unshift(Number.NEGATIVE_INFINITY);
-
-    for (let i = 0; i < rest.length; i += 2) {
-      const label = rest[i];
-      const value = rest[i + 1];
-
-      const labelKey = i + 1;
-      const valueKey = i + 2;
-
-      if (typeof label !== 'number') {
-        return context.error(
-          'Input/output pairs for "step" expressions must be defined using literal numeric values (not computed expressions) for the input values.',
-          labelKey
-        );
-      }
-
-      if (stops.length && stops[stops.length - 1][0] >= label) {
-        return context.error(
-          'Input/output pairs for "step" expressions must be arranged with input values in strictly ascending order.',
-          labelKey
-        );
-      }
-
-      const parsed = context.parse(value, valueKey, outputType);
-      if (!parsed) return null;
-      outputType = outputType || parsed.type;
-      stops.push([label, parsed]);
-    }
-
-    return new Step(outputType, input, stops);
-  }
-
-  evaluate(ctx) {
-    const labels = this.labels;
-    const outputs = this.outputs;
-
-    if (labels.length === 1) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const value = this.input.evaluate(ctx);
-    if (value <= labels[0]) {
-      return outputs[0].evaluate(ctx);
-    }
-
-    const stopCount = labels.length;
-    if (value >= labels[stopCount - 1]) {
-      return outputs[stopCount - 1].evaluate(ctx);
-    }
-
-    const index = findStopLessThanOrEqualTo(labels, value);
-    return outputs[index].evaluate(ctx);
-  }
-
-  eachChild(fn) {
-    fn(this.input);
-    for (const expression of this.outputs) {
-      fn(expression);
-    }
-  }
-
-  possibleOutputs() {
-    return [].concat(...this.outputs.map(output => output.possibleOutputs()));
-  }
-
-  serialize() {
-    const serialized = ['step', this.input.serialize()];
-    for (let i = 0; i < this.labels.length; i++) {
-      if (i > 0) {
-        serialized.push(this.labels[i]);
-      }
-      serialized.push(this.outputs[i].serialize());
-    }
-    return serialized;
-  }
-}
-
-module.exports = Step;