@mapwhit/tilerenderer 0.47.2 → 0.49.0

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

@@ -0,0 +1,197 @@
+const { isExpressionFilter } = require('./index');
+
+module.exports = convertFilter;
+
+/**
+ * Convert the given legacy filter to (the JSON representation of) an
+ * equivalent expression
+ * @private
+ */
+function convertFilter(filter) {
+  return _convertFilter(filter, {});
+}
+
+/*
+ * Convert the given filter to an expression, storing the expected types for
+ * any feature properties referenced in expectedTypes.
+ *
+ * These expected types are needed in order to construct preflight type checks
+ * needed for handling 'any' filters. A preflight type check is necessary in
+ * order to mimic legacy filters' semantics around expected type mismatches.
+ * For example, consider the legacy filter:
+ *
+ *     ["any", ["all", [">", "y", 0], [">", "y", 0]], [">", "x", 0]]
+ *
+ * Naively, we might convert this to the expression:
+ *
+ *     ["any", ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]], [">", ["get", "x"], 0]]
+ *
+ * But if we tried to evaluate this against, say `{x: 1, y: null, z: 0}`, the
+ * [">", ["get", "y"], 0] would cause an evaluation error, leading to the
+ * entire filter returning false. Legacy filter semantics, though, ask for
+ * [">", "y", 0] to simply return `false` when `y` is of the wrong type,
+ * allowing the subsequent terms of the outer "any" expression to be evaluated
+ * (resulting, in this case, in a `true` value, because x > 0).
+ *
+ * We account for this by inserting a preflight type-checking expression before
+ * each "any" term, allowing us to avoid evaluating the actual converted filter
+ * if any type mismatches would cause it to produce an evalaution error:
+ *
+ *     ["any",
+ *       ["case",
+ *         ["all", ["==", ["typeof", ["get", "y"]], "number"], ["==", ["typeof", ["get", "z"], "number]],
+ *         ["all", [">", ["get", "y"], 0], [">", ["get", "z"], 0]],
+ *         false
+ *       ],
+ *       ["case",
+ *         ["==", ["typeof", ["get", "x"], "number"]],
+ *         [">", ["get", "x"], 0],
+ *         false
+ *       ]
+ *     ]
+ *
+ * An alternative, possibly more direct approach would be to use type checks
+ * in the conversion of each comparison operator, so that the converted version
+ * of each individual ==, >=, etc. would mimic the legacy filter semantics. The
+ * downside of this approach is that it can lead to many more type checks than
+ * would otherwise be necessary: outside the context of an "any" expression,
+ * bailing out due to a runtime type error (expression semantics) and returning
+ * false (legacy filter semantics) are equivalent: they cause the filter to
+ * produce a `false` result.
+ */
+function _convertFilter(filter, expectedTypes) {
+  if (isExpressionFilter(filter)) {
+    return filter;
+  }
+
+  if (!filter) return true;
+  const op = filter[0];
+  if (filter.length <= 1) return op !== 'any';
+
+  let converted;
+
+  if (op === '==' || op === '!=' || op === '<' || op === '>' || op === '<=' || op === '>=') {
+    const [, property, value] = filter;
+    converted = convertComparisonOp(property, value, op, expectedTypes);
+  } else if (op === 'any') {
+    const children = filter.slice(1).map(f => {
+      const types = {};
+      const child = _convertFilter(f, types);
+      const typechecks = runtimeTypeChecks(types);
+      return typechecks === true ? child : ['case', typechecks, child, false];
+    });
+    return ['any'].concat(children);
+  } else if (op === 'all') {
+    const children = filter.slice(1).map(f => _convertFilter(f, expectedTypes));
+    return ['all'].concat(children);
+  } else if (op === 'none') {
+    return ['!', _convertFilter(['any'].concat(filter.slice(1)), {})];
+  } else if (op === 'in') {
+    converted = convertInOp(filter[1], filter.slice(2));
+  } else if (op === '!in') {
+    converted = convertInOp(filter[1], filter.slice(2), true);
+  } else if (op === 'has') {
+    converted = convertHasOp(filter[1]);
+  } else if (op === '!has') {
+    converted = ['!', convertHasOp(filter[1])];
+  } else {
+    converted = true;
+  }
+
+  return converted;
+}
+
+// Given a set of feature properties and an expected type for each one,
+// construct an boolean expression that tests whether each property has the
+// right type.
+// E.g.: for {name: 'string', population: 'number'}, return
+// [ 'all',
+//   ['==', ['typeof', ['get', 'name'], 'string']],
+//   ['==', ['typeof', ['get', 'population'], 'number]]
+// ]
+function runtimeTypeChecks(expectedTypes) {
+  const conditions = [];
+  for (const property in expectedTypes) {
+    const get = property === '$id' ? ['id'] : ['get', property];
+    conditions.push(['==', ['typeof', get], expectedTypes[property]]);
+  }
+  if (conditions.length === 0) return true;
+  if (conditions.length === 1) return conditions[0];
+  return ['all'].concat(conditions);
+}
+
+function convertComparisonOp(property, value, op, expectedTypes) {
+  let get;
+  if (property === '$type') {
+    return [op, ['geometry-type'], value];
+  }
+  if (property === '$id') {
+    get = ['id'];
+  } else {
+    get = ['get', property];
+  }
+
+  if (expectedTypes && value !== null) {
+    const type = typeof value;
+    expectedTypes[property] = type;
+  }
+
+  if (op === '==' && property !== '$id' && value === null) {
+    return [
+      'all',
+      ['has', property], // missing property != null for legacy filters
+      ['==', get, null]
+    ];
+  }
+  if (op === '!=' && property !== '$id' && value === null) {
+    return [
+      'any',
+      ['!', ['has', property]], // missing property != null for legacy filters
+      ['!=', get, null]
+    ];
+  }
+
+  return [op, get, value];
+}
+
+function convertInOp(property, values, negate = false) {
+  if (values.length === 0) return negate;
+
+  let get;
+  if (property === '$type') {
+    get = ['geometry-type'];
+  } else if (property === '$id') {
+    get = ['id'];
+  } else {
+    get = ['get', property];
+  }
+
+  // Determine if the list of values to be searched is homogenously typed.
+  // If so (and if the type is string or number), then we can use a
+  // [match, input, [...values], true, false] construction rather than a
+  // bunch of `==` tests.
+  let uniformTypes = true;
+  const type = typeof values[0];
+  for (const value of values) {
+    if (typeof value !== type) {
+      uniformTypes = false;
+      break;
+    }
+  }
+
+  if (uniformTypes && (type === 'string' || type === 'number')) {
+    return ['match', get, values, !negate, negate];
+  }
+
+  return [negate ? 'all' : 'any'].concat(values.map(v => [negate ? '!=' : '==', get, v]));
+}
+
+function convertHasOp(property) {
+  if (property === '$type') {
+    return true;
+  }
+  if (property === '$id') {
+    return ['!=', ['id'], null];
+  }
+  return ['has', property];
+}

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

@@ -5,6 +5,9 @@ module.exports = createFilter;
 createFilter.isExpressionFilter = isExpressionFilter;
 
 function isExpressionFilter(filter) {
+  if (filter === true || filter === false) {
+    return true;
+  }
   if (!Array.isArray(filter) || filter.length === 0) {
     return false;
   }
@@ -24,7 +27,7 @@ function isExpressionFilter(filter) {
     case '>=':
     case '<':
     case '<=':
-      return filter.length === 3 && (Array.isArray(filter[1]) || Array.isArray(filter[2]));
+      return filter.length !== 3 || Array.isArray(filter[1]) || Array.isArray(filter[2]);
 
     case 'any':
     case 'all':
@@ -61,7 +64,7 @@ const filterSpec = {
  * @returns {Function} filter-evaluating function
  */
 function createFilter(filter) {
-  if (!filter) {
+  if (filter === null || filter === undefined) {
     return () => true;
   }
 

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

@@ -3,85 +3,64 @@ 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.'];
-    }
+  let stops = parameters.stops;
+  if (!stops) {
+    // identity function
+    return convertIdentityFunction(parameters, propertySpec);
   }
 
-  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)];
-    });
+  const zoomAndFeatureDependent = stops && typeof stops[0][0] === 'object';
+  const featureDependent = zoomAndFeatureDependent || parameters.property !== undefined;
+  const zoomDependent = zoomAndFeatureDependent || !featureDependent;
 
-    if (parameters.colorSpace && parameters.colorSpace !== 'rgb') {
-      throw new Error('Unimplemented');
+  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) {
-      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);
+  if (zoomAndFeatureDependent) {
+    return convertZoomAndPropertyFunction(parameters, propertySpec, stops);
   }
-
-  return expression;
+  if (zoomDependent) {
+    return convertZoomFunction(parameters, propertySpec, stops);
+  }
+  return convertPropertyFunction(parameters, propertySpec, stops);
 }
 
-function convertIdentityFunction(parameters, propertySpec, defaultExpression) {
+function convertIdentityFunction(parameters, propertySpec) {
   const get = ['get', parameters.property];
 
-  if (propertySpec.type === 'color') {
-    return parameters.default === undefined ? get : ['to-color', get, parameters.default];
+  if (parameters.default === undefined) {
+    return get;
   }
-  if (propertySpec.type === 'array' && typeof propertySpec.length === 'number') {
-    return ['array', propertySpec.value, propertySpec.length, 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') {
-    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]
-    ];
+    expression.splice(1, 0, propertySpec.value, propertySpec.length || null);
   }
-  return parameters.default === undefined ? get : [propertySpec.type, get, parameters.default];
+  return expression;
 }
 
-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];
+function getInterpolateOperator(parameters) {
+  switch (parameters.colorSpace) {
+    case 'hcl':
+      return 'interpolate-hcl';
+    case 'lab':
+      return 'interpolate-lab';
+    default:
+      return 'interpolate';
   }
-  return value;
 }
 
-function convertZoomAndPropertyFunction(parameters, propertySpec, stops, defaultExpression) {
+function convertZoomAndPropertyFunction(parameters, propertySpec, stops) {
   const featureFunctionParameters = {};
   const featureFunctionStops = {};
   const zoomStops = [];
@@ -107,15 +86,10 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops, default
   // otherwise.
   const functionType = getFunctionType({}, propertySpec);
   if (functionType === 'exponential') {
-    const expression = ['interpolate', ['linear'], ['zoom']];
+    const expression = [getInterpolateOperator(parameters), ['linear'], ['zoom']];
 
     for (const z of zoomStops) {
-      const output = convertPropertyFunction(
-        featureFunctionParameters[z],
-        propertySpec,
-        featureFunctionStops[z],
-        defaultExpression
-      );
+      const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
       appendStopPair(expression, z, output, false);
     }
 
@@ -124,12 +98,7 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops, default
   const expression = ['step', ['zoom']];
 
   for (const z of zoomStops) {
-    const output = convertPropertyFunction(
-      featureFunctionParameters[z],
-      propertySpec,
-      featureFunctionStops[z],
-      defaultExpression
-    );
+    const output = convertPropertyFunction(featureFunctionParameters[z], propertySpec, featureFunctionStops[z]);
     appendStopPair(expression, z, output, true);
   }
 
@@ -138,43 +107,52 @@ function convertZoomAndPropertyFunction(parameters, propertySpec, stops, default
   return expression;
 }
 
-function convertPropertyFunction(parameters, propertySpec, stops, defaultExpression) {
-  const type = getFunctionType(parameters, propertySpec);
+function coalesce(a, b) {
+  if (a !== undefined) return a;
+  if (b !== undefined) return b;
+}
 
-  let expression;
-  let isStep = false;
+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);
-    expression = ['case'];
+    const expression = ['case'];
     for (const stop of stops) {
-      expression.push(['==', ['get', parameters.property], stop[0]], stop[1]);
+      expression.push(['==', get, stop[0]], stop[1]);
     }
-    expression.push(defaultExpression);
+    expression.push(['literal', coalesce(parameters.default, propertySpec.default)]);
     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}`);
+    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;
   }
-
-  for (const stop of stops) {
-    appendStopPair(expression, stop[0], stop[1], isStep);
+  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 (expression[0] === 'match') {
-    expression.push(defaultExpression);
+  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]];
   }
-
-  fixupDegenerateStepCurve(expression);
-
-  return expression;
+  throw new Error(`Unknown property function type ${type}`);
 }
 
 function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom']) {
@@ -186,7 +164,7 @@ function convertZoomFunction(parameters, propertySpec, stops, input = ['zoom'])
     isStep = true;
   } else if (type === 'exponential') {
     const base = parameters.base !== undefined ? parameters.base : 1;
-    expression = ['interpolate', ['exponential', base], input];
+    expression = [getInterpolateOperator(parameters), ['exponential', base], input];
   } else {
     throw new Error(`Unknown zoom function type "${type}"`);
   }