@mapwhit/tilerenderer 0.47.1

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

@@ -0,0 +1,77 @@
+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' };
+
+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, 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,
+  ObjectType,
+  ValueType,
+  ErrorType,
+  CollatorType,
+  array,
+  toString,
+  checkSubtype
+};

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

@@ -0,0 +1,126 @@
+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/feature_filter/README.md

@@ -0,0 +1,55 @@
+## Filter
+
+Filter expressions are used to target specific data in a layer. This library implements the semantics specified by the [Mapbox GL JS spec](https://www.mapbox.com/mapbox-gl-style-spec/#filter).
+
+### API
+
+`featureFilter(filter)`
+
+Given a filter expressed as nested arrays, return a new function
+that evaluates whether a given feature (with a .properties or .tags property)
+passes its test.
+
+#### Parameters
+
+| parameter | type  | description      |
+| --------- | ----- | ---------------- |
+| `filter`  | Array | mapbox gl filter |
+
+**Returns** `Function`, filter-evaluating function
+
+### Usage
+
+``` javascript
+var ff = require('feature-filter');
+
+// will match a feature with class of street_limited,
+// AND an admin_level less than or equal to 3,
+// that's NOT a polygon.
+var filter = [
+    "all",
+    ["==", "class", "street_limited"],
+    ["<=", "admin_level", 3],
+    ["!=", "$type", "Polygon"]
+]
+
+// will match a feature that has a class of
+// wetland OR wetland_noveg.
+// ["in", "class", "wetland", "wetland_noveg"]
+
+// testFilter will be a function that returns a boolean
+var testFilter = ff(filter);
+
+// Layer feature that you're testing. Must have type
+// and properties keys.
+var feature = {
+    type: 2,
+    properties: {
+       class: "street_limited",
+       admin_level: 1
+    }
+};
+
+// will return a boolean based on whether the feature matched the filter
+return testFilter({zoom: 0}, feature);
+```

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

@@ -0,0 +1,158 @@
+const { createExpression } = require('../expression');
+
+module.exports = createFilter;
+
+createFilter.isExpressionFilter = isExpressionFilter;
+
+function isExpressionFilter(filter) {
+  if (!Array.isArray(filter) || filter.length === 0) {
+    return false;
+  }
+  switch (filter[0]) {
+    case 'has':
+      return filter.length >= 2 && filter[1] !== '$id' && filter[1] !== '$type';
+
+    case 'in':
+    case '!in':
+    case '!has':
+    case 'none':
+      return false;
+
+    case '==':
+    case '!=':
+    case '>':
+    case '>=':
+    case '<':
+    case '<=':
+      return filter.length === 3 && (Array.isArray(filter[1]) || Array.isArray(filter[2]));
+
+    case 'any':
+    case 'all':
+      for (const f of filter.slice(1)) {
+        if (!isExpressionFilter(f) && typeof f !== 'boolean') {
+          return false;
+        }
+      }
+      return true;
+
+    default:
+      return true;
+  }
+}
+
+const filterSpec = {
+  type: 'boolean',
+  default: false,
+  transition: false,
+  'property-type': 'data-driven',
+  expression: {
+    interpolated: false,
+    parameters: ['zoom', 'feature']
+  }
+};
+
+/**
+ * Given a filter expressed as nested arrays, return a new function
+ * that evaluates whether a given feature (with a .properties or .tags property)
+ * passes its test.
+ *
+ * @private
+ * @param {Array} filter mapbox gl filter
+ * @returns {Function} filter-evaluating function
+ */
+function createFilter(filter) {
+  if (!filter) {
+    return () => true;
+  }
+
+  if (!isExpressionFilter(filter)) {
+    filter = convertFilter(filter);
+  }
+
+  const compiled = createExpression(filter, filterSpec);
+  if (compiled.result === 'error') {
+    throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
+  }
+  return (globalProperties, feature) => compiled.value.evaluate(globalProperties, feature);
+}
+
+// Comparison function to sort numbers and strings
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+
+function convertFilter(filter) {
+  if (!filter) return true;
+  const op = filter[0];
+  if (filter.length <= 1) return op !== 'any';
+  const converted =
+    op === '=='
+      ? convertComparisonOp(filter[1], filter[2], '==')
+      : op === '!='
+        ? convertNegation(convertComparisonOp(filter[1], filter[2], '=='))
+        : op === '<' || op === '>' || op === '<=' || op === '>='
+          ? convertComparisonOp(filter[1], filter[2], op)
+          : op === 'any'
+            ? convertDisjunctionOp(filter.slice(1))
+            : op === 'all'
+              ? ['all'].concat(filter.slice(1).map(convertFilter))
+              : op === 'none'
+                ? ['all'].concat(filter.slice(1).map(convertFilter).map(convertNegation))
+                : op === 'in'
+                  ? convertInOp(filter[1], filter.slice(2))
+                  : op === '!in'
+                    ? convertNegation(convertInOp(filter[1], filter.slice(2)))
+                    : op === 'has'
+                      ? convertHasOp(filter[1])
+                      : op === '!has'
+                        ? convertNegation(convertHasOp(filter[1]))
+                        : true;
+  return converted;
+}
+
+function convertComparisonOp(property, value, op) {
+  switch (property) {
+    case '$type':
+      return [`filter-type-${op}`, value];
+    case '$id':
+      return [`filter-id-${op}`, value];
+    default:
+      return [`filter-${op}`, property, value];
+  }
+}
+
+function convertDisjunctionOp(filters) {
+  return ['any'].concat(filters.map(convertFilter));
+}
+
+function convertInOp(property, values) {
+  if (values.length === 0) {
+    return false;
+  }
+  switch (property) {
+    case '$type':
+      return ['filter-type-in', ['literal', values]];
+    case '$id':
+      return ['filter-id-in', ['literal', values]];
+    default:
+      if (values.length > 200 && !values.some(v => typeof v !== typeof values[0])) {
+        return ['filter-in-large', property, ['literal', values.sort(compare)]];
+      }
+      return ['filter-in-small', property, ['literal', values]];
+  }
+}
+
+function convertHasOp(property) {
+  switch (property) {
+    case '$type':
+      return true;
+    case '$id':
+      return ['filter-has-id'];
+    default:
+      return ['filter-has', property];
+  }
+}
+
+function convertNegation(filter) {
+  return ['!', filter];
+}

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

@@ -0,0 +1,256 @@
+const assert = require('assert');
+
+module.exports = convertFunction;
+
+function convertFunction(parameters, propertySpec) {
+  let expression;
+
+  parameters = { ...parameters };
+  let defaultExpression;
+  if (typeof parameters.default !== 'undefined') {
+    defaultExpression = convertValue(parameters.default, propertySpec);
+  } else {
+    defaultExpression = convertValue(propertySpec.default, propertySpec);
+    if (defaultExpression === null) {
+      defaultExpression = ['error', 'No default property value available.'];
+    }
+  }
+
+  if (parameters.stops) {
+    const zoomAndFeatureDependent = parameters.stops && typeof parameters.stops[0][0] === 'object';
+    const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
+    const zoomDependent = zoomAndFeatureDependent || !featureDependent;
+
+    const stops = parameters.stops.map(stop => {
+      if (!featureDependent && propertySpec.tokens && typeof stop[1] === 'string') {
+        return [stop[0], convertTokenString(stop[1])];
+      }
+      return [stop[0], convertValue(stop[1], propertySpec)];
+    });
+
+    if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
+      throw new Error('Unimplemented');
+    }
+
+    if (zoomAndFeatureDependent) {
+      expression = convertZoomAndPropertyFunction(parameters, propertySpec, stops, defaultExpression);
+    } else if (zoomDependent) {
+      expression = convertZoomFunction(parameters, propertySpec, stops);
+    } else {
+      expression = convertPropertyFunction(parameters, propertySpec, stops, defaultExpression);
+    }
+  } else {
+    // identity function
+    expression = convertIdentityFunction(parameters, propertySpec, defaultExpression);
+  }
+
+  return expression;
+}
+
+function convertIdentityFunction(parameters, propertySpec, defaultExpression) {
+  const get = ['get', parameters.property];
+
+  if (propertySpec.type === 'color') {
+    return parameters.default === undefined ? get : ['to-color', get, parameters.default];
+  }
+  if (propertySpec.type === 'array' && typeof propertySpec.length === 'number') {
+    return ['array', propertySpec.value, propertySpec.length, get];
+  }
+  if (propertySpec.type === 'array') {
+    return ['array', propertySpec.value, get];
+  }
+  if (propertySpec.type === 'enum') {
+    return [
+      'let',
+      'property_value',
+      ['string', get],
+      ['match', ['var', 'property_value'], propertySpec.values, ['var', 'property_value'], defaultExpression]
+    ];
+  }
+  return parameters.default === undefined ? get : [propertySpec.type, get, parameters.default];
+}
+
+function convertValue(value, spec) {
+  if (typeof value === 'undefined' || value === null) return null;
+  if (spec.type === 'color') {
+    return value;
+  }
+  if (spec.type === 'array') {
+    return ['literal', value];
+  }
+  return value;
+}
+
+function convertZoomAndPropertyFunction(parameters, propertySpec, stops, defaultExpression) {
+  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 = ['interpolate', ['linear'], ['zoom']];
+
+    for (const z of zoomStops) {
+      const output = convertPropertyFunction(
+        featureFunctionParameters[z],
+        propertySpec,
+        featureFunctionStops[z],
+        defaultExpression
+      );
+      appendStopPair(expression, z, output, false);
+    }
+
+    return expression;
+  }
+  const expression = ['step', ['zoom']];
+
+  for (const z of zoomStops) {
+    const output = convertPropertyFunction(
+      featureFunctionParameters[z],
+      propertySpec,
+      featureFunctionStops[z],
+      defaultExpression
+    );
+    appendStopPair(expression, z, output, true);
+  }
+
+  fixupDegenerateStepCurve(expression);
+
+  return expression;
+}
+
+function convertPropertyFunction(parameters, propertySpec, stops, defaultExpression) {
+  const type = getFunctionType(parameters, propertySpec);
+
+  let expression;
+  let isStep = false;
+  if (type === 'categorical' && typeof stops[0][0] === 'boolean') {
+    assert(parameters.stops.length > 0 && parameters.stops.length <= 2);
+    expression = ['case'];
+    for (const stop of stops) {
+      expression.push(['==', ['get', parameters.property], stop[0]], stop[1]);
+    }
+    expression.push(defaultExpression);
+    return expression;
+  }
+  if (type === 'categorical') {
+    expression = ['match', ['get', parameters.property]];
+  } else if (type === 'interval') {
+    expression = ['step', ['number', ['get', parameters.property]]];
+    isStep = true;
+  } else if (type === 'exponential') {
+    const base = parameters.base !== undefined ? parameters.base : 1;
+    expression = ['interpolate', ['exponential', base], ['number', ['get', parameters.property]]];
+  } else {
+    throw new Error(`Unknown property function type ${type}`);
+  }
+
+  for (const stop of stops) {
+    appendStopPair(expression, stop[0], stop[1], isStep);
+  }
+
+  if (expression[0] === 'match') {
+    expression.push(defaultExpression);
+  }
+
+  fixupDegenerateStepCurve(expression);
+
+  return expression;
+}
+
+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 = ['interpolate', ['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;
+}