@mapwhit/tilerenderer 0.49.0 → 0.51.0

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;

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

@@ -1,37 +0,0 @@
-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
-};

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

@@ -1,88 +0,0 @@
-const NullType = { kind: 'null' };
-const NumberType = { kind: 'number' };
-const StringType = { kind: 'string' };
-const BooleanType = { kind: 'boolean' };
-const ColorType = { kind: 'color' };
-const ObjectType = { kind: 'object' };
-const ValueType = { kind: 'value' };
-const ErrorType = { kind: 'error' };
-const CollatorType = { kind: 'collator' };
-const FormattedType = { kind: 'formatted' };
-
-function array(itemType, N) {
-  return {
-    kind: 'array',
-    itemType,
-    N
-  };
-}
-
-function toString(type) {
-  if (type.kind === 'array') {
-    const itemType = toString(type.itemType);
-    return typeof type.N === 'number'
-      ? `array<${itemType}, ${type.N}>`
-      : type.itemType.kind === 'value'
-        ? 'array'
-        : `array<${itemType}>`;
-  }
-  return type.kind;
-}
-
-const valueMemberTypes = [
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  FormattedType,
-  ObjectType,
-  array(ValueType)
-];
-
-/**
- * Returns null if `t` is a subtype of `expected`; otherwise returns an
- * error message.
- * @private
- */
-function checkSubtype(expected, t) {
-  if (t.kind === 'error') {
-    // Error is a subtype of every type
-    return null;
-  }
-  if (expected.kind === 'array') {
-    if (
-      t.kind === 'array' &&
-      !checkSubtype(expected.itemType, t.itemType) &&
-      (typeof expected.N !== 'number' || expected.N === t.N)
-    ) {
-      return null;
-    }
-  } else if (expected.kind === t.kind) {
-    return null;
-  } else if (expected.kind === 'value') {
-    for (const memberType of valueMemberTypes) {
-      if (!checkSubtype(memberType, t)) {
-        return null;
-      }
-    }
-  }
-
-  return `Expected ${toString(expected)} but found ${toString(t)} instead.`;
-}
-
-module.exports = {
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  FormattedType,
-  ObjectType,
-  ValueType,
-  ErrorType,
-  CollatorType,
-  array,
-  toString,
-  checkSubtype
-};

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

@@ -1,126 +0,0 @@
-const assert = require('assert');
-
-const Color = require('../util/color');
-const { Collator } = require('./definitions/collator');
-const {
-  NullType,
-  NumberType,
-  StringType,
-  BooleanType,
-  ColorType,
-  ObjectType,
-  ValueType,
-  CollatorType,
-  array
-} = require('./types');
-
-function validateRGBA(r, g, b, a) {
-  if (
-    !(
-      typeof r === 'number' &&
-      r >= 0 &&
-      r <= 255 &&
-      typeof g === 'number' &&
-      g >= 0 &&
-      g <= 255 &&
-      typeof b === 'number' &&
-      b >= 0 &&
-      b <= 255
-    )
-  ) {
-    const value = typeof a === 'number' ? [r, g, b, a] : [r, g, b];
-    return `Invalid rgba value [${value.join(', ')}]: 'r', 'g', and 'b' must be between 0 and 255.`;
-  }
-
-  if (!(typeof a === 'undefined' || (typeof a === 'number' && a >= 0 && a <= 1))) {
-    return `Invalid rgba value [${[r, g, b, a].join(', ')}]: 'a' must be between 0 and 1.`;
-  }
-
-  return null;
-}
-
-function isValue(mixed) {
-  if (mixed === null) {
-    return true;
-  }
-  if (typeof mixed === 'string') {
-    return true;
-  }
-  if (typeof mixed === 'boolean') {
-    return true;
-  }
-  if (typeof mixed === 'number') {
-    return true;
-  }
-  if (mixed instanceof Color) {
-    return true;
-  }
-  if (mixed instanceof Collator) {
-    return true;
-  }
-  if (Array.isArray(mixed)) {
-    for (const item of mixed) {
-      if (!isValue(item)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  if (typeof mixed === 'object') {
-    for (const key in mixed) {
-      if (!isValue(mixed[key])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  return false;
-}
-
-function typeOf(value) {
-  if (value === null) {
-    return NullType;
-  }
-  if (typeof value === 'string') {
-    return StringType;
-  }
-  if (typeof value === 'boolean') {
-    return BooleanType;
-  }
-  if (typeof value === 'number') {
-    return NumberType;
-  }
-  if (value instanceof Color) {
-    return ColorType;
-  }
-  if (value instanceof Collator) {
-    return CollatorType;
-  }
-  if (Array.isArray(value)) {
-    const length = value.length;
-    let itemType;
-
-    for (const item of value) {
-      const t = typeOf(item);
-      if (!itemType) {
-        itemType = t;
-      } else if (itemType === t) {
-      } else {
-        itemType = ValueType;
-        break;
-      }
-    }
-
-    return array(itemType || ValueType, length);
-  }
-  assert(typeof value === 'object');
-  return ObjectType;
-}
-
-module.exports = {
-  Color,
-  Collator,
-  validateRGBA,
-  isValue,
-  typeOf
-};

package/src/style-spec/function/convert.js

@@ -1,234 +0,0 @@
-const assert = require('assert');
-
-module.exports = convertFunction;
-
-function convertFunction(parameters, propertySpec) {
-  let stops = parameters.stops;
-  if (!stops) {
-    // identity function
-    return convertIdentityFunction(parameters, propertySpec);
-  }
-
-  const zoomAndFeatureDependent = stops && typeof stops[0][0] === 'object';
-  const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
-  const zoomDependent = zoomAndFeatureDependent || !featureDependent;
-
-  stops = stops.map(stop => {
-    if (!featureDependent && propertySpec.tokens && typeof stop[1] === 'string') {
-      return [stop[0], convertTokenString(stop[1])];
-    }
-    return [stop[0], ['literal', stop[1]]];
-  });
-
-  if (zoomAndFeatureDependent) {
-    return convertZoomAndPropertyFunction(parameters, propertySpec, stops);
-  }
-  if (zoomDependent) {
-    return convertZoomFunction(parameters, propertySpec, stops);
-  }
-  return convertPropertyFunction(parameters, propertySpec, stops);
-}
-
-function convertIdentityFunction(parameters, propertySpec) {
-  const get = ['get', parameters.property];
-
-  if (parameters.default === undefined) {
-    return get;
-  }
-  if (propertySpec.type === 'enum') {
-    return ['match', get, Object.keys(propertySpec.values), get, parameters.default];
-  }
-  const expression = [
-    propertySpec.type === 'color' ? 'to-color' : propertySpec.type,
-    get,
-    ['literal', parameters.default]
-  ];
-  if (propertySpec.type === 'array') {
-    expression.splice(1, 0, propertySpec.value, propertySpec.length || null);
-  }
-  return expression;
-}
-
-function getInterpolateOperator(parameters) {
-  switch (parameters.colorSpace) {
-    case 'hcl':
-      return 'interpolate-hcl';
-    case 'lab':
-      return 'interpolate-lab';
-    default:
-      return 'interpolate';
-  }
-}
-
-function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
-  const featureFunctionParameters = {};
-  const featureFunctionStops = {};
-  const zoomStops = [];
-  for (let s = 0; s < stops.length; s++) {
-    const stop = stops[s];
-    const zoom = stop[0].zoom;
-    if (featureFunctionParameters[zoom] === undefined) {
-      featureFunctionParameters[zoom] = {
-        zoom: zoom,
-        type: parameters.type,
-        property: parameters.property,
-        default: parameters.default
-      };
-      featureFunctionStops[zoom] = [];
-      zoomStops.push(zoom);
-    }
-    featureFunctionStops[zoom].push([stop[0].value, stop[1]]);
-  }
-
-  // the interpolation type for the zoom dimension of a zoom-and-property
-  // function is determined directly from the style property specification
-  // for which it's being used: linear for interpolatable properties, step
-  // otherwise.
-  const functionType = getFunctionType({}, propertySpec);
-  if (functionType === 'exponential') {
-    const expression = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
-
-    for (const z of zoomStops) {
-      const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
-      appendStopPair(expression, z, output, false);
-    }
-
-    return expression;
-  }
-  const expression = ['step', ['zoom']];
-
-  for (const z of zoomStops) {
-    const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
-    appendStopPair(expression, z, output, true);
-  }
-
-  fixupDegenerateStepCurve(expression);
-
-  return expression;
-}
-
-function coalesce(a, b) {
-  if (a !== undefined) return a;
-  if (b !== undefined) return b;
-}
-
-function convertPropertyFunction(parameters, propertySpec, stops) {
-  const type = getFunctionType(parameters, propertySpec);
-  const get = ['get', parameters.property];
-  if (type === 'categorical' && typeof stops[0][0] === 'boolean') {
-    assert(parameters.stops.length > 0 && parameters.stops.length <= 2);
-    const expression = ['case'];
-    for (const stop of stops) {
-      expression.push(['==', get, stop[0]], stop[1]);
-    }
-    expression.push(['literal', coalesce(parameters.default, propertySpec.default)]);
-    return expression;
-  }
-  if (type === 'categorical') {
-    const expression = ['match', get];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], false);
-    }
-    expression.push(['literal', coalesce(parameters.default, propertySpec.default)]);
-    return expression;
-  }
-  if (type === 'interval') {
-    const expression = ['step', ['number', get]];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], true);
-    }
-    fixupDegenerateStepCurve(expression);
-    return parameters.default === undefined
-      ? expression
-      : ['case', ['==', ['typeof', get], 'number'], expression, ['literal', parameters.default]];
-  }
-  if (type === 'exponential') {
-    const base = parameters.base !== undefined ? parameters.base : 1;
-    const expression = [getInterpolateOperator(parameters), ['exponential', base], ['number', get]];
-    for (const stop of stops) {
-      appendStopPair(expression, stop[0], stop[1], false);
-    }
-    return parameters.default === undefined
-      ? expression
-      : ['case', ['==', ['typeof', get], 'number'], expression, ['literal', parameters.default]];
-  }
-  throw new Error(`Unknown property function type ${type}`);
-}
-
-function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom']) {
-  const type = getFunctionType(parameters, propertySpec);
-  let expression;
-  let isStep = false;
-  if (type === 'interval') {
-    expression = ['step', input];
-    isStep = true;
-  } else if (type === 'exponential') {
-    const base = parameters.base !== undefined ? parameters.base : 1;
-    expression = [getInterpolateOperator(parameters), ['exponential', base], input];
-  } else {
-    throw new Error(`Unknown zoom function type "${type}"`);
-  }
-
-  for (const stop of stops) {
-    appendStopPair(expression, stop[0], stop[1], isStep);
-  }
-
-  fixupDegenerateStepCurve(expression);
-
-  return expression;
-}
-
-function fixupDegenerateStepCurve(expression) {
-  // degenerate step curve (i.e. a constant function): add a noop stop
-  if (expression[0] === 'step' && expression.length === 3) {
-    expression.push(0);
-    expression.push(expression[3]);
-  }
-}
-
-function appendStopPair(curve, input, output, isStep) {
-  // Skip duplicate stop values. They were not validated for functions, but they are for expressions.
-  // https://github.com/mapbox/mapbox-gl-js/issues/4107
-  if (curve.length > 3 && input === curve[curve.length - 2]) {
-    return;
-  }
-  // step curves don't get the first input value, as it is redundant.
-  if (!(isStep && curve.length === 2)) {
-    curve.push(input);
-  }
-  curve.push(output);
-}
-
-function getFunctionType(parameters, propertySpec) {
-  if (parameters.type) {
-    return parameters.type;
-  }
-  assert(propertySpec.expression);
-  return propertySpec.expression.interpolated ? 'exponential' : 'interval';
-}
-
-// "String with {name} token" => ["concat", "String with ", ["get", "name"], " token"]
-function convertTokenString(s) {
-  const result = ['concat'];
-  const re = /{([^{}]+)}/g;
-  let pos = 0;
-  let match;
-  while ((match = re.exec(s)) !== null) {
-    const literal = s.slice(pos, re.lastIndex - match[0].length);
-    pos = re.lastIndex;
-    if (literal.length > 0) result.push(literal);
-    result.push(['to-string', ['get', match[1]]]);
-  }
-
-  if (result.length === 1) {
-    return s;
-  }
-
-  if (pos < s.length) {
-    result.push(s.slice(pos));
-  } else if (result.length === 2) {
-    return result[1];
-  }
-
-  return result;
-}