@loaders.gl/mvt 4.3.0-alpha.1 → 4.3.0-alpha.2

package/dist/index.cjs

@@ -35,10 +35,10 @@ var __publicField = (obj, key, value) => {
 // dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  GeoJSONTileSource: () => GeoJSONTileSource,
   MVTLoader: () => MVTLoader,
   MVTSource: () => MVTSource,
   MVTWorkerLoader: () => MVTWorkerLoader,
+  TableTileSource: () => TableTileSource,
   TileJSONLoader: () => TileJSONLoader
 });
 module.exports = __toCommonJS(dist_exports);
@@ -59,6 +59,39 @@ function signedArea(ring) {
   }
   return sum;
 }
+function convertToLocalCoordinates(coordinates, extent) {
+  if (Array.isArray(coordinates[0])) {
+    for (const subcoords of coordinates) {
+      convertToLocalCoordinates(subcoords, extent);
+    }
+    return;
+  }
+  const p = coordinates;
+  p[0] /= extent;
+  p[1] /= extent;
+}
+function convertToLocalCoordinatesFlat(data, extent) {
+  for (let i = 0, il = data.length; i < il; ++i) {
+    data[i] /= extent;
+  }
+}
+function projectToLngLat(line, tileIndex, extent) {
+  if (typeof line[0][0] !== "number") {
+    for (const point of line) {
+      projectToLngLat(point, tileIndex, extent);
+    }
+    return;
+  }
+  const size = extent * Math.pow(2, tileIndex.z);
+  const x0 = extent * tileIndex.x;
+  const y0 = extent * tileIndex.y;
+  for (let j = 0; j < line.length; j++) {
+    const p = line[j];
+    p[0] = (p[0] + x0) * 360 / size - 180;
+    const y2 = 180 - (p[1] + y0) * 360 / size;
+    p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
+  }
+}
 function projectToLngLatFlat(data, tileIndex, extent) {
   const { x, y, z } = tileIndex;
   const size = extent * Math.pow(2, z);
@@ -168,37 +201,30 @@ var VectorTileFeature = class {
     this._geometryInfo = geometryInfo;
     pbf.readFields(readFeature, this, end);
   }
-  toGeoJSON(options) {
+  toGeoJSONFeature(coordinates, tileIndex) {
     const coords = this.loadGeometry();
-    if (typeof options === "function") {
-      return _toGeoJSON(this, coords, options);
-    }
-    const { x, y, z } = options;
-    const size = this.extent * Math.pow(2, z);
-    const x0 = this.extent * x;
-    const y0 = this.extent * y;
-    function project(line) {
-      for (let j = 0; j < line.length; j++) {
-        const p = line[j];
-        p[0] = (p[0] + x0) * 360 / size - 180;
-        const y2 = 180 - (p[1] + y0) * 360 / size;
-        p[1] = 360 / Math.PI * Math.atan(Math.exp(y2 * Math.PI / 180)) - 90;
-      }
+    switch (coordinates) {
+      case "wgs84":
+        return _toGeoJSONFeature(this, coords, (line) => projectToLngLat(line, tileIndex, this.extent));
+      default:
+        return _toGeoJSONFeature(this, coords, convertToLocalCoordinates);
     }
-    return _toGeoJSON(this, coords, project);
   }
   /**
    *
    * @param options
    * @returns
    */
-  toBinaryCoordinates(options) {
-    if (typeof options === "function") {
-      return this._toBinaryCoordinates(options);
+  toBinaryFeature(coordinates, tileIndex) {
+    const geom = this.loadFlatGeometry();
+    switch (coordinates) {
+      case "wgs84":
+        return this._toBinaryCoordinates(geom, (coords) => projectToLngLatFlat(coords, tileIndex, this.extent));
+      default:
+        return this._toBinaryCoordinates(geom, convertToLocalCoordinatesFlat);
     }
-    const tileIndex = options;
-    return this._toBinaryCoordinates((data) => projectToLngLatFlat(data, tileIndex, this.extent));
   }
+  /** Read a bounding box from the feature */
   // eslint-disable-next-line max-statements
   bbox() {
     const pbf = this._pbf;
@@ -242,10 +268,9 @@ var VectorTileFeature = class {
    * @param transform
    * @returns result
    */
-  _toBinaryCoordinates(transform) {
-    const geom = this.loadFlatGeometry();
+  _toBinaryCoordinates(geom, transform) {
     let geometry;
-    transform(geom.data, this);
+    transform(geom.data, this.extent);
     const coordLength = 2;
     switch (this.type) {
       case 1:
@@ -322,6 +347,28 @@ var VectorTileFeature = class {
       lines.push(line);
     return lines;
   }
+  /**
+   * Expands the protobuf data to an intermediate Flat GeoJSON
+   * data format, which maps closely to the binary data buffers.
+   * It is similar to GeoJSON, but rather than storing the coordinates
+   * in multidimensional arrays, we have a 1D `data` with all the
+   * coordinates, and then index into this using the `indices`
+   * parameter, e.g.
+   *
+   * geometry: {
+   *   type: 'Point', data: [1,2], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'LineString', data: [1,2,3,4,...], indices: [0]
+   * }
+   * geometry: {
+   *   type: 'Polygon', data: [1,2,3,4,...], indices: [[0, 2]]
+   * }
+   * Thus the indices member lets us look up the relevant range
+   * from the data array.
+   * The Multi* versions of the above types share the same data
+   * structure, just with multiple elements in the indices array
+   */
   // eslint-disable-next-line complexity, max-statements
   loadFlatGeometry() {
     const pbf = this._pbf;
@@ -364,7 +411,7 @@ var VectorTileFeature = class {
   }
 };
 __publicField(VectorTileFeature, "types", ["Unknown", "Point", "LineString", "Polygon"]);
-function _toGeoJSON(vtFeature, coords, transform) {
+function _toGeoJSONFeature(vtFeature, coords, transform) {
   let type = VectorTileFeature.types[vtFeature.type];
   let i;
   let j;
@@ -376,19 +423,19 @@ function _toGeoJSON(vtFeature, coords, transform) {
         points[i] = coords[i][0];
       }
       coordinates = points;
-      transform(coordinates, vtFeature);
+      transform(coordinates, vtFeature.extent);
       break;
     case 2:
       coordinates = coords;
       for (i = 0; i < coordinates.length; i++) {
-        transform(coordinates[i], vtFeature);
+        transform(coordinates[i], vtFeature.extent);
       }
       break;
     case 3:
       coordinates = classifyRings(coords);
       for (i = 0; i < coordinates.length; i++) {
         for (j = 0; j < coordinates[i].length; j++) {
-          transform(coordinates[i][j], vtFeature);
+          transform(coordinates[i][j], vtFeature.extent);
         }
       }
       break;
@@ -409,7 +456,8 @@ function _toGeoJSON(vtFeature, coords, transform) {
     properties: vtFeature.properties
   };
   if (vtFeature.id !== null) {
-    result.id = vtFeature.id;
+    result.properties ||= {};
+    result.properties.id = vtFeature.id;
   }
   return result;
 }
@@ -627,10 +675,7 @@ function checkOptions(options) {
   return options.mvt;
 }
 function getDecodedFeature(feature, options, layerName) {
-  const decodedFeature = feature.toGeoJSON(
-    // @ts-expect-error What is going on here?
-    options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinates
-  );
+  const decodedFeature = feature.toGeoJSONFeature(options.coordinates || "local", options.tileIndex);
   if (options.layerProperty) {
     decodedFeature.properties ||= {};
     decodedFeature.properties[options.layerProperty] = layerName;
@@ -638,32 +683,15 @@ function getDecodedFeature(feature, options, layerName) {
   return decodedFeature;
 }
 function getDecodedFeatureBinary(feature, options, layerName) {
-  const decodedFeature = feature.toBinaryCoordinates(
-    // @ts-expect-error
-    options.coordinates === "wgs84" ? options.tileIndex : transformToLocalCoordinatesBinary
-  );
+  const decodedFeature = feature.toBinaryFeature(options.coordinates || "local", options.tileIndex);
   if (options.layerProperty && decodedFeature.properties) {
     decodedFeature.properties[options.layerProperty] = layerName;
   }
   return decodedFeature;
 }
-function transformToLocalCoordinates(line, feature) {
-  const { extent } = feature;
-  for (let i = 0; i < line.length; i++) {
-    const p = line[i];
-    p[0] /= extent;
-    p[1] /= extent;
-  }
-}
-function transformToLocalCoordinatesBinary(data, feature) {
-  const { extent } = feature;
-  for (let i = 0, il = data.length; i < il; ++i) {
-    data[i] /= extent;
-  }
-}
 
 // dist/mvt-loader.js
-var VERSION = true ? "4.2.0" : "latest";
+var VERSION = true ? "4.3.0-alpha.1" : "latest";
 var MVTWorkerLoader = {
   dataType: null,
   batchType: null,
@@ -905,7 +933,7 @@ function attributeTypeToFieldType(aType) {
 }
 
 // dist/tilejson-loader.js
-var VERSION2 = true ? "4.2.0" : "latest";
+var VERSION2 = true ? "4.3.0-alpha.1" : "latest";
 var TileJSONLoader = {
   dataType: null,
   batchType: null,
@@ -985,8 +1013,8 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   getTileMIMEType() {
     return this.mimeType;
   }
-  async getTile(tileParams) {
-    const { x, y, z } = tileParams;
+  async getTile(parameters) {
+    const { x, y, z } = parameters;
     const tileUrl = this.getTileURL(x, y, z);
     const response = await this.fetch(tileUrl);
     if (!response.ok) {
@@ -997,8 +1025,8 @@ var MVTSource = class extends import_loader_utils2.DataSource {
   }
   // Tile Source interface implementation: deck.gl compatible API
   // TODO - currently only handles image tiles, not vector tiles
-  async getTileData(tileParams) {
-    const { x, y, z } = tileParams.index;
+  async getTileData(parameters) {
+    const { x, y, z } = parameters.index;
     const arrayBuffer = await this.getTile({ x, y, z, layers: [] });
     if (arrayBuffer === null) {
       return null;
@@ -1078,7 +1106,12 @@ function stringHash(s) {
   return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
 }
 
-// dist/lib/geojsonvt/simplify.js
+// dist/table-tile-source.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_schema = require("@loaders.gl/schema");
+var import_stats = require("@probe.gl/stats");
+
+// dist/lib/vector-tiler/simplify.js
 function simplify(coords, first, last, sqTolerance) {
   let maxSqDist = sqTolerance;
   const mid = last - first >> 1;
@@ -1127,7 +1160,7 @@ function getSqSegDist(px, py, x, y, bx, by) {
   return dx * dx + dy * dy;
 }
 
-// dist/lib/geojsonvt/feature.js
+// dist/lib/vector-tiler/feature.js
 function createFeature(id, type, geom, tags) {
   const feature = {
     // eslint-disable-next-line
@@ -1164,7 +1197,7 @@ function calcLineBBox(feature, geom) {
   }
 }
 
-// dist/lib/geojsonvt/convert.js
+// dist/lib/vector-tiler/convert.js
 function convert(data, options) {
   const features = [];
   if (data.type === "FeatureCollection") {
@@ -1277,7 +1310,7 @@ function projectY(y) {
   return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
 }
 
-// dist/lib/geojsonvt/clip.js
+// dist/lib/vector-tiler/clip.js
 function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
   k1 /= scale;
   k2 /= scale;
@@ -1442,7 +1475,7 @@ function intersectY(out, ax, ay, bx, by, y) {
   return t;
 }
 
-// dist/lib/geojsonvt/wrap.js
+// dist/lib/vector-tiler/wrap.js
 function wrap(features, options) {
   const buffer = options.buffer / options.extent;
   let merged = features;
@@ -1499,7 +1532,7 @@ function shiftCoords(points, offset) {
   return newPoints;
 }
 
-// dist/lib/geojsonvt/transform.js
+// dist/lib/vector-tiler/transform.js
 function transformTile(tile, extent) {
   if (tile.transformed) {
     return tile;
@@ -1532,7 +1565,7 @@ function transformPoint(x, y, extent, z2, tx, ty) {
   return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
 }
 
-// dist/lib/geojsonvt/tile.js
+// dist/lib/vector-tiler/tile.js
 function createTile(features, z, tx, ty, options) {
   const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
   const tile = {
@@ -1638,57 +1671,46 @@ function rewind(ring, clockwise) {
   }
 }
 
-// dist/geojson-tile-source.js
-var _GeoJSONTileSource = class {
+// dist/table-tile-source.js
+var _TableTileSource = class {
+  /** Stats for this TableTileSource */
+  stats = new import_stats.Stats({
+    id: "table-tile-source",
+    stats: [new import_stats.Stat("tiles", "count"), new import_stats.Stat("features", "count")]
+  });
+  /** MIME type of the tiles emitted by this tile source */
   mimeType = "application/vnd.mapbox-vector-tile";
-  options;
-  // tiles and tileCoords are part of the public API
+  localCoordinates = true;
+  /** The props that this tile source was created with */
+  props;
+  /* Schema of the data */
+  schema = null;
+  /** Map of generated tiles, indexed by stringified tile coordinates */
   tiles = {};
+  /** Array of tile coordinates */
   tileCoords = [];
-  stats = {};
-  total = 0;
-  /** Sync methods can be called: the input data promise has been resolved and initial top-level tiling is done */
+  /** Input data has loaded, initial top-level tiling is done, sync methods can now be called */
   ready;
-  constructor(data, options) {
-    this.options = { ..._GeoJSONTileSource.defaultOptions, ...options };
+  /** Metadata for the tile source (generated TileJSON/tilestats */
+  metadata;
+  constructor(table, props) {
+    this.props = { ..._TableTileSource.defaultProps, ...props };
     this.getTileData = this.getTileData.bind(this);
-    this.ready = this.initializeTilesAsync(data);
-  }
-  async initializeTilesAsync(dataPromise) {
-    const data = await dataPromise;
-    this.initializeTilesSync(data);
-  }
-  initializeTilesSync(data) {
-    const options = this.options;
-    const debug = options.debug;
-    if (debug)
-      console.time("preprocess data");
-    if (this.options.maxZoom < 0 || this.options.maxZoom > 24) {
-      throw new Error("maxZoom should be in the 0-24 range");
-    }
-    if (options.promoteId && this.options.generateId) {
-      throw new Error("promoteId and generateId cannot be used together.");
-    }
-    let features = convert(data, options);
-    if (debug) {
-      console.timeEnd("preprocess data");
-      console.log("index: maxZoom: %d, maxPoints: %d", options.indexMaxZoom, options.indexMaxPoints);
-      console.time("generate tiles");
-    }
-    features = wrap(features, this.options);
-    if (features.length) {
-      this.splitTile(features, 0, 0, 0);
-    }
-    if (debug) {
-      if (features.length) {
-        console.log("features: %d, points: %d", this.tiles[0].numFeatures, this.tiles[0].numPoints);
-      }
-      console.timeEnd("generate tiles");
-      console.log("tiles generated:", this.total, JSON.stringify(this.stats));
-    }
+    this.ready = this.initializeTilesAsync(table);
+    this.metadata = this.getMetadata();
+  }
+  async initializeTilesAsync(tablePromise) {
+    const table = await tablePromise;
+    this.schema = (0, import_schema.deduceTableSchema)(table);
+    this.createRootTiles(table);
   }
   async getMetadata() {
-    return {};
+    await this.ready;
+    return { schema: this.schema, minZoom: 0, maxZoom: this.props.maxZoom };
+  }
+  async getSchema() {
+    await this.ready;
+    return this.schema;
   }
   /**
    * Get a tile at the specified index
@@ -1698,6 +1720,7 @@ var _GeoJSONTileSource = class {
   async getVectorTile(tileIndex) {
     await this.ready;
     const table = this.getTileSync(tileIndex);
+    import_loader_utils3.log.info(2, "getVectorTile", tileIndex, table)();
     return table;
   }
   async getTile(tileIndex) {
@@ -1706,7 +1729,8 @@ var _GeoJSONTileSource = class {
   }
   async getTileData(tileParams) {
     const { x, y, z } = tileParams.index;
-    return await this.getVectorTile({ x, y, z });
+    const tile = await this.getVectorTile({ x, y, z });
+    return (tile == null ? void 0 : tile.features) || [];
   }
   // Implementation
   /**
@@ -1718,7 +1742,38 @@ var _GeoJSONTileSource = class {
     if (!rawTile) {
       return null;
     }
-    return convertToGeoJSONTable(rawTile, this.options.extent);
+    return convertToGeoJSONTable(rawTile, {
+      coordinates: this.props.coordinates,
+      tileIndex,
+      extent: this.props.extent
+    });
+  }
+  /**
+   * Create the initial tiles
+   * @note the tiles stores all the features together with additional data
+   */
+  createRootTiles(table) {
+    if (this.props.maxZoom < 0 || this.props.maxZoom > 24) {
+      throw new Error("maxZoom should be in the 0-24 range");
+    }
+    if (this.props.promoteId && this.props.generateId) {
+      throw new Error("promoteId and generateId cannot be used together.");
+    }
+    import_loader_utils3.log.log(1, "TableTileSource creating root tiles", this.props)();
+    import_loader_utils3.log.time(1, "preprocess table")();
+    let features = convert(table, this.props);
+    import_loader_utils3.log.timeEnd(1, "preprocess table")();
+    import_loader_utils3.log.time(1, "generate tiles")();
+    features = wrap(features, this.props);
+    if (features.length === 0) {
+      import_loader_utils3.log.log(1, "TableTileSource: no features generated")();
+      return;
+    }
+    this.splitTile(features, 0, 0, 0);
+    const rootTile = this.tiles[0];
+    import_loader_utils3.log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+    import_loader_utils3.log.timeEnd(1, "generate tiles")();
+    import_loader_utils3.log.log(1, `TableTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
   }
   /**
    * Return geojsonvt-style "half formed" vector tile
@@ -1728,7 +1783,7 @@ var _GeoJSONTileSource = class {
   getRawTile(tileIndex) {
     const { z, y } = tileIndex;
     let { x } = tileIndex;
-    const { extent, debug } = this.options;
+    const { extent } = this.props;
     if (z < 0 || z > 24) {
       return null;
     }
@@ -1738,8 +1793,7 @@ var _GeoJSONTileSource = class {
     if (this.tiles[id]) {
       return transformTile(this.tiles[id], extent);
     }
-    if (debug > 1)
-      console.log("drilling down to z%d-%d-%d", z, x, y);
+    import_loader_utils3.log.log(import_loader_utils3.log, "drilling down to z%d-%d-%d", z, x, y)();
     let z0 = z;
     let x0 = x;
     let y0 = y;
@@ -1753,14 +1807,10 @@ var _GeoJSONTileSource = class {
     if (!parent || !parent.source) {
       return null;
     }
-    if (debug > 1) {
-      console.log("found parent tile z%d-%d-%d", z0, x0, y0);
-      console.time("drilling down");
-    }
+    import_loader_utils3.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+    import_loader_utils3.log.time(1, "drilling down")();
     this.splitTile(parent.source, z0, x0, y0, z, x, y);
-    if (debug > 1) {
-      console.timeEnd("drilling down");
-    }
+    import_loader_utils3.log.timeEnd(1, "drilling down")();
     return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
   }
   /**
@@ -1769,13 +1819,11 @@ var _GeoJSONTileSource = class {
    * @param cz, cx, and cy are the coordinates of the target tile
    *
    * If no target tile is specified, splitting stops when we reach the maximum
-   * zoom or the number of points is low as specified in the options.
+   * zoom or the number of points is low as specified in the props.
    */
   // eslint-disable-next-line max-params, max-statements, complexity
   splitTile(features, z, x, y, cz, cx, cy) {
     const stack = [features, z, x, y];
-    const options = this.options;
-    const debug = options.debug;
     while (stack.length) {
       y = stack.pop();
       x = stack.pop();
@@ -1785,38 +1833,39 @@ var _GeoJSONTileSource = class {
       const id = toID(z, x, y);
       let tile = this.tiles[id];
       if (!tile) {
-        if (debug > 1) {
-          console.time("creation");
-        }
-        tile = this.tiles[id] = createTile(features, z, x, y, options);
+        import_loader_utils3.log.time(2, "tile creation")();
+        tile = this.tiles[id] = createTile(features, z, x, y, this.props);
         this.tileCoords.push({ z, x, y });
-        if (debug) {
-          if (debug > 1) {
-            console.log("tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified);
-            console.timeEnd("creation");
-          }
-          const key = `z${z}`;
-          this.stats[key] = (this.stats[key] || 0) + 1;
-          this.total++;
-        }
+        const key = `z${z}`;
+        let stat = this.stats.get(key, "count");
+        stat.incrementCount();
+        stat = this.stats.get("total");
+        stat.incrementCount();
+        stat = _TableTileSource.stats.get(key, "count");
+        stat.incrementCount();
+        stat = _TableTileSource.stats.get("total");
+        stat.incrementCount();
+        import_loader_utils3.log.log(2, "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)", z, x, y, tile.numFeatures, tile.numPoints, tile.numSimplified)();
+        import_loader_utils3.log.timeEnd(2, "tile creation")();
       }
       tile.source = features;
       if (cz === void 0) {
-        if (z === options.indexMaxZoom || tile.numPoints <= options.indexMaxPoints)
+        if (z === this.props.indexMaxZoom || tile.numPoints <= this.props.maxPointsPerTile) {
           continue;
-      } else if (z === options.maxZoom || z === cz) {
+        }
+      } else if (z === this.props.maxZoom || z === cz) {
         continue;
       } else if (cz !== void 0) {
         const zoomSteps = cz - z;
-        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps)
+        if (x !== cx >> zoomSteps || y !== cy >> zoomSteps) {
           continue;
+        }
       }
       tile.source = null;
       if (features.length === 0)
         continue;
-      if (debug > 1)
-        console.time("clipping");
-      const k1 = 0.5 * options.buffer / options.extent;
+      import_loader_utils3.log.time(2, "clipping tile")();
+      const k1 = 0.5 * this.props.buffer / this.props.extent;
       const k2 = 0.5 - k1;
       const k3 = 0.5 + k1;
       const k4 = 1 + k1;
@@ -1824,21 +1873,20 @@ var _GeoJSONTileSource = class {
       let bl = null;
       let tr = null;
       let br = null;
-      let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, options);
-      let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, options);
+      let left = clip(features, z2, x - k1, x + k3, 0, tile.minX, tile.maxX, this.props);
+      let right = clip(features, z2, x + k2, x + k4, 0, tile.minX, tile.maxX, this.props);
       features = null;
       if (left) {
-        tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        tl = clip(left, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+        bl = clip(left, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
         left = null;
       }
       if (right) {
-        tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, options);
-        br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, options);
+        tr = clip(right, z2, y - k1, y + k3, 1, tile.minY, tile.maxY, this.props);
+        br = clip(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.props);
         right = null;
       }
-      if (debug > 1)
-        console.timeEnd("clipping");
+      import_loader_utils3.log.timeEnd(2, "clipping tile")();
       stack.push(tl || [], z + 1, x * 2, y * 2);
       stack.push(bl || [], z + 1, x * 2, y * 2 + 1);
       stack.push(tr || [], z + 1, x * 2 + 1, y * 2);
@@ -1846,13 +1894,15 @@ var _GeoJSONTileSource = class {
     }
   }
 };
-var GeoJSONTileSource = _GeoJSONTileSource;
-__publicField(GeoJSONTileSource, "defaultOptions", {
+var TableTileSource = _TableTileSource;
+__publicField(TableTileSource, "defaultProps", {
+  coordinates: "wgs84",
+  // coordinates in tile coordinates or lng/lat
   maxZoom: 14,
   // max zoom to preserve detail on
   indexMaxZoom: 5,
   // max zoom in the tile index
-  indexMaxPoints: 1e5,
+  maxPointsPerTile: 1e5,
   // max number of points per tile in the tile index
   tolerance: 3,
   // simplification tolerance (higher means simpler)
@@ -1870,10 +1920,15 @@ __publicField(GeoJSONTileSource, "defaultOptions", {
   debug: 0
   // logging level (0, 1 or 2)
 });
+/** Global stats for all TableTileSources */
+__publicField(TableTileSource, "stats", new import_stats.Stats({
+  id: "table-tile-source-all",
+  stats: [new import_stats.Stat("count", "tiles"), new import_stats.Stat("count", "features")]
+}));
 function toID(z, x, y) {
   return ((1 << z) * y + x) * 32 + z;
 }
-function convertToGeoJSONTable(vtTile, extent) {
+function convertToGeoJSONTable(vtTile, props) {
   const features = [];
   for (const rawFeature of vtTile.features) {
     if (!rawFeature || !rawFeature.geometry) {
@@ -1912,17 +1967,31 @@ function convertToGeoJSONTable(vtTile, extent) {
       default:
         continue;
     }
-    coordinates = toLngLat(coordinates, extent);
+    switch (props.coordinates) {
+      case "EPSG:4326":
+      case "wgs84":
+        projectToLngLat(coordinates, props.tileIndex, props.extent);
+        break;
+      case "local":
+        convertToLocalCoordinates(coordinates, props.extent);
+        break;
+      default:
+        throw new Error(`Unsupported CRS ${props.coordinates}`);
+    }
     const feature = {
       type: "Feature",
       geometry: {
         type,
         coordinates
       },
-      properties: rawFeature.tags || {}
+      properties: rawFeature.tags || {},
+      id: rawFeature.id
     };
     features.push(feature);
   }
+  if (features.length === 0) {
+    return null;
+  }
   const table = {
     shape: "geojson-table",
     type: "FeatureCollection",
@@ -1930,10 +1999,4 @@ function convertToGeoJSONTable(vtTile, extent) {
   };
   return table;
 }
-function toLngLat(coords, extent) {
-  if (Array.isArray(coords[0])) {
-    return coords.map((c) => toLngLat(c, extent));
-  }
-  return [coords[0] / extent, coords[1] / extent];
-}
 //# sourceMappingURL=index.cjs.map