@mapwhit/tilerenderer 0.52.1 → 1.0.0

package/src/source/raster_dem_tile_source.js

@@ -1,35 +1,23 @@
 const browser = require('../util/browser');
 const loadImage = require('../util/loader/image');
-const { OverscaledTileID } = require('./tile_id');
+const { calculateKey } = require('./tile_id');
 const RasterTileSource = require('./raster_tile_source');
-// ensure DEMData is registered for worker transfer on main thread:
-require('../data/dem_data');
+const DEMData = require('../data/dem_data');
 
 class RasterDEMTileSource extends RasterTileSource {
-  constructor(id, options, dispatcher, eventedParent) {
-    super(id, options, dispatcher, eventedParent);
+  constructor(id, options, eventedParent) {
+    super(id, options, eventedParent);
     this.type = 'raster-dem';
     this.maxzoom = 22;
     this._options = Object.assign({}, options);
     this.encoding = options.encoding || 'mapbox';
   }
 
-  serialize() {
-    return {
-      type: 'raster-dem',
-      url: this.url,
-      tileSize: this.tileSize,
-      tiles: this.tiles,
-      bounds: this.bounds,
-      encoding: this.encoding
-    };
-  }
-
   async loadTile(tile) {
     try {
       tile.abortController = new window.AbortController();
       const data = await this.tiles(tile.tileID.canonical, tile.abortController).catch(() => {});
-      tile.neighboringTiles = this._getNeighboringTiles(tile.tileID);
+      tile.neighboringTiles = getNeighboringTiles(tile.tileID);
       if (!data) {
         const err = new Error('Tile could not be loaded');
         err.status = 404; // will try to use the parent/child tile
@@ -48,7 +36,7 @@ class RasterDEMTileSource extends RasterTileSource {
           rawImageData,
           encoding: this.encoding
         };
-        const dem = await this.dispatcher.send('loadDEMTile', params);
+        const dem = await loadDEMTile(params);
         if (dem) {
           tile.dem = dem;
           tile.needsHillshadePrepare = true;
@@ -65,52 +53,6 @@ class RasterDEMTileSource extends RasterTileSource {
     }
   }
 
-  _getNeighboringTiles(tileID) {
-    const canonical = tileID.canonical;
-    const dim = 2 ** canonical.z;
-
-    const px = (canonical.x - 1 + dim) % dim;
-    const pxw = canonical.x === 0 ? tileID.wrap - 1 : tileID.wrap;
-    const nx = (canonical.x + 1 + dim) % dim;
-    const nxw = canonical.x + 1 === dim ? tileID.wrap + 1 : tileID.wrap;
-
-    const neighboringTiles = {};
-    // add adjacent tiles
-    neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y).key] = {
-      backfilled: false
-    };
-    neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y).key] = {
-      backfilled: false
-    };
-
-    // Add upper neighboringTiles
-    if (canonical.y > 0) {
-      neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y - 1).key] = {
-        backfilled: false
-      };
-      neighboringTiles[
-        new OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y - 1).key
-      ] = { backfilled: false };
-      neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y - 1).key] = {
-        backfilled: false
-      };
-    }
-    // Add lower neighboringTiles
-    if (canonical.y + 1 < dim) {
-      neighboringTiles[new OverscaledTileID(tileID.overscaledZ, pxw, canonical.z, px, canonical.y + 1).key] = {
-        backfilled: false
-      };
-      neighboringTiles[
-        new OverscaledTileID(tileID.overscaledZ, tileID.wrap, canonical.z, canonical.x, canonical.y + 1).key
-      ] = { backfilled: false };
-      neighboringTiles[new OverscaledTileID(tileID.overscaledZ, nxw, canonical.z, nx, canonical.y + 1).key] = {
-        backfilled: false
-      };
-    }
-
-    return neighboringTiles;
-  }
-
   unloadTile(tile) {
     if (tile.demTexture) this.map.painter.saveTileTexture(tile.demTexture);
     if (tile.fbo) {
@@ -124,4 +66,43 @@ class RasterDEMTileSource extends RasterTileSource {
   }
 }
 
+// biome-ignore lint/suspicious/useAwait: thread
+async function loadDEMTile({ uid, rawImageData, encoding }) {
+  return new DEMData(uid, rawImageData, encoding);
+}
+
 module.exports = RasterDEMTileSource;
+
+function getNeighboringTiles(tileID) {
+  const {
+    canonical: { x, y, z },
+    wrap,
+    overscaledZ
+  } = tileID;
+  const dim = 2 ** z;
+  const px = (x - 1 + dim) % dim;
+  const pxw = x === 0 ? wrap - 1 : wrap;
+  const nx = (x + 1 + dim) % dim;
+  const nxw = x + 1 === dim ? wrap + 1 : wrap;
+
+  const neighboringTiles = {
+    // add adjacent tiles
+    [calculateKey(pxw, overscaledZ, px, y)]: { backfilled: false },
+    [calculateKey(nxw, overscaledZ, nx, y)]: { backfilled: false }
+  };
+
+  // Add upper neighboringTiles
+  if (y > 0) {
+    neighboringTiles[calculateKey(pxw, overscaledZ, px, y - 1)] = { backfilled: false };
+    neighboringTiles[calculateKey(wrap, overscaledZ, x, y - 1)] = { backfilled: false };
+    neighboringTiles[calculateKey(nxw, overscaledZ, nx, y - 1)] = { backfilled: false };
+  }
+  // Add lower neighboringTiles
+  if (y + 1 < dim) {
+    neighboringTiles[calculateKey(pxw, overscaledZ, px, y + 1)] = { backfilled: false };
+    neighboringTiles[calculateKey(wrap, overscaledZ, x, y + 1)] = { backfilled: false };
+    neighboringTiles[calculateKey(nxw, overscaledZ, nx, y + 1)] = { backfilled: false };
+  }
+
+  return neighboringTiles;
+}

package/src/source/raster_tile_source.js

@@ -6,10 +6,9 @@ const TileBounds = require('./tile_bounds');
 const Texture = require('../render/texture');
 
 class RasterTileSource extends Evented {
-  constructor(id, options, dispatcher, eventedParent) {
+  constructor(id, options, eventedParent) {
     super();
     this.id = id;
-    this.dispatcher = dispatcher;
     this.setEventedParent(eventedParent);
 
     this.type = 'raster';
@@ -46,10 +45,6 @@ class RasterTileSource extends Evented {
     this.load();
   }
 
-  serialize() {
-    return Object.assign({}, this._options);
-  }
-
   hasTile(tileID) {
     return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
   }

package/src/source/resources/glyphs.js

@@ -4,7 +4,7 @@ module.exports = glyphCache;
 
 const MAX_GLYPH_ID = 65535;
 
-function glyphCache({ actor, mapId, parseGlyphs = parseGlyphPBF }) {
+function glyphCache({ loadGlyphRange: loadGlyphRangeFromStyle, parseGlyphs = parseGlyphPBF }) {
   const entries = {};
 
   return {
@@ -56,7 +56,7 @@ function glyphCache({ actor, mapId, parseGlyphs = parseGlyphPBF }) {
   }
 
   async function loadGlyphRange(entry, stack, range) {
-    const promise = (entry.requests[range] ??= actor.send('loadGlyphRange', { stack, range }, mapId));
+    const promise = (entry.requests[range] ??= loadGlyphRangeFromStyle({ stack, range }));
     const data = await promise;
     delete entry.requests[range];
     entry.ranges[range] = true;

package/src/source/resources/index.js

@@ -1,22 +1,16 @@
 const makeGlyphs = require('./glyphs');
-const makeImages = require('./images');
 
 module.exports = { resources };
 
-function resources(actor, mapId) {
-  const glyphs = makeGlyphs({ actor, mapId });
-  const images = makeImages({ actor, mapId });
+function resources(opts) {
+  const glyphs = makeGlyphs(opts);
 
   return {
     getGlyphs,
-    getImages
+    getImages: opts.getImages
   };
 
   function getGlyphs(params) {
     return glyphs.getGlyphs(params);
   }
-
-  function getImages(params) {
-    return images.getImages(params);
-  }
 }

package/src/source/rtl_text_plugin.js

@@ -1,26 +1,34 @@
-const { Event, Evented } = require('@mapwhit/events');
+const dynload = require('dynload');
 const browser = require('../util/browser');
 
 let pluginRequested = false;
-let pluginURL = null;
-let foregroundLoadComplete = false;
-
-const evented = new Evented();
+let pluginURL;
+let loading = false;
 
 let _completionCallback;
+const _loadedCallbacks = [];
+
+const rtlPlugin = {
+  clearRTLTextPlugin, // exported for testing
+  loadScript, // exported for testing
+  registerForPluginAvailability,
+  setRTLTextPlugin
+};
 
 function registerForPluginAvailability(callback) {
-  if (pluginURL) {
-    callback({ pluginURL: pluginURL, completionCallback: _completionCallback });
-  } else {
-    evented.once('pluginAvailable', callback);
+  if (plugin.isLoaded()) {
+    callback();
+    return;
   }
-  return callback;
+  _loadedCallbacks.push(callback);
+  loadRTLTextPlugin();
+  return () => _loadedCallbacks.splice(_loadedCallbacks.indexOf(callback), 1);
 }
 
 function clearRTLTextPlugin() {
+  _loadedCallbacks.length = 0;
   pluginRequested = false;
-  pluginURL = null;
+  pluginURL = undefined;
 }
 
 function setRTLTextPlugin(url, callback) {
@@ -31,35 +39,54 @@ function setRTLTextPlugin(url, callback) {
   pluginURL = browser.resolveURL(url);
   _completionCallback = error => {
     if (error) {
+      const msg = `RTL Text Plugin failed to load scripts from ${pluginURL}`;
       // Clear loaded state to allow retries
       clearRTLTextPlugin();
       if (callback) {
-        callback(error);
+        callback(new Error(msg));
       }
-    } else {
-      // Called once for each worker
-      foregroundLoadComplete = true;
     }
+    loading = false;
+    _completionCallback = undefined;
   };
-  evented.fire(new Event('pluginAvailable', { pluginURL: pluginURL, completionCallback: _completionCallback }));
+  loadRTLTextPlugin();
+}
+
+function loadRTLTextPlugin() {
+  if (pluginURL && !plugin.isLoaded() && _loadedCallbacks.length > 0 && !loading) {
+    // needs to be called as exported method for mock testing
+    loading = rtlPlugin.loadScript(pluginURL).catch(_completionCallback);
+  }
+}
+
+function registerRTLTextPlugin(loadedPlugin) {
+  if (plugin.isLoaded()) {
+    throw new Error('RTL text plugin already registered.');
+  }
+  plugin['applyArabicShaping'] = loadedPlugin.applyArabicShaping;
+  plugin['processBidirectionalText'] = loadedPlugin.processBidirectionalText;
+  plugin['processStyledBidirectionalText'] = loadedPlugin.processStyledBidirectionalText;
+
+  _completionCallback();
+  _loadedCallbacks.forEach(callback => callback());
+  _loadedCallbacks.length = 0;
+}
+
+globalThis.registerRTLTextPlugin ??= registerRTLTextPlugin;
+
+async function loadScript(url) {
+  const { promise, resolve, reject } = Promise.withResolvers();
+  const s = dynload(url);
+  s.onload = () => resolve();
+  s.onerror = () => reject(true);
+  return promise;
 }
 
-const plugin = {
+const plugin = (rtlPlugin.plugin = {
   applyArabicShaping: null,
   processBidirectionalText: null,
   processStyledBidirectionalText: null,
-  isLoaded: function () {
-    return (
-      foregroundLoadComplete || // Foreground: loaded if the completion callback returned successfully
-      plugin.applyArabicShaping != null
-    ); // Background: loaded if the plugin functions have been compiled
-  }
-};
+  isLoaded: () => plugin.applyArabicShaping != null
+});
 
-module.exports = {
-  registerForPluginAvailability,
-  clearRTLTextPlugin,
-  setRTLTextPlugin,
-  plugin,
-  evented
-};
+module.exports = rtlPlugin;

package/src/source/source.js

@@ -10,7 +10,6 @@ const { bindAll } = require('../util/object');
  * @param {Object} options Source options, specific to the source type (except for `options.type`, which is always
  * required).
  * @param {string} options.type The source type, matching the value of `name` used in {@link Style#addSourceType}.
- * @param {Dispatcher} dispatcher A {@link Dispatcher} instance, which can be used to send messages to the workers.
  *
  * @fires data with `{dataType: 'source', sourceDataType: 'metadata'}` to indicate that any necessary metadata
  * has been loaded so that it's okay to call `loadTile`; and with `{dataType: 'source', sourceDataType: 'content'}`
@@ -25,11 +24,11 @@ const { bindAll } = require('../util/object');
  * if they are floor-ed to the nearest integer.
  */
 
-const vector = require('../source/vector_tile_source');
-const raster = require('../source/raster_tile_source');
-const rasterDem = require('../source/raster_dem_tile_source');
-const geojson = require('../source/geojson_source');
-const image = require('../source/image_source');
+const vector = require('./vector_tile_source');
+const raster = require('./raster_tile_source');
+const rasterDem = require('./raster_dem_tile_source');
+const geojson = require('./geojson_source');
+const image = require('./image_source');
 
 const sourceTypes = {
   vector,
@@ -46,15 +45,14 @@ const sourceTypes = {
  * @param {Object} source A source definition object compliant with
  * [`mapbox-gl-style-spec`](https://www.mapbox.com/mapbox-gl-style-spec/#sources) or, for a third-party source type,
  * with that type's requirements.
- * @param {Dispatcher} dispatcher
  * @returns {Source}
  */
-function create(id, specification, dispatcher, eventedParent) {
-  const source = new sourceTypes[specification.type](id, specification, dispatcher, eventedParent);
-
-  if (source.id !== id) {
-    throw new Error(`Expected Source id to be ${id} instead of ${source.id}`);
-  }
+function create(id, specification, eventedParent, { resources, layerIndex, showTileBoundaries }) {
+  const source = new sourceTypes[specification.type](id, specification, eventedParent, {
+    resources,
+    layerIndex,
+    showTileBoundaries
+  });
 
   bindAll(['load', 'abort', 'unload', 'serialize', 'prepare'], source);
   return source;