@mapwhit/tilerenderer 0.47.2 → 0.49.0

package/src/index.js

@@ -43,7 +43,7 @@ module.exports = {
  * @param {string} pluginURL URL pointing to the Mapbox RTL text plugin source.
  * @param {Function} callback Called with an error argument if there is an error.
  * @example
- * mapboxgl.setRTLTextPlugin('https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.1.2/mapbox-gl-rtl-text.js');
+ * mapboxgl.setRTLTextPlugin('https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.2.0/mapbox-gl-rtl-text.js');
  * @see [Add support for right-to-left scripts](https://www.mapbox.com/mapbox-gl-js/example/mapbox-gl-rtl-text/)
  */
 

package/src/render/glyph_atlas.js

@@ -1,14 +1,12 @@
-const ShelfPack = require('@mapbox/shelf-pack');
-
 const { AlphaImage } = require('../util/image');
 const { register } = require('../util/transfer_registry');
+const potpack = require('potpack');
 
 const padding = 1;
 
 class GlyphAtlas {
   constructor(stacks) {
     const positions = {};
-    const pack = new ShelfPack(0, 0, { autoResize: true });
     const bins = [];
 
     for (const stack in stacks) {
@@ -30,9 +28,8 @@ class GlyphAtlas {
       }
     }
 
-    pack.pack(bins, { inPlace: true });
-
-    const image = new AlphaImage({ width: pack.w, height: pack.h });
+    const { w, h } = potpack(bins);
+    const image = new AlphaImage({ width: w ?? 1, height: h ?? 1 });
 
     for (const stack in stacks) {
       const glyphs = stacks[stack];

package/src/render/image_atlas.js

@@ -1,7 +1,6 @@
-const ShelfPack = require('@mapbox/shelf-pack');
-
 const { RGBAImage } = require('../util/image');
 const { register } = require('../util/transfer_registry');
+const potpack = require('potpack');
 
 const padding = 1;
 
@@ -32,7 +31,6 @@ class ImageAtlas {
   constructor(icons, patterns) {
     const iconPositions = {};
     const patternPositions = {};
-    const pack = new ShelfPack(0, 0, { autoResize: true });
     const bins = [];
     for (const id in icons) {
       const src = icons[id];
@@ -58,9 +56,8 @@ class ImageAtlas {
       patternPositions[id] = new ImagePosition(bin, src);
     }
 
-    pack.pack(bins, { inPlace: true });
-
-    const image = new RGBAImage({ width: pack.w, height: pack.h });
+    const { w, h } = potpack(bins);
+    const image = new RGBAImage({ width: w || 1, height: h || 1 });
 
     for (const id in icons) {
       const src = icons[id];

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/source/rtl_text_plugin.js

@@ -47,6 +47,7 @@ function setRTLTextPlugin(url, callback) {
 const plugin = {
   applyArabicShaping: null,
   processBidirectionalText: null,
+  processStyledBidirectionalText: null,
   isLoaded: function () {
     return (
       foregroundLoadComplete || // Foreground: loaded if the completion callback returned successfully

package/src/source/source_cache.js

@@ -181,7 +181,7 @@ class SourceCache extends Evented {
     this._cache.reset();
 
     for (const i in this._tiles) {
-      this._reloadTile(i, 'reloading');
+      if (this._tiles[i].state !== 'errored') this._reloadTile(i, 'reloading');
     }
   }
 

package/src/source/tile.js

@@ -101,8 +101,9 @@ class Tile {
     }
 
     this.queryPadding = 0;
-    for (const bucket of buckets) {
-      this.queryPadding = Math.max(this.queryPadding, painter.style.getLayer(bucket.layerIds[0]).queryRadius(bucket));
+    for (const id in this.buckets) {
+      const bucket = this.buckets[id];
+      this.queryPadding = Math.max(this.queryPadding, painter.style.getLayer(id).queryRadius(bucket));
     }
 
     if (data.imageAtlas) {
@@ -297,8 +298,8 @@ class Tile {
 
     const vtLayers = this.latestFeatureIndex.loadVTLayers();
 
-    for (const i in this.buckets) {
-      const bucket = this.buckets[i];
+    for (const id in this.buckets) {
+      const bucket = this.buckets[id];
       // Buckets are grouped by common source-layer
       const sourceLayerId = bucket.layers[0]['sourceLayer'] || '_geojsonTileLayer';
       const sourceLayer = vtLayers[sourceLayerId];
@@ -307,7 +308,7 @@ class Tile {
 
       bucket.update(sourceLayerStates, sourceLayer, this.imageAtlas?.patternPositions || {});
       if (painter?.style) {
-        this.queryPadding = Math.max(this.queryPadding, painter.style.getLayer(bucket.layerIds[0]).queryRadius(bucket));
+        this.queryPadding = Math.max(this.queryPadding, painter.style.getLayer(id).queryRadius(bucket));
       }
     }
   }

package/src/source/worker.js

@@ -38,6 +38,7 @@ class Worker {
       }
       globalRTLTextPlugin['applyArabicShaping'] = rtlTextPlugin.applyArabicShaping;
       globalRTLTextPlugin['processBidirectionalText'] = rtlTextPlugin.processBidirectionalText;
+      globalRTLTextPlugin['processStyledBidirectionalText'] = rtlTextPlugin.processStyledBidirectionalText;
     };
   }
 
@@ -71,16 +72,6 @@ class Worker {
     }
   }
 
-  /**
-   * Load a {@link WorkerSource} script at params.url.  The script is run
-   * (using importScripts) with `registerWorkerSource` in scope, which is a
-   * function taking `(name, workerSourceObject)`.
-   *  @private
-   */
-  loadWorkerSource(map, params) {
-    this.self.importScripts(params.url);
-  }
-
   loadRTLTextPlugin(map, pluginURL) {
     if (!globalRTLTextPlugin.isLoaded()) {
       this.self.importScripts(pluginURL);

package/src/style/style.js

@@ -633,6 +633,10 @@ class Style extends Evented {
       this.fire(new ErrorEvent(new Error('The sourceLayer parameter must be provided for vector source types.')));
       return;
     }
+    if (feature.id == null || feature.id === '') {
+      this.fire(new ErrorEvent(new Error('The feature id parameter must be provided.')));
+      return;
+    }
 
     sourceCache.setFeatureState(sourceLayer, feature.id, state);
   }
@@ -767,25 +771,6 @@ class Style extends Evented {
     return sourceCache ? querySourceFeatures(sourceCache, params) : [];
   }
 
-  addSourceType(name, SourceType, callback) {
-    if (Style.getSourceType(name)) {
-      return callback(new Error(`A source type called "${name}" already exists.`));
-    }
-
-    Style.setSourceType(name, SourceType);
-
-    if (!SourceType.workerSourceURL) {
-      return callback(null, null);
-    }
-
-    this.dispatcher
-      .broadcast('loadWorkerSource', {
-        name: name,
-        url: SourceType.workerSourceURL
-      })
-      .then(data => callback(null, data), callback);
-  }
-
   getLight() {
     return this.light.getLight();
   }

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,
@@ -106,7 +112,7 @@ const layout = new Properties({
     expression: { parameters: ['zoom'] }
   }),
   'text-field': new DataDrivenProperty({
-    type: 'string',
+    type: 'formatted',
     default: '',
     tokens: true,
     expression: { parameters: ['zoom', 'feature'] }

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

@@ -46,20 +46,6 @@ class CompoundExpression {
         signature.length === args.length - 1 // correct param count
     );
 
-    // First parse all the args
-    const parsedArgs = [];
-    for (let i = 1; i < args.length; i++) {
-      const arg = args[i];
-      let expected;
-      if (overloads.length === 1) {
-        const params = overloads[0][0];
-        expected = Array.isArray(params) ? params[i - 1] : params.type;
-      }
-      const parsed = context.parse(arg, 1 + parsedArgs.length, expected);
-      if (!parsed) return null;
-      parsedArgs.push(parsed);
-    }
-
     let signatureContext = null;
 
     for (const [params, evaluate] of overloads) {
@@ -67,6 +53,27 @@ class CompoundExpression {
       // we eventually succeed, we haven't polluted `context.errors`.
       signatureContext = new ParsingContext(context.registry, context.path, null, context.scope);
 
+      // First parse all the args, potentially coercing to the
+      // types expected by this overload.
+      const parsedArgs = [];
+      let argParseFailed = false;
+      for (let i = 1; i < args.length; i++) {
+        const arg = args[i];
+        const expectedType = Array.isArray(params) ? params[i - 1] : params.type;
+
+        const parsed = signatureContext.parse(arg, 1 + parsedArgs.length, expectedType);
+        if (!parsed) {
+          argParseFailed = true;
+          break;
+        }
+        parsedArgs.push(parsed);
+      }
+      if (argParseFailed) {
+        // Couldn't coerce args of this overload to expected type, move
+        // on to next one.
+        continue;
+      }
+
       if (Array.isArray(params)) {
         if (params.length !== parsedArgs.length) {
           signatureContext.error(`Expected ${params.length} arguments, but found ${parsedArgs.length} instead.`);
@@ -92,8 +99,15 @@ class CompoundExpression {
     } else {
       const expected = overloads.length ? overloads : availableOverloads;
       const signatures = expected.map(([params]) => stringifySignature(params)).join(' | ');
-      const actualTypes = parsedArgs.map(arg => toString(arg.type)).join(', ');
-      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes}) instead.`);
+      const actualTypes = [];
+      // For error message, re-parse arguments without trying to
+      // apply any coercions
+      for (let i = 1; i < args.length; i++) {
+        const parsed = context.parse(args[i], 1 + actualTypes.length);
+        if (!parsed) return null;
+        actualTypes.push(toString(parsed.type));
+      }
+      context.error(`Expected arguments of type ${signatures}, but found (${actualTypes.join(', ')}) instead.`);
     }
 
     return null;

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/coercion.js

@@ -3,6 +3,7 @@ const assert = require('assert');
 const { ColorType, ValueType, NumberType } = require('../types');
 const { Color, validateRGBA } = require('../values');
 const RuntimeError = require('../runtime_error');
+const { Formatted, FormattedSection } = require('./formatted');
 
 const types = {
   'to-number': NumberType,
@@ -65,6 +66,18 @@ class Coercion {
         error || `Could not parse color from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`
       );
     }
+    if (this.type.kind === 'formatted') {
+      let input;
+      for (const arg of this.args) {
+        input = arg.evaluate(ctx);
+        if (typeof input === 'string') {
+          return new Formatted([new FormattedSection(input, null, null)]);
+        }
+      }
+      throw new RuntimeError(
+        `Could not parse formatted text from value '${typeof input === 'string' ? input : JSON.stringify(input)}'`
+      );
+    }
     let value = null;
     for (const arg of this.args) {
       value = arg.evaluate(ctx);