@mapwhit/tilerenderer 0.50.0 → 0.51.0

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('../types/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;

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

@@ -1,38 +0,0 @@
-class Var {
-  constructor(name, boundExpression) {
-    this.type = boundExpression.type;
-    this.name = name;
-    this.boundExpression = boundExpression;
-  }
-
-  static parse(args, context) {
-    if (args.length !== 2 || typeof args[1] !== 'string')
-      return context.error(`'var' expression requires exactly one string literal argument.`);
-
-    const name = args[1];
-    if (!context.scope.has(name)) {
-      return context.error(
-        `Unknown variable "${name}". Make sure "${name}" has been bound in an enclosing "let" expression before using it.`,
-        1
-      );
-    }
-
-    return new Var(name, context.scope.get(name));
-  }
-
-  evaluate(ctx) {
-    return this.boundExpression.evaluate(ctx);
-  }
-
-  eachChild() {}
-
-  possibleOutputs() {
-    return [undefined];
-  }
-
-  serialize() {
-    return ['var', this.name];
-  }
-}
-
-module.exports = Var;

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

@@ -1,38 +0,0 @@
-const { Color } = require('./values');
-
-const geometryTypes = ['Unknown', 'Point', 'LineString', 'Polygon'];
-
-class EvaluationContext {
-  constructor() {
-    this.globals = null;
-    this.feature = null;
-    this.featureState = null;
-    this._parseColorCache = {};
-  }
-
-  id() {
-    return this.feature && 'id' in this.feature ? this.feature.id : null;
-  }
-
-  geometryType() {
-    return this.feature
-      ? typeof this.feature.type === 'number'
-        ? geometryTypes[this.feature.type]
-        : this.feature.type
-      : null;
-  }
-
-  properties() {
-    return this.feature?.properties || {};
-  }
-
-  parseColor(input) {
-    let cached = this._parseColorCache[input];
-    if (!cached) {
-      cached = this._parseColorCache[input] = Color.parse(input);
-    }
-    return cached;
-  }
-}
-
-module.exports = EvaluationContext;