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

package/dist/dist.dev.js

@@ -793,14 +793,142 @@ var __exports__ = (() => {
   // bundle.ts
   var bundle_exports = {};
   __export(bundle_exports, {
-    GeoJSONTileSource: () => GeoJSONTileSource,
     MVTLoader: () => MVTLoader,
     MVTSource: () => MVTSource,
     MVTWorkerLoader: () => MVTWorkerLoader,
+    TableTileSource: () => TableTileSource,
     TileJSONLoader: () => TileJSONLoader
   });
   __reExport(bundle_exports, __toESM(require_core(), 1));
 
+  // ../schema/src/lib/table/simple-table/data-type.ts
+  function getDataTypeFromValue(value, defaultNumberType = "float32") {
+    if (value instanceof Date) {
+      return "date-millisecond";
+    }
+    if (value instanceof Number) {
+      return defaultNumberType;
+    }
+    if (typeof value === "string") {
+      return "utf8";
+    }
+    if (value === null || value === "undefined") {
+      return "null";
+    }
+    return "null";
+  }
+  function getDataTypeFromArray(array) {
+    let type = getDataTypeFromTypedArray(array);
+    if (type !== "null") {
+      return { type, nullable: false };
+    }
+    if (array.length > 0) {
+      type = getDataTypeFromValue(array[0]);
+      return { type, nullable: true };
+    }
+    return { type: "null", nullable: true };
+  }
+  function getDataTypeFromTypedArray(array) {
+    switch (array.constructor) {
+      case Int8Array:
+        return "int8";
+      case Uint8Array:
+      case Uint8ClampedArray:
+        return "uint8";
+      case Int16Array:
+        return "int16";
+      case Uint16Array:
+        return "uint16";
+      case Int32Array:
+        return "int32";
+      case Uint32Array:
+        return "uint32";
+      case Float32Array:
+        return "float32";
+      case Float64Array:
+        return "float64";
+      default:
+        return "null";
+    }
+  }
+
+  // ../schema/src/lib/table/simple-table/table-schema.ts
+  function deduceTableSchema(table) {
+    switch (table.shape) {
+      case "array-row-table":
+      case "object-row-table":
+        return deduceSchemaFromRows(table.data);
+      case "geojson-table":
+        return deduceSchemaFromGeoJSON(table.features);
+      case "columnar-table":
+        return deduceSchemaFromColumns(table.data);
+      case "arrow-table":
+      default:
+        throw new Error("Deduce schema");
+    }
+  }
+  function deduceSchemaFromColumns(columnarTable) {
+    const fields = [];
+    for (const [columnName, column] of Object.entries(columnarTable)) {
+      const field = deduceFieldFromColumn(column, columnName);
+      fields.push(field);
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromRows(rowTable) {
+    if (!rowTable.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = rowTable[0];
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceSchemaFromGeoJSON(features) {
+    if (!features.length) {
+      throw new Error("deduce from empty table");
+    }
+    const fields = [];
+    const row0 = features[0].properties || {};
+    for (const [columnName, value] of Object.entries(row0)) {
+      fields.push(deduceFieldFromValue(value, columnName));
+    }
+    return { fields, metadata: {} };
+  }
+  function deduceFieldFromColumn(column, name) {
+    if (ArrayBuffer.isView(column)) {
+      const type = getDataTypeFromArray(column);
+      return {
+        name,
+        type: type.type || "null",
+        nullable: type.nullable
+        // metadata: {}
+      };
+    }
+    if (Array.isArray(column) && column.length > 0) {
+      const value = column[0];
+      const type = getDataTypeFromValue(value);
+      return {
+        name,
+        type,
+        nullable: true
+        // metadata: {},
+      };
+    }
+    throw new Error("empty table");
+  }
+  function deduceFieldFromValue(value, name) {
+    const type = getDataTypeFromValue(value);
+    return {
+      name,
+      type,
+      nullable: true
+      // metadata: {}
+    };
+  }
+
   // ../../node_modules/@babel/runtime/helpers/esm/typeof.js
   function _typeof(obj) {
     "@babel/helpers - typeof";
@@ -2204,7 +2332,16 @@ var __exports__ = (() => {
   // ../loader-utils/src/lib/log-utils/log.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
   var version = VERSION2[0] >= "0" && VERSION2[0] <= "9" ? `v${VERSION2}` : "";
-  var log = new Log({ id: `loaders.gl ${version}` });
+  function createLog() {
+    const log2 = new Log({ id: "loaders.gl" });
+    globalThis.loaders = globalThis.loaders || {};
+    globalThis.loaders.log = log2;
+    globalThis.loaders.version = version;
+    globalThis.probe = globalThis.probe || {};
+    globalThis.probe.loaders = log2;
+    return log2;
+  }
+  var log = createLog();
 
   // ../loader-utils/src/lib/path-utils/file-aliases.ts
   var pathPrefix = "";
@@ -2280,6 +2417,39 @@ var __exports__ = (() => {
     }
     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);
@@ -2389,39 +2559,37 @@ var __exports__ = (() => {
       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;
@@ -2465,10 +2633,9 @@ var __exports__ = (() => {
      * @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:
@@ -2545,6 +2712,28 @@ var __exports__ = (() => {
         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;
@@ -2587,7 +2776,7 @@ var __exports__ = (() => {
     }
   };
   __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;
@@ -2599,19 +2788,19 @@ var __exports__ = (() => {
           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;
@@ -2632,7 +2821,8 @@ var __exports__ = (() => {
       properties: vtFeature.properties
     };
     if (vtFeature.id !== null) {
-      result.id = vtFeature.id;
+      result.properties ||= {};
+      result.properties.id = vtFeature.id;
     }
     return result;
   }
@@ -2855,9 +3045,9 @@ var __exports__ = (() => {
     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 ||= {};
@@ -2866,29 +3056,12 @@ var __exports__ = (() => {
     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;
-    }
-  }
 
   // src/mvt-loader.ts
   var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -3615,8 +3788,8 @@ var __exports__ = (() => {
     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) {
@@ -3627,8 +3800,8 @@ var __exports__ = (() => {
     }
     // 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;
@@ -3707,7 +3880,200 @@ var __exports__ = (() => {
     return Math.abs(s.split("").reduce((a, b) => (a << 5) - a + b.charCodeAt(0) | 0, 0));
   }
 
-  // src/lib/geojsonvt/simplify.ts
+  // node_modules/@probe.gl/stats/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp2() {
+    let timestamp;
+    if (typeof window !== "undefined" && window.performance) {
+      timestamp = window.performance.now();
+    } else if (typeof process !== "undefined" && process.hrtime) {
+      const timeParts = process.hrtime();
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+
+  // node_modules/@probe.gl/stats/dist/lib/stat.js
+  var Stat = class {
+    constructor(name, type) {
+      this.sampleSize = 1;
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      this.name = name;
+      this.type = type;
+      this.reset();
+    }
+    reset() {
+      this.time = 0;
+      this.count = 0;
+      this.samples = 0;
+      this.lastTiming = 0;
+      this.lastSampleTime = 0;
+      this.lastSampleCount = 0;
+      this._count = 0;
+      this._time = 0;
+      this._samples = 0;
+      this._startTime = 0;
+      this._timerPending = false;
+      return this;
+    }
+    setSampleSize(samples) {
+      this.sampleSize = samples;
+      return this;
+    }
+    /** Call to increment count (+1) */
+    incrementCount() {
+      this.addCount(1);
+      return this;
+    }
+    /** Call to decrement count (-1) */
+    decrementCount() {
+      this.subtractCount(1);
+      return this;
+    }
+    /** Increase count */
+    addCount(value) {
+      this._count += value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Decrease count */
+    subtractCount(value) {
+      this._count -= value;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Add an arbitrary timing and bump the count */
+    addTime(time) {
+      this._time += time;
+      this.lastTiming = time;
+      this._samples++;
+      this._checkSampling();
+      return this;
+    }
+    /** Start a timer */
+    timeStart() {
+      this._startTime = getHiResTimestamp2();
+      this._timerPending = true;
+      return this;
+    }
+    /** End a timer. Adds to time and bumps the timing count. */
+    timeEnd() {
+      if (!this._timerPending) {
+        return this;
+      }
+      this.addTime(getHiResTimestamp2() - this._startTime);
+      this._timerPending = false;
+      this._checkSampling();
+      return this;
+    }
+    getSampleAverageCount() {
+      return this.sampleSize > 0 ? this.lastSampleCount / this.sampleSize : 0;
+    }
+    /** Calculate average time / count for the previous window */
+    getSampleAverageTime() {
+      return this.sampleSize > 0 ? this.lastSampleTime / this.sampleSize : 0;
+    }
+    /** Calculate counts per second for the previous window */
+    getSampleHz() {
+      return this.lastSampleTime > 0 ? this.sampleSize / (this.lastSampleTime / 1e3) : 0;
+    }
+    getAverageCount() {
+      return this.samples > 0 ? this.count / this.samples : 0;
+    }
+    /** Calculate average time / count */
+    getAverageTime() {
+      return this.samples > 0 ? this.time / this.samples : 0;
+    }
+    /** Calculate counts per second */
+    getHz() {
+      return this.time > 0 ? this.samples / (this.time / 1e3) : 0;
+    }
+    _checkSampling() {
+      if (this._samples === this.sampleSize) {
+        this.lastSampleTime = this._time;
+        this.lastSampleCount = this._count;
+        this.count += this._count;
+        this.time += this._time;
+        this.samples += this._samples;
+        this._time = 0;
+        this._count = 0;
+        this._samples = 0;
+      }
+    }
+  };
+
+  // node_modules/@probe.gl/stats/dist/lib/stats.js
+  var Stats = class {
+    constructor(options) {
+      this.stats = {};
+      this.id = options.id;
+      this.stats = {};
+      this._initializeStats(options.stats);
+      Object.seal(this);
+    }
+    /** Acquire a stat. Create if it doesn't exist. */
+    get(name, type = "count") {
+      return this._getOrCreate({ name, type });
+    }
+    get size() {
+      return Object.keys(this.stats).length;
+    }
+    /** Reset all stats */
+    reset() {
+      for (const stat of Object.values(this.stats)) {
+        stat.reset();
+      }
+      return this;
+    }
+    forEach(fn) {
+      for (const stat of Object.values(this.stats)) {
+        fn(stat);
+      }
+    }
+    getTable() {
+      const table = {};
+      this.forEach((stat) => {
+        table[stat.name] = {
+          time: stat.time || 0,
+          count: stat.count || 0,
+          average: stat.getAverageTime() || 0,
+          hz: stat.getHz() || 0
+        };
+      });
+      return table;
+    }
+    _initializeStats(stats = []) {
+      stats.forEach((stat) => this._getOrCreate(stat));
+    }
+    _getOrCreate(stat) {
+      const { name, type } = stat;
+      let result = this.stats[name];
+      if (!result) {
+        if (stat instanceof Stat) {
+          result = stat;
+        } else {
+          result = new Stat(name, type);
+        }
+        this.stats[name] = result;
+      }
+      return result;
+    }
+  };
+
+  // src/lib/vector-tiler/simplify.ts
   function simplify(coords, first, last, sqTolerance) {
     let maxSqDist = sqTolerance;
     const mid = last - first >> 1;
@@ -3756,7 +4122,7 @@ var __exports__ = (() => {
     return dx * dx + dy * dy;
   }
 
-  // src/lib/geojsonvt/feature.ts
+  // src/lib/vector-tiler/feature.ts
   function createFeature(id, type, geom, tags) {
     const feature = {
       // eslint-disable-next-line
@@ -3793,7 +4159,7 @@ var __exports__ = (() => {
     }
   }
 
-  // src/lib/geojsonvt/convert.ts
+  // src/lib/vector-tiler/convert.ts
   function convert(data, options) {
     const features = [];
     if (data.type === "FeatureCollection") {
@@ -3911,7 +4277,7 @@ var __exports__ = (() => {
     return y2 < 0 ? 0 : y2 > 1 ? 1 : y2;
   }
 
-  // src/lib/geojsonvt/clip.ts
+  // src/lib/vector-tiler/clip.ts
   function clip(features, scale, k1, k2, axis, minAll, maxAll, options) {
     k1 /= scale;
     k2 /= scale;
@@ -4076,7 +4442,7 @@ var __exports__ = (() => {
     return t;
   }
 
-  // src/lib/geojsonvt/wrap.ts
+  // src/lib/vector-tiler/wrap.ts
   function wrap(features, options) {
     const buffer = options.buffer / options.extent;
     let merged = features;
@@ -4133,7 +4499,7 @@ var __exports__ = (() => {
     return newPoints;
   }
 
-  // src/lib/geojsonvt/transform.ts
+  // src/lib/vector-tiler/transform.ts
   function transformTile(tile, extent) {
     if (tile.transformed) {
       return tile;
@@ -4166,7 +4532,7 @@ var __exports__ = (() => {
     return [Math.round(extent * (x * z2 - tx)), Math.round(extent * (y * z2 - ty))];
   }
 
-  // src/lib/geojsonvt/tile.ts
+  // src/lib/vector-tiler/tile.ts
   function createTile(features, z, tx, ty, options) {
     const tolerance = z === options.maxZoom ? 0 : options.tolerance / ((1 << z) * options.extent);
     const tile = {
@@ -4272,61 +4638,46 @@ var __exports__ = (() => {
     }
   }
 
-  // src/geojson-tile-source.ts
-  var _GeoJSONTileSource = class {
+  // src/table-tile-source.ts
+  var _TableTileSource = class {
+    /** Stats for this TableTileSource */
+    stats = new Stats({
+      id: "table-tile-source",
+      stats: [new Stat("tiles", "count"), new 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 = 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
@@ -4336,6 +4687,7 @@ var __exports__ = (() => {
     async getVectorTile(tileIndex) {
       await this.ready;
       const table = this.getTileSync(tileIndex);
+      log.info(2, "getVectorTile", tileIndex, table)();
       return table;
     }
     async getTile(tileIndex) {
@@ -4344,7 +4696,8 @@ var __exports__ = (() => {
     }
     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?.features || [];
     }
     // Implementation
     /**
@@ -4356,7 +4709,38 @@ var __exports__ = (() => {
       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.");
+      }
+      log.log(1, "TableTileSource creating root tiles", this.props)();
+      log.time(1, "preprocess table")();
+      let features = convert(table, this.props);
+      log.timeEnd(1, "preprocess table")();
+      log.time(1, "generate tiles")();
+      features = wrap(features, this.props);
+      if (features.length === 0) {
+        log.log(1, "TableTileSource: no features generated")();
+        return;
+      }
+      this.splitTile(features, 0, 0, 0);
+      const rootTile = this.tiles[0];
+      log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+      log.timeEnd(1, "generate tiles")();
+      log.log(1, `TableTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
     }
     /**
      * Return geojsonvt-style "half formed" vector tile
@@ -4366,7 +4750,7 @@ var __exports__ = (() => {
     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;
       }
@@ -4376,8 +4760,7 @@ var __exports__ = (() => {
       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);
+      log.log(log, "drilling down to z%d-%d-%d", z, x, y)();
       let z0 = z;
       let x0 = x;
       let y0 = y;
@@ -4391,14 +4774,10 @@ var __exports__ = (() => {
       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");
-      }
+      log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+      log.time(1, "drilling down")();
       this.splitTile(parent.source, z0, x0, y0, z, x, y);
-      if (debug > 1) {
-        console.timeEnd("drilling down");
-      }
+      log.timeEnd(1, "drilling down")();
       return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
     }
     /**
@@ -4407,13 +4786,11 @@ var __exports__ = (() => {
      * @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();
@@ -4423,46 +4800,48 @@ var __exports__ = (() => {
         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);
+          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();
+          log.log(
+            2,
+            "tile z%d-%d-%d (features: %d, points: %d, simplified: %d)",
+            z,
+            x,
+            y,
+            tile.numFeatures,
+            tile.numPoints,
+            tile.numSimplified
+          )();
+          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;
+        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;
@@ -4470,21 +4849,20 @@ var __exports__ = (() => {
         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");
+        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);
@@ -4492,13 +4870,15 @@ var __exports__ = (() => {
       }
     }
   };
-  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)
@@ -4516,10 +4896,15 @@ var __exports__ = (() => {
     debug: 0
     // logging level (0, 1 or 2)
   });
+  /** Global stats for all TableTileSources */
+  __publicField(TableTileSource, "stats", new Stats({
+    id: "table-tile-source-all",
+    stats: [new Stat("count", "tiles"), new 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) {
@@ -4558,17 +4943,31 @@ var __exports__ = (() => {
         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",
@@ -4576,12 +4975,6 @@ var __exports__ = (() => {
     };
     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];
-  }
   return __toCommonJS(bundle_exports);
 })();
 /*! Bundled license information: