@mapwhit/tilerenderer 0.48.0 → 0.49.0

package/src/render/image_manager.js

@@ -1,4 +1,4 @@
-const ShelfPack = require('@mapbox/shelf-pack');
+const potpack = require('potpack');
 
 const { RGBAImage } = require('../util/image');
 const { ImagePosition } = require('./image_atlas');
@@ -26,9 +26,8 @@ class ImageManager {
   constructor() {
     this.images = {};
 
-    this.shelfPack = new ShelfPack(64, 64, { autoResize: true });
     this.patterns = {};
-    this.atlasImage = new RGBAImage({ width: 64, height: 64 });
+    this.atlasImage = new RGBAImage({ width: 1, height: 1 });
     this.dirty = true;
   }
 
@@ -56,12 +55,7 @@ class ImageManager {
   removeImage(id) {
     assert(this.images[id]);
     delete this.images[id];
-
-    const pattern = this.patterns[id];
-    if (pattern) {
-      this.shelfPack.unref(pattern.bin);
-      delete this.patterns[id];
-    }
+    delete this.patterns[id];
   }
 
   listImages() {
@@ -89,10 +83,8 @@ class ImageManager {
   // Pattern stuff
 
   getPixelSize() {
-    return {
-      width: this.shelfPack.w,
-      height: this.shelfPack.h
-    };
+    const { width, height } = this.atlasImage;
+    return { width, height };
   }
 
   getPattern(id) {
@@ -106,36 +98,13 @@ class ImageManager {
       return null;
     }
 
-    const width = image.data.width + padding * 2;
-    const height = image.data.height + padding * 2;
-
-    const bin = this.shelfPack.packOne(width, height);
-    if (!bin) {
-      return null;
-    }
-
-    this.atlasImage.resize(this.getPixelSize());
-
-    const src = image.data;
-    const dst = this.atlasImage;
-
-    const x = bin.x + padding;
-    const y = bin.y + padding;
-    const w = src.width;
-    const h = src.height;
-
-    RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x, y }, { width: w, height: h });
-
-    // Add 1 pixel wrapped padding on each side of the image.
-    RGBAImage.copy(src, dst, { x: 0, y: h - 1 }, { x: x, y: y - 1 }, { width: w, height: 1 }); // T
-    RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x: x, y: y + h }, { width: w, height: 1 }); // B
-    RGBAImage.copy(src, dst, { x: w - 1, y: 0 }, { x: x - 1, y: y }, { width: 1, height: h }); // L
-    RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x: x + w, y: y }, { width: 1, height: h }); // R
-
-    this.dirty = true;
-
+    const w = image.data.width + padding * 2;
+    const h = image.data.height + padding * 2;
+    const bin = { w, h, x: 0, y: 0 };
     const position = new ImagePosition(bin, image);
     this.patterns[id] = { bin, position };
+    this._updatePatternAtlas();
+
     return position;
   }
 
@@ -150,6 +119,37 @@ class ImageManager {
 
     this.atlasTexture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE);
   }
+
+  _updatePatternAtlas() {
+    const bins = [];
+    for (const id in this.patterns) {
+      bins.push(this.patterns[id].bin);
+    }
+
+    const { w, h } = potpack(bins);
+
+    const dst = this.atlasImage;
+    dst.resize({ width: w ?? 1, height: h ?? 1 });
+
+    for (const id in this.patterns) {
+      const { bin } = this.patterns[id];
+      const x = bin.x + padding;
+      const y = bin.y + padding;
+      const src = this.images[id].data;
+      const w = src.width;
+      const h = src.height;
+
+      RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x, y }, { width: w, height: h });
+
+      // Add 1 pixel wrapped padding on each side of the image.
+      RGBAImage.copy(src, dst, { x: 0, y: h - 1 }, { x: x, y: y - 1 }, { width: w, height: 1 }); // T
+      RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x: x, y: y + h }, { width: w, height: 1 }); // B
+      RGBAImage.copy(src, dst, { x: w - 1, y: 0 }, { x: x - 1, y: y }, { width: 1, height: h }); // L
+      RGBAImage.copy(src, dst, { x: 0, y: 0 }, { x: x + w, y: y }, { width: 1, height: h }); // R
+    }
+
+    this.dirty = true;
+  }
 }
 
 module.exports = ImageManager;

package/src/style/style_layer/symbol_style_layer_properties.js

@@ -19,6 +19,12 @@ const layout = new Properties({
     default: false,
     expression: { parameters: ['zoom'] }
   }),
+  'symbol-z-order': new DataConstantProperty({
+    type: 'enum',
+    values: ['viewport-y', 'source'],
+    default: 'viewport-y',
+    expression: { parameters: ['zoom'] }
+  }),
   'icon-allow-overlap': new DataConstantProperty({
     type: 'boolean',
     default: false,

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

@@ -1,6 +1,15 @@
 const assert = require('assert');
 
-const { ObjectType, ValueType, StringType, NumberType, BooleanType, checkSubtype, toString } = require('../types');
+const {
+  ObjectType,
+  ValueType,
+  StringType,
+  NumberType,
+  BooleanType,
+  checkSubtype,
+  toString,
+  array
+} = require('../types');
 const RuntimeError = require('../runtime_error');
 const { typeOf } = require('../values');
 
@@ -20,13 +29,39 @@ class Assertion {
   static parse(args, context) {
     if (args.length < 2) return context.error('Expected at least one argument.');
 
+    let i = 1;
+    let type;
+
     const name = args[0];
-    assert(types[name], name);
+    if (name === 'array') {
+      let itemType;
+      if (args.length > 2) {
+        const type = args[1];
+        if (typeof type !== 'string' || !(type in types) || type === 'object')
+          return context.error('The item type argument of "array" must be one of string, number, boolean', 1);
+        itemType = types[type];
+        i++;
+      } else {
+        itemType = ValueType;
+      }
 
-    const type = types[name];
+      let N;
+      if (args.length > 3) {
+        if (args[2] !== null && (typeof args[2] !== 'number' || args[2] < 0 || args[2] !== Math.floor(args[2]))) {
+          return context.error('The length argument to "array" must be a positive integer literal', 2);
+        }
+        N = args[2];
+        i++;
+      }
+
+      type = array(itemType, N);
+    } else {
+      assert(types[name], name);
+      type = types[name];
+    }
 
     const parsed = [];
-    for (let i = 1; i < args.length; i++) {
+    for (; i < args.length; i++) {
       const input = context.parse(args[i], i, ValueType);
       if (!input) return null;
       parsed.push(input);
@@ -62,7 +97,19 @@ class Assertion {
   }
 
   serialize() {
-    return [this.type.kind].concat(this.args.map(arg => arg.serialize()));
+    const type = this.type;
+    const serialized = [type.kind];
+    if (type.kind === 'array') {
+      const itemType = type.itemType;
+      if (itemType.kind === 'string' || itemType.kind === 'number' || itemType.kind === 'boolean') {
+        serialized.push(itemType.kind);
+        const N = type.N;
+        if (typeof N === 'number' || this.args.length > 1) {
+          serialized.push(N);
+        }
+      }
+    }
+    return serialized.concat(this.args.map(arg => arg.serialize()));
   }
 }
 

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

@@ -18,7 +18,6 @@ const Let = require('./let');
 const Var = require('./var');
 const Literal = require('./literal');
 const Assertion = require('./assertion');
-const ArrayAssertion = require('./array');
 const Coercion = require('./coercion');
 const At = require('./at');
 const Match = require('./match');
@@ -39,7 +38,7 @@ const expressions = {
   '<': LessThan,
   '>=': GreaterThanOrEqual,
   '<=': LessThanOrEqual,
-  array: ArrayAssertion,
+  array: Assertion,
   at: At,
   boolean: Assertion,
   case: Case,

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

@@ -4,7 +4,6 @@ const { checkSubtype } = require('./types');
 const ParsingError = require('./parsing_error');
 const Literal = require('./definitions/literal');
 const Assertion = require('./definitions/assertion');
-const ArrayAssertion = require('./definitions/array');
 const Coercion = require('./definitions/coercion');
 const EvaluationContext = require('./evaluation_context');
 const { CollatorExpression } = require('./definitions/collator');
@@ -83,16 +82,13 @@ class ParsingContext {
             (expected.kind === 'string' ||
               expected.kind === 'number' ||
               expected.kind === 'boolean' ||
-              expected.kind === 'object') &&
+              expected.kind === 'object' ||
+              expected.kind === 'array') &&
             actual.kind === 'value'
           ) {
             if (!options.omitTypeAnnotations) {
               parsed = new Assertion(expected, [parsed]);
             }
-          } else if (expected.kind === 'array' && actual.kind === 'value') {
-            if (!options.omitTypeAnnotations) {
-              parsed = new ArrayAssertion(expected, parsed);
-            }
           } else if (expected.kind === 'color' && (actual.kind === 'value' || actual.kind === 'string')) {
             if (!options.omitTypeAnnotations) {
               parsed = new Coercion(expected, [parsed]);
@@ -188,8 +184,7 @@ function isConstant(expression) {
     return false;
   }
 
-  const isTypeAnnotation =
-    expression instanceof Coercion || expression instanceof Assertion || expression instanceof ArrayAssertion;
+  const isTypeAnnotation = expression instanceof Coercion || expression instanceof Assertion;
 
   let childrenConstant = true;
   expression.eachChild(child => {

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;
   }
@@ -61,7 +64,7 @@ const filterSpec = {
  * @returns {Function} filter-evaluating function
  */
 function createFilter(filter) {
-  if (!filter) {
+  if (filter === null || filter === undefined) {
     return () => true;
   }