@mapwhit/tilerenderer 0.47.1

package/src/source/raster_tile_source.js

@@ -0,0 +1,126 @@
+const { pick } = require('../util/object');
+const loadImage = require('../util/loader/image');
+const { Event, ErrorEvent, Evented } = require('../util/evented');
+const loadTileJSON = require('./load_tilejson');
+const TileBounds = require('./tile_bounds');
+const Texture = require('../render/texture');
+
+class RasterTileSource extends Evented {
+  constructor(id, options, dispatcher, eventedParent) {
+    super();
+    this.id = id;
+    this.dispatcher = dispatcher;
+    this.setEventedParent(eventedParent);
+
+    this.type = 'raster';
+    this.minzoom = 0;
+    this.maxzoom = 22;
+    this.roundZoom = true;
+    this.scheme = 'xyz';
+    this.tileSize = 512;
+    this._loaded = false;
+
+    this._options = Object.assign({}, options);
+    Object.assign(this, pick(options, ['url', 'scheme', 'tileSize']));
+  }
+
+  load() {
+    this.fire(new Event('dataloading', { dataType: 'source' }));
+    loadTileJSON(this._options, (err, tileJSON) => {
+      if (err) {
+        this.fire(new ErrorEvent(err));
+      } else if (tileJSON) {
+        Object.assign(this, tileJSON);
+        if (tileJSON.bounds) this.tileBounds = new TileBounds(tileJSON.bounds, this.minzoom, this.maxzoom);
+
+        // `content` is included here to prevent a race condition where `Style#_updateSources` is called
+        // before the TileJSON arrives. this makes sure the tiles needed are loaded once TileJSON arrives
+        // ref: https://github.com/mapbox/mapbox-gl-js/pull/4347#discussion_r104418088
+        this.fire(new Event('data', { dataType: 'source', sourceDataType: 'metadata' }));
+        this.fire(new Event('data', { dataType: 'source', sourceDataType: 'content' }));
+      }
+    });
+  }
+
+  onAdd(map) {
+    this.map = map;
+    this.load();
+  }
+
+  serialize() {
+    return Object.assign({}, this._options);
+  }
+
+  hasTile(tileID) {
+    return !this.tileBounds || this.tileBounds.contains(tileID.canonical);
+  }
+
+  loadTile(tile, callback) {
+    const done = (err, img) => {
+      delete tile.request;
+
+      if (tile.aborted) {
+        tile.state = 'unloaded';
+        callback(null);
+      } else if (err) {
+        tile.state = 'errored';
+        callback(err);
+      } else if (img) {
+        const context = this.map.painter.context;
+        const gl = context.gl;
+        tile.texture = this.map.painter.getTileTexture(img.width);
+        if (tile.texture) {
+          tile.texture.update(img, { useMipmap: true });
+        } else {
+          tile.texture = new Texture(context, img, gl.RGBA, { useMipmap: true });
+          tile.texture.bind(gl.LINEAR, gl.CLAMP_TO_EDGE, gl.LINEAR_MIPMAP_NEAREST);
+
+          if (context.extTextureFilterAnisotropic) {
+            gl.texParameterf(
+              gl.TEXTURE_2D,
+              context.extTextureFilterAnisotropic.TEXTURE_MAX_ANISOTROPY_EXT,
+              context.extTextureFilterAnisotropicMax
+            );
+          }
+        }
+
+        tile.state = 'loaded';
+
+        callback(null);
+      }
+    };
+
+    tile.abortController = new window.AbortController();
+    this.tiles(tile.tileID.canonical, tile.abortController)
+      .catch(() => {})
+      .then(data => {
+        if (!data) {
+          const err = new Error('Tile could not be loaded');
+          err.status = 404; // will try to use the parent/child tile
+          return done(err);
+        }
+        tile.request = loadImage(data, done);
+      });
+  }
+
+  abortTile(tile, callback) {
+    if (tile.abortController) {
+      tile.aborted = true;
+      tile.abortController.abort();
+      delete tile.abortController;
+      delete tile.request;
+    }
+    callback();
+  }
+
+  unloadTile(tile, callback) {
+    if (tile.texture) this.map.painter.saveTileTexture(tile.texture);
+    callback();
+  }
+
+  hasTransition() {
+    return false;
+  }
+}
+
+module.exports = RasterTileSource;

package/src/source/rtl_text_plugin.js

@@ -0,0 +1,63 @@
+const { Event, Evented } = require('../util/evented');
+
+let pluginRequested = false;
+let pluginURL = null;
+let foregroundLoadComplete = false;
+
+const evented = new Evented();
+
+let _completionCallback;
+
+function registerForPluginAvailability(callback) {
+  if (pluginURL) {
+    callback({ pluginURL: pluginURL, completionCallback: _completionCallback });
+  } else {
+    evented.once('pluginAvailable', callback);
+  }
+  return callback;
+}
+
+function clearRTLTextPlugin() {
+  pluginRequested = false;
+  pluginURL = null;
+}
+
+function setRTLTextPlugin(url, callback) {
+  if (pluginRequested) {
+    throw new Error('setRTLTextPlugin cannot be called multiple times.');
+  }
+  pluginRequested = true;
+  pluginURL = url;
+  _completionCallback = error => {
+    if (error) {
+      // Clear loaded state to allow retries
+      clearRTLTextPlugin();
+      if (callback) {
+        callback(error);
+      }
+    } else {
+      // Called once for each worker
+      foregroundLoadComplete = true;
+    }
+  };
+  evented.fire(new Event('pluginAvailable', { pluginURL: pluginURL, completionCallback: _completionCallback }));
+}
+
+const plugin = {
+  applyArabicShaping: null,
+  processBidirectionalText: 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
+  }
+};
+
+module.exports = {
+  registerForPluginAvailability,
+  clearRTLTextPlugin,
+  setRTLTextPlugin,
+  plugin,
+  evented
+};

package/src/source/source.js

@@ -0,0 +1,75 @@
+const { bindAll } = require('../util/object');
+
+/**
+ * The `Source` interface must be implemented by each source type, including "core" types (`vector`, `raster`,
+ * `video`, etc.) and all custom, third-party types.
+ *
+ * @private
+ *
+ * @param {string} id The id for the source. Must not be used by any existing source.
+ * @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'}`
+ * to indicate that the source data has changed, so that any current caches should be flushed.
+ * @property {string} id The id for the source.  Must match the id passed to the constructor.
+ * @property {number} minzoom
+ * @property {number} maxzoom
+ * @property {boolean} isTileClipped `false` if tiles can be drawn outside their boundaries, `true` if they cannot.
+ * @property {boolean} reparseOverscaled `true` if tiles should be sent back to the worker for each overzoomed zoom
+ * level, `false` if not.
+ * @property {boolean} roundZoom `true` if zoom levels are rounded to the nearest integer in the source data, `false`
+ * 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 sourceTypes = {
+  vector,
+  raster,
+  'raster-dem': rasterDem,
+  geojson,
+  image
+};
+
+/*
+ * Creates a tiled data source instance given an options object.
+ *
+ * @param id
+ * @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}`);
+  }
+
+  bindAll(['load', 'abort', 'unload', 'serialize', 'prepare'], source);
+  return source;
+}
+
+function getType(name) {
+  return sourceTypes[name];
+}
+
+function setType(name, type) {
+  sourceTypes[name] = type;
+}
+
+module.exports = {
+  create,
+  getType,
+  setType
+};