@mapwhit/tilerenderer 0.52.0 → 1.0.0

package/src/source/geojson_source.js

@@ -2,6 +2,7 @@ const { Event, ErrorEvent, Evented } = require('@mapwhit/events');
 
 const EXTENT = require('../data/extent');
 const browser = require('../util/browser');
+const GeoJSONWorkerSource = require('./geojson_worker_source');
 
 /**
  * A source containing GeoJSON.
@@ -52,8 +53,9 @@ class GeoJSONSource extends Evented {
   #pendingDataEvents = new Set();
   #newData = false;
   #updateInProgress = false;
+  #worker;
 
-  constructor(id, options, dispatcher, eventedParent) {
+  constructor(id, options, eventedParent, { resources, layerIndex }) {
     super();
 
     this.id = id;
@@ -69,10 +71,9 @@ class GeoJSONSource extends Evented {
     this.reparseOverscaled = true;
     this._removed = false;
 
-    this.dispatcher = dispatcher;
     this.setEventedParent(eventedParent);
 
-    this._data = options.data;
+    this.data = options.data;
     this._options = Object.assign({}, options);
 
     if (options.maxzoom !== undefined) this.maxzoom = options.maxzoom;
@@ -107,6 +108,7 @@ class GeoJSONSource extends Evented {
       },
       options.workerOptions
     );
+    this.#worker = new GeoJSONWorkerSource(resources, layerIndex);
   }
 
   load() {
@@ -125,7 +127,7 @@ class GeoJSONSource extends Evented {
    * @returns {GeoJSONSource} this
    */
   setData(data) {
-    this._data = data;
+    this.data = data;
     this.#updateData();
     return this;
   }
@@ -142,7 +144,7 @@ class GeoJSONSource extends Evented {
       this.fire(new Event('dataloading', { dataType: 'source' }));
       while (this.#newData) {
         this.#newData = false;
-        await this._updateWorkerData(this._data);
+        await this._updateWorkerData(this.data);
       }
       this.#pendingDataEvents.forEach(sourceDataType =>
         this.fire(new Event('data', { dataType: 'source', sourceDataType }))
@@ -165,13 +167,9 @@ class GeoJSONSource extends Evented {
     if (!json) {
       throw new Error('no GeoJSON data');
     }
-    const options = { ...this.workerOptions, data: JSON.stringify(json) };
-    this.workerID ??= this.dispatcher.nextWorkerId();
+    const options = { ...this.workerOptions, data: json };
 
-    // target {this.type}.loadData rather than literally geojson.loadData,
-    // so that other geojson-like source types can easily reuse this
-    // implementation
-    await this.dispatcher.send(`${this.type}.loadData`, options, this.workerID);
+    return await this.#worker.loadData(options);
   }
 
   async loadTile(tile) {
@@ -185,14 +183,15 @@ class GeoJSONSource extends Evented {
       source: this.id,
       pixelRatio: browser.devicePixelRatio,
       showCollisionBoxes: this.map.showCollisionBoxes,
-      globalState: this.map.getGlobalState()
+      globalState: this.map.getGlobalState(),
+      justReloaded: tile.workerID != null,
+      painter: this.map.painter
     };
 
-    const justReloaded = tile.workerID != null;
-    tile.workerID ??= this.dispatcher.nextWorkerId(this.workerID);
-    const data = await this.dispatcher.send('loadTile', params, tile.workerID).finally(() => tile.unloadVectorData());
+    tile.workerID ??= true;
+    const data = await this.#worker.loadTile(params).finally(() => tile.unloadVectorData());
     if (!tile.aborted) {
-      tile.loadVectorData(data, this.map.painter, justReloaded);
+      tile.loadVectorData(data, this.map.painter);
     }
   }
 
@@ -206,14 +205,6 @@ class GeoJSONSource extends Evented {
 
   onRemove() {
     this._removed = true;
-    return this.dispatcher.send('removeSource', { type: this.type, source: this.id }, this.workerID);
-  }
-
-  serialize() {
-    return Object.assign({}, this._options, {
-      type: this.type,
-      data: this._data
-    });
   }
 
   hasTransition() {

package/src/source/geojson_worker_source.js

@@ -1,68 +1,14 @@
 const rewind = require('@mapwhit/geojson-rewind');
 const GeoJSONWrapper = require('./geojson_wrapper');
-const { fromVectorTileJs } = require('@mapwhit/vt-pbf');
 const { default: Supercluster } = require('supercluster');
 const { default: geojsonvt } = require('geojson-vt');
 const VectorTileWorkerSource = require('./vector_tile_worker_source');
 
-function loadGeoJSONTile(params) {
-  if (!this._geoJSONIndex) {
-    if (!this._createGeoJSONIndex) {
-      return; // we couldn't load the file
-    }
-
-    try {
-      this._geoJSONIndex = this._createGeoJSONIndex();
-    } finally {
-      this._createGeoJSONIndex = null;
-    }
-  }
-
-  const { z, x, y } = params.tileID.canonical;
-  const geoJSONTile = this._geoJSONIndex.getTile(z, x, y);
-  if (!geoJSONTile) {
-    return; // nothing in the given tile
-  }
-
-  const geojsonWrapper = new GeoJSONWrapper(geoJSONTile.features);
-
-  // Encode the geojson-vt tile into binary vector tile form.  This
-  // is a convenience that allows `FeatureIndex` to operate the same way
-  // across `VectorTileSource` and `GeoJSONSource` data.
-  let pbf = fromVectorTileJs(geojsonWrapper);
-  if (pbf.byteOffset !== 0 || pbf.byteLength !== pbf.buffer.byteLength) {
-    // Compatibility with node Buffer (https://github.com/mapbox/pbf/issues/35)
-    pbf = new Uint8Array(pbf);
-  }
-
-  return {
-    vectorTile: geojsonWrapper,
-    rawData: pbf.buffer
-  };
-}
-
 /**
  * The {@link WorkerSource} implementation that supports {@link GeoJSONSource}.
- * This class is designed to be easily reused to support custom source types
- * for data formats that can be parsed/converted into an in-memory GeoJSON
- * representation.  To do so, create it with
- * `new GeoJSONWorkerSource(resources, layerIndex, customLoadGeoJSONFunction)`.
- * For a full example, see [mapbox-gl-topojson](https://github.com/developmentseed/mapbox-gl-topojson).
  *
  */
 class GeoJSONWorkerSource extends VectorTileWorkerSource {
-  /**
-   * @param [loadGeoJSON] Optional method for custom loading/parsing of
-   * GeoJSON based on parameters passed from the main-thread Source.
-   * See {@link GeoJSONWorkerSource#loadGeoJSON}.
-   */
-  constructor(resources, layerIndex, loadGeoJSON) {
-    super(resources, layerIndex, loadGeoJSONTile);
-    if (loadGeoJSON) {
-      this.loadGeoJSON = loadGeoJSON;
-    }
-  }
-
   /**
    * Fetches (if appropriate), parses, and index geojson data into tiles. This
    * preparatory method must be called before {@link GeoJSONWorkerSource#loadTile}
@@ -76,7 +22,7 @@ class GeoJSONWorkerSource extends VectorTileWorkerSource {
    * @param callback
    */
   loadData(params) {
-    const data = this.loadGeoJSON(params);
+    const data = loadJSON(params.data);
     this._geoJSONIndex = null;
     this._createGeoJSONIndex = params.cluster
       ? () => {
@@ -89,20 +35,46 @@ class GeoJSONWorkerSource extends VectorTileWorkerSource {
         };
   }
 
-  /**
-   * Fetch and parse GeoJSON according to the given params.
-   *
-   * GeoJSON is expected as a literal (string or object) `params.data`.
-   *
-   * @param params
-   * @param [params.data] Literal GeoJSON data. Must be provided.
-   */
-  loadGeoJSON(params) {
-    try {
-      return JSON.parse(params.data);
-    } catch (e) {
-      throw new Error('Input data is not a valid GeoJSON object.');
+  getTile(tileID) {
+    if (!this._geoJSONIndex) {
+      if (!this._createGeoJSONIndex) {
+        return; // we couldn't load the file
+      }
+
+      try {
+        this._geoJSONIndex = this._createGeoJSONIndex();
+      } finally {
+        this._createGeoJSONIndex = null;
+      }
+    }
+    const { z, x, y } = tileID.canonical;
+    return this._geoJSONIndex.getTile(z, x, y);
+  }
+
+  loadVectorData({ tileID }) {
+    const geoJSONTile = this.getTile(tileID);
+    if (!geoJSONTile) {
+      return; // nothing in the given tile
     }
+
+    const vectorTile = new GeoJSONWrapper(geoJSONTile.features);
+
+    return {
+      vectorTile
+    };
+  }
+}
+
+/**
+ * Fetch and parse GeoJSON according to the given params.
+ *
+ * @param data Literal GeoJSON data. Must be provided.
+ */
+function loadJSON(data) {
+  try {
+    return typeof data === 'string' ? JSON.parse(data) : data;
+  } catch (e) {
+    throw new Error('Input data is not a valid GeoJSON object.');
   }
 }
 

package/src/source/geojson_wrapper.js

@@ -20,6 +20,14 @@ class FeatureWrapper {
     if ('id' in feature && !isNaN(feature.id)) {
       this.id = Number.parseInt(feature.id, 10);
     }
+
+    // fix geometry - it has to be at least array of 2 points
+    if (typeof this._feature.geometry[0] === 'number') {
+      this._feature.geometry = [this._feature.geometry];
+      if (this._feature.geometry.length === 1) {
+        this._feature.geometry.push(this._feature.geometry[0]);
+      }
+    }
   }
 
   get type() {
@@ -27,7 +35,7 @@ class FeatureWrapper {
   }
 
   get properties() {
-    return this._feature.tags;
+    return this._feature.tags ?? {};
   }
 
   get extent() {

package/src/source/image_source.js

@@ -2,7 +2,6 @@ const { getCoordinatesCenter } = require('../util/util');
 
 const { CanonicalTileID } = require('./tile_id');
 const LngLat = require('../geo/lng_lat');
-const { default: Point } = require('@mapbox/point-geometry');
 const { Event, ErrorEvent, Evented } = require('@mapwhit/events');
 const loadImage = require('../util/loader/image');
 const EXTENT = require('../data/extent');
@@ -44,10 +43,9 @@ class ImageSource extends Evented {
   /**
    * @private
    */
-  constructor(id, options, dispatcher, eventedParent) {
+  constructor(id, options, eventedParent) {
     super();
     this.id = id;
-    this.dispatcher = dispatcher;
     this.coordinates = options.coordinates;
 
     this.type = 'image';
@@ -125,10 +123,10 @@ class ImageSource extends Evented {
     // tile.
     const tileCoords = cornerZ0Coords.map(coord => {
       const zoomedCoord = coord.zoomTo(centerCoord.zoom);
-      return new Point(
-        Math.round((zoomedCoord.column - centerCoord.column) * EXTENT),
-        Math.round((zoomedCoord.row - centerCoord.row) * EXTENT)
-      );
+      return {
+        x: Math.round((zoomedCoord.column - centerCoord.column) * EXTENT),
+        y: Math.round((zoomedCoord.row - centerCoord.row) * EXTENT)
+      };
     });
 
     this._boundsArray = new RasterBoundsArray();
@@ -185,21 +183,13 @@ class ImageSource extends Evented {
     // single tile.
     if (this.tileID?.equals(tile.tileID.canonical)) {
       this.tiles[String(tile.tileID.wrap)] = tile;
-      tile.buckets = {};
+      tile.buckets = new Map();
     } else {
       tile.state = 'errored';
     }
     return Promise.resolve();
   }
 
-  serialize() {
-    return {
-      type: 'image',
-      url: this.options.url,
-      coordinates: this.coordinates
-    };
-  }
-
   hasTransition() {
     return false;
   }

package/src/source/query_features.js

@@ -20,14 +20,13 @@ function getPixelPosMatrix(transform, tileID) {
 function queryIncludes3DLayer(layers, styleLayers, sourceID) {
   if (layers) {
     for (const layerID of layers) {
-      const layer = styleLayers[layerID];
+      const layer = styleLayers.get(layerID);
       if (layer && layer.source === sourceID && layer.type === 'fill-extrusion') {
         return true;
       }
     }
-  } else {
-    for (const key in styleLayers) {
-      const layer = styleLayers[key];
+  } else if (styleLayers) {
+    for (const layer of styleLayers.values()) {
       if (layer.source === sourceID && layer.type === 'fill-extrusion') {
         return true;
       }
@@ -129,7 +128,7 @@ function queryRenderedSymbols(styleLayers, sourceCaches, queryGeometry, params,
   for (const layerName in result) {
     result[layerName].forEach(featureWrapper => {
       const feature = featureWrapper.feature;
-      const layer = styleLayers[layerName];
+      const layer = styleLayers.get(layerName);
       const sourceCache = sourceCaches[layer.source];
       const state = sourceCache.getFeatureState(feature.layer['source-layer'], feature.id);
       feature.source = feature.layer.source;

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;