@loaders.gl/mvt 4.4.0-alpha.1 → 4.4.0-alpha.9

package/dist/index.cjs

@@ -38,6 +38,7 @@ __export(dist_exports, {
   MVTLoader: () => MVTLoader,
   MVTSource: () => MVTSource,
   MVTWorkerLoader: () => MVTWorkerLoader,
+  MVTWriter: () => MVTWriter,
   TableTileSource: () => TableTileSource,
   TileJSONLoader: () => TileJSONLoader
 });
@@ -302,7 +303,7 @@ function attributeTypeToFieldType(aType) {
 }
 
 // dist/tilejson-loader.js
-var VERSION = true ? "4.4.0-alpha.0" : "latest";
+var VERSION = true ? "4.4.0-alpha.9" : "latest";
 var TileJSONLoader = {
   dataType: null,
   batchType: null,
@@ -996,7 +997,7 @@ var MVTFormat = {
 };
 
 // dist/mvt-loader.js
-var VERSION2 = true ? "4.4.0-alpha.0" : "latest";
+var VERSION2 = true ? "4.4.0-alpha.9" : "latest";
 var MVTWorkerLoader = {
   ...MVTFormat,
   dataType: null,
@@ -1020,8 +1021,395 @@ var MVTLoader = {
   binary: true
 };
 
-// dist/mvt-source.js
+// dist/lib/mapbox-vt-pbf/to-vector-tile.js
+var import_pbf2 = __toESM(require("pbf"), 1);
+
+// dist/lib/mvt-pbf/mvt-constants.js
+var TileInfo;
+(function(TileInfo2) {
+  TileInfo2[TileInfo2["layers"] = 3] = "layers";
+})(TileInfo || (TileInfo = {}));
+var LayerInfo;
+(function(LayerInfo2) {
+  LayerInfo2[LayerInfo2["version"] = 15] = "version";
+  LayerInfo2[LayerInfo2["name"] = 1] = "name";
+  LayerInfo2[LayerInfo2["features"] = 2] = "features";
+  LayerInfo2[LayerInfo2["keys"] = 3] = "keys";
+  LayerInfo2[LayerInfo2["values"] = 4] = "values";
+  LayerInfo2[LayerInfo2["extent"] = 5] = "extent";
+})(LayerInfo || (LayerInfo = {}));
+var FeatureInfo;
+(function(FeatureInfo2) {
+  FeatureInfo2[FeatureInfo2["id"] = 1] = "id";
+  FeatureInfo2[FeatureInfo2["tags"] = 2] = "tags";
+  FeatureInfo2[FeatureInfo2["type"] = 3] = "type";
+  FeatureInfo2[FeatureInfo2["geometry"] = 4] = "geometry";
+})(FeatureInfo || (FeatureInfo = {}));
+var GeometryType;
+(function(GeometryType2) {
+  GeometryType2[GeometryType2["UNKNOWN"] = 0] = "UNKNOWN";
+  GeometryType2[GeometryType2["POINT"] = 1] = "POINT";
+  GeometryType2[GeometryType2["LINESTRING"] = 2] = "LINESTRING";
+  GeometryType2[GeometryType2["POLYGON"] = 3] = "POLYGON";
+})(GeometryType || (GeometryType = {}));
+var PropertyType;
+(function(PropertyType2) {
+  PropertyType2[PropertyType2["string_value"] = 1] = "string_value";
+  PropertyType2[PropertyType2["float_value"] = 2] = "float_value";
+  PropertyType2[PropertyType2["double_value"] = 3] = "double_value";
+  PropertyType2[PropertyType2["int_value"] = 4] = "int_value";
+  PropertyType2[PropertyType2["uint_value"] = 5] = "uint_value";
+  PropertyType2[PropertyType2["sint_value"] = 6] = "sint_value";
+  PropertyType2[PropertyType2["bool_value"] = 7] = "bool_value";
+})(PropertyType || (PropertyType = {}));
+var Command;
+(function(Command2) {
+  Command2[Command2["MoveTo"] = 1] = "MoveTo";
+  Command2[Command2["LineTo"] = 2] = "LineTo";
+  Command2[Command2["ClosePath"] = 7] = "ClosePath";
+})(Command || (Command = {}));
+
+// dist/lib/mvt-pbf/write-mvt-to-pbf.js
+function writeMVT(tile, pbf) {
+  for (const key in tile.layers) {
+    const context = {
+      layer: tile.layers[key],
+      keys: [],
+      values: [],
+      keycache: {},
+      valuecache: {}
+    };
+    pbf.writeMessage(TileInfo.layers, writeLayer, context);
+  }
+}
+function writeLayer(context, pbf) {
+  const { layer } = context;
+  pbf.writeVarintField(LayerInfo.version, layer.version || 1);
+  pbf.writeStringField(LayerInfo.name, layer.name || "");
+  pbf.writeVarintField(LayerInfo.extent, layer.extent || 4096);
+  for (let i = 0; i < layer.length; i++) {
+    context.feature = layer.feature(i);
+    pbf.writeMessage(LayerInfo.features, writeFeature, context);
+  }
+  const keys = context.keys;
+  for (let i = 0; i < keys.length; i++) {
+    pbf.writeStringField(LayerInfo.keys, keys[i]);
+  }
+  const values = context.values;
+  for (let i = 0; i < values.length; i++) {
+    pbf.writeMessage(LayerInfo.values, writeValue, values[i]);
+  }
+}
+function writeFeature(context, pbf) {
+  const feature = context.feature;
+  if (feature.id !== void 0) {
+    pbf.writeVarintField(FeatureInfo.id, feature.id);
+  }
+  pbf.writeMessage(FeatureInfo.tags, writeProperties, context);
+  pbf.writeVarintField(FeatureInfo.type, feature.type);
+  pbf.writeMessage(FeatureInfo.geometry, writeGeometry, feature);
+}
+function writeProperties(context, pbf) {
+  const feature = context.feature;
+  const { keys, values, keycache, valuecache } = context;
+  for (const key in feature.properties) {
+    let keyIndex = keycache[key];
+    if (typeof keyIndex === "undefined") {
+      keys.push(key);
+      keyIndex = keys.length - 1;
+      keycache[key] = keyIndex;
+    }
+    pbf.writeVarint(keyIndex);
+    let value = feature.properties[key];
+    const type = typeof value;
+    if (type !== "string" && type !== "boolean" && type !== "number") {
+      value = JSON.stringify(value);
+    }
+    const valueKey = `${type}:${value}`;
+    let valueIndex = valuecache[valueKey];
+    if (typeof valueIndex === "undefined") {
+      values.push(value);
+      valueIndex = values.length - 1;
+      valuecache[valueKey] = valueIndex;
+    }
+    pbf.writeVarint(valueIndex);
+  }
+}
+function command(cmd, length) {
+  return (length << 3) + (cmd & 7);
+}
+function zigzag(num) {
+  return num << 1 ^ num >> 31;
+}
+function writeGeometry(feature, pbf) {
+  const geometry = feature.loadGeometry();
+  const type = feature.type;
+  let x = 0;
+  let y = 0;
+  const rings = geometry.length;
+  for (let r = 0; r < rings; r++) {
+    const ring = geometry[r];
+    let count = 1;
+    if (type === 1) {
+      count = ring.length;
+    }
+    pbf.writeVarint(command(1, count));
+    const lineCount = type === 3 ? ring.length - 1 : ring.length;
+    for (let i = 0; i < lineCount; i++) {
+      if (i === 1 && type !== 1) {
+        pbf.writeVarint(command(2, lineCount - 1));
+      }
+      const dx = ring[i].x - x;
+      const dy = ring[i].y - y;
+      pbf.writeVarint(zigzag(dx));
+      pbf.writeVarint(zigzag(dy));
+      x += dx;
+      y += dy;
+    }
+    if (type === 3) {
+      pbf.writeVarint(command(7, 1));
+    }
+  }
+}
+function writeValue(value, pbf) {
+  switch (typeof value) {
+    case "string":
+      pbf.writeStringField(1, value);
+      break;
+    case "boolean":
+      pbf.writeBooleanField(7, value);
+      break;
+    case "number":
+      if (value % 1 !== 0) {
+        pbf.writeDoubleField(3, value);
+      } else if (value < 0) {
+        pbf.writeSVarintField(6, value);
+      } else {
+        pbf.writeVarintField(5, value);
+      }
+      break;
+    default:
+  }
+}
+
+// dist/lib/mapbox-vt-pbf/geojson-wrapper.js
+var Point = class {
+  x;
+  y;
+  constructor(x, y) {
+    this.x = x;
+    this.y = y;
+  }
+};
+var GeoJSONWrapper = class {
+  options;
+  features;
+  length;
+  constructor(features2, options = {}) {
+    this.options = options;
+    this.features = features2;
+    this.length = features2.length;
+  }
+  feature(index) {
+    return new FeatureWrapper(this.features[index], this.options.extent);
+  }
+};
+var FeatureWrapper = class {
+  id;
+  type;
+  rawGeometry;
+  properties;
+  extent;
+  geometry = [];
+  constructor(feature, extent) {
+    this.id = typeof feature.id === "number" ? feature.id : void 0;
+    this.type = feature.type;
+    this.rawGeometry = feature.type === 1 ? [feature.geometry] : feature.geometry;
+    this.properties = feature.tags;
+    this.extent = extent || 4096;
+  }
+  loadGeometry() {
+    const rings = this.rawGeometry;
+    this.geometry = [];
+    for (const ring of rings) {
+      const newRing = [];
+      for (const coord of ring) {
+        newRing.push(new Point(coord[0], coord[1]));
+      }
+      this.geometry.push(newRing);
+    }
+    return this.geometry;
+  }
+  bbox() {
+    if (!this.geometry) {
+      this.loadGeometry();
+    }
+    const rings = this.geometry;
+    let x1 = Infinity;
+    let x2 = -Infinity;
+    let y1 = Infinity;
+    let y2 = -Infinity;
+    for (const ring of rings) {
+      for (const coord of ring) {
+        x1 = Math.min(x1, coord.x);
+        x2 = Math.max(x2, coord.x);
+        y1 = Math.min(y1, coord.y);
+        y2 = Math.max(y2, coord.y);
+      }
+    }
+    return [x1, y1, x2, y2];
+  }
+};
+
+// dist/lib/mapbox-vt-pbf/to-vector-tile.js
 var import_loader_utils2 = require("@loaders.gl/loader-utils");
+function fromGeojson(geojson, options) {
+  options = options || {};
+  geojson = normalizeGeojson(geojson);
+  const extent = options.extent || 4096;
+  const features2 = convertFeaturesToVectorTileFeatures(geojson.features, extent, options.tileIndex);
+  const layer = new GeoJSONWrapper(features2, { ...options, extent });
+  layer.name = options.layerName || "geojsonLayer";
+  layer.version = options.version || 1;
+  layer.extent = options.extent || 4096;
+  return fromVectorTileJs({ layers: { [layer.name]: layer } });
+}
+function fromVectorTileJs(tile) {
+  const pbf = new import_pbf2.default();
+  writeMVT(tile, pbf);
+  const uint8Array = pbf.finish();
+  return (0, import_loader_utils2.copyToArrayBuffer)(uint8Array.buffer, uint8Array.byteOffset, uint8Array.byteOffset + uint8Array.byteLength);
+}
+function normalizeGeojson(geojson) {
+  if (Array.isArray(geojson)) {
+    return {
+      type: "FeatureCollection",
+      features: geojson
+    };
+  }
+  if (geojson.type === "Feature") {
+    return {
+      type: "FeatureCollection",
+      features: [geojson]
+    };
+  }
+  throw new Error("Invalid GeoJSON object");
+}
+function convertFeaturesToVectorTileFeatures(features2, extent, tileIndex) {
+  if (features2.every(isVectorTileFeature)) {
+    return features2;
+  }
+  return features2.map((feature) => convertFeatureToVectorTile(feature, extent, tileIndex));
+}
+function convertFeatureToVectorTile(feature, extent, tileIndex) {
+  const geometry = feature.geometry;
+  const type = getVectorTileType(geometry.type);
+  return {
+    id: typeof feature.id === "number" ? feature.id : void 0,
+    type,
+    geometry: projectGeometryToTileSpace(geometry, extent, tileIndex),
+    tags: feature.properties || {}
+  };
+}
+function projectGeometryToTileSpace(geometry, extent, tileIndex) {
+  switch (geometry.type) {
+    case "Point":
+      return [projectPointToTile(geometry.coordinates, extent, tileIndex)];
+    case "MultiPoint":
+      return geometry.coordinates.map((coord) => projectPointToTile(coord, extent, tileIndex));
+    case "LineString":
+      return [
+        geometry.coordinates.map((coord) => projectPointToTile(coord, extent, tileIndex))
+      ];
+    case "MultiLineString":
+      return geometry.coordinates.map((line) => line.map((coord) => projectPointToTile(coord, extent, tileIndex)));
+    case "Polygon":
+      return geometry.coordinates.map((ring) => ring.map((coord) => projectPointToTile(coord, extent, tileIndex)));
+    case "MultiPolygon":
+      return geometry.coordinates.flatMap((polygon) => polygon.map((ring) => ring.map((coord) => projectPointToTile(coord, extent, tileIndex))));
+    default:
+      throw new Error(`Unsupported geometry type: ${geometry.type}`);
+  }
+}
+function projectPointToTile(point, extent, tileIndex) {
+  if (isNormalizedPoint(point)) {
+    return [Math.round(point[0] * extent), Math.round(point[1] * extent)];
+  }
+  if (tileIndex && isLngLatPoint(point)) {
+    return projectLngLatToTile(point, tileIndex, extent);
+  }
+  return [Math.round(point[0]), Math.round(point[1])];
+}
+function isNormalizedPoint(point) {
+  return Math.abs(point[0]) <= 1 && Math.abs(point[1]) <= 1;
+}
+function isLngLatPoint(point) {
+  return Math.abs(point[0]) <= 180 && Math.abs(point[1]) <= 90;
+}
+function projectLngLatToTile(point, tileIndex, extent) {
+  const [lng, lat] = point;
+  const { x, y, z } = tileIndex;
+  const size = extent * Math.pow(2, z);
+  const x0 = extent * x;
+  const y0 = extent * y;
+  const worldX = (lng + 180) / 360 * size;
+  const worldY = (180 - 180 / Math.PI * Math.log(Math.tan(Math.PI / 4 + lat * Math.PI / 180 / 2))) * size / 360;
+  return [Math.round(worldX - x0), Math.round(worldY - y0)];
+}
+function isVectorTileFeature(feature) {
+  return typeof (feature == null ? void 0 : feature.type) === "number" && Array.isArray(feature.geometry);
+}
+function getVectorTileType(type) {
+  switch (type) {
+    case "Point":
+    case "MultiPoint":
+      return 1;
+    case "LineString":
+    case "MultiLineString":
+      return 2;
+    case "Polygon":
+    case "MultiPolygon":
+      return 3;
+    default:
+      throw new Error(`Unknown geometry type: ${type}`);
+  }
+}
+
+// dist/lib/encode-mvt.js
+function encodeMVT(data, options) {
+  const { mvt } = options || {};
+  const encodeOptions = {
+    layerName: (mvt == null ? void 0 : mvt.layerName) || "geojsonLayer",
+    version: (mvt == null ? void 0 : mvt.version) || 1,
+    extent: (mvt == null ? void 0 : mvt.extent) || 4096,
+    tileIndex: mvt == null ? void 0 : mvt.tileIndex
+  };
+  return fromGeojson(data, encodeOptions);
+}
+
+// dist/mvt-writer.js
+var VERSION3 = true ? "4.4.0-alpha.9" : "latest";
+var MVTWriter = {
+  ...MVTFormat,
+  version: VERSION3,
+  binary: true,
+  options: {
+    mvt: {
+      layerName: "geojsonLayer",
+      version: 1,
+      extent: 4096
+    }
+  },
+  async encode(data, options) {
+    return encodeMVT(data, options);
+  },
+  encodeSync(data, options) {
+    return encodeMVT(data, options);
+  }
+};
+
+// dist/mvt-source.js
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var import_images = require("@loaders.gl/images");
 var import_mvt = require("@loaders.gl/mvt");
 var MVTSource = {
@@ -1040,7 +1428,7 @@ var MVTSource = {
     return new MVTTileSource(url, options);
   }
 };
-var MVTTileSource = class extends import_loader_utils2.DataSource {
+var MVTTileSource = class extends import_loader_utils3.DataSource {
   metadataUrl = null;
   schema = "tms";
   metadata;
@@ -1124,8 +1512,8 @@ var MVTTileSource = class extends import_loader_utils2.DataSource {
   async _parseVectorTile(arrayBuffer, tileParams) {
     var _a;
     const loadOptions = {
-      shape: "geojson-table",
       mvt: {
+        shape: "geojson-table",
         coordinates: "wgs84",
         tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.z },
         ...(_a = this.loadOptions) == null ? void 0 : _a.mvt
@@ -1175,7 +1563,7 @@ function stringHash(s) {
 }
 
 // dist/table-tile-source.js
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var import_schema_utils = require("@loaders.gl/schema-utils");
 var import_stats = require("@probe.gl/stats");
 
@@ -1894,7 +2282,7 @@ var TableTileSource = {
     return new TableVectorTileSource(tablePromise, options);
   }
 };
-var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
+var _TableVectorTileSource = class extends import_loader_utils4.DataSource {
   /** Stats for this TableVectorTileSource */
   stats = new import_stats.Stats({
     id: "table-tile-source",
@@ -1916,7 +2304,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
   metadata;
   constructor(table, options) {
     super(table, options, TableTileSource.defaultOptions);
-    this.tableOptions = (0, import_loader_utils3.getRequiredOptions)(this.options).table;
+    this.tableOptions = (0, import_loader_utils4.getRequiredOptions)(this.options).table;
     this.getTileData = this.getTileData.bind(this);
     this.ready = this.initializeTilesAsync(table);
     this.metadata = this.getMetadata();
@@ -1942,7 +2330,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
   async getVectorTile(tileIndex) {
     await this.ready;
     const table = this.getTileSync(tileIndex);
-    import_loader_utils3.log.info(2, "getVectorTile", tileIndex, table)();
+    import_loader_utils4.log.info(2, "getVectorTile", tileIndex, table)();
     return table;
   }
   async getTile(tileIndex) {
@@ -1981,21 +2369,21 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
     if (this.tableOptions.promoteId && this.tableOptions.generateId) {
       throw new Error("promoteId and generateId cannot be used together.");
     }
-    import_loader_utils3.log.log(1, "TableVectorTileSource creating root tiles", this.tableOptions)();
-    import_loader_utils3.log.time(1, "preprocess table")();
+    import_loader_utils4.log.log(1, "TableVectorTileSource creating root tiles", this.tableOptions)();
+    import_loader_utils4.log.time(1, "preprocess table")();
     let features2 = convertFeaturesToProtoFeature(table, this.tableOptions);
-    import_loader_utils3.log.timeEnd(1, "preprocess table")();
-    import_loader_utils3.log.time(1, "generate tiles")();
+    import_loader_utils4.log.timeEnd(1, "preprocess table")();
+    import_loader_utils4.log.time(1, "generate tiles")();
     features2 = wrapFeatures(features2, this.tableOptions);
     if (features2.length === 0) {
-      import_loader_utils3.log.log(1, "TableVectorTileSource: no features generated")();
+      import_loader_utils4.log.log(1, "TableVectorTileSource: no features generated")();
       return;
     }
     this.splitTile(features2, 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, `TableVectorTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
+    import_loader_utils4.log.log(1, `root tile features: ${rootTile.numFeatures}, points: ${rootTile.numPoints}`)();
+    import_loader_utils4.log.timeEnd(1, "generate tiles")();
+    import_loader_utils4.log.log(1, `TableVectorTileSource: tiles generated: ${this.stats.get("total").count}`, this.stats)();
   }
   /**
    * Return geojsonvt-style "half formed" vector tile
@@ -2015,7 +2403,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
     if (this.tiles[id]) {
       return transformTile(this.tiles[id], extent);
     }
-    import_loader_utils3.log.log(import_loader_utils3.log, "drilling down to z%d-%d-%d", z, x, y)();
+    import_loader_utils4.log.log(import_loader_utils4.log, "drilling down to z%d-%d-%d", z, x, y)();
     let z0 = z;
     let x0 = x;
     let y0 = y;
@@ -2029,10 +2417,10 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
     if (!parent || !parent.sourceFeatures) {
       return null;
     }
-    import_loader_utils3.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
-    import_loader_utils3.log.time(1, "drilling down")();
+    import_loader_utils4.log.log(1, "found parent tile z%d-%d-%d", z0, x0, y0)();
+    import_loader_utils4.log.time(1, "drilling down")();
     this.splitTile(parent.sourceFeatures, z0, x0, y0, z, x, y);
-    import_loader_utils3.log.timeEnd(1, "drilling down")();
+    import_loader_utils4.log.timeEnd(1, "drilling down")();
     return this.tiles[id] ? transformTile(this.tiles[id], extent) : null;
   }
   /**
@@ -2055,7 +2443,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
       const id = toID(z, x, y);
       let tile = this.tiles[id];
       if (!tile) {
-        import_loader_utils3.log.time(2, "tile creation")();
+        import_loader_utils4.log.time(2, "tile creation")();
         tile = this.tiles[id] = createProtoTile(features2, z, x, y, this.tableOptions);
         this.tileCoords.push({ z, x, y });
         const key = `z${z}`;
@@ -2067,8 +2455,8 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
         stat.incrementCount();
         stat = _TableVectorTileSource.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")();
+        import_loader_utils4.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_utils4.log.timeEnd(2, "tile creation")();
       }
       tile.sourceFeatures = features2;
       if (cz === void 0) {
@@ -2086,7 +2474,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
       tile.sourceFeatures = null;
       if (features2.length === 0)
         continue;
-      import_loader_utils3.log.time(2, "clipping tile")();
+      import_loader_utils4.log.time(2, "clipping tile")();
       const k1 = 0.5 * this.tableOptions.buffer / this.tableOptions.extent;
       const k2 = 0.5 - k1;
       const k3 = 0.5 + k1;
@@ -2108,7 +2496,7 @@ var _TableVectorTileSource = class extends import_loader_utils3.DataSource {
         br = clipFeatures(right, z2, y + k2, y + k4, 1, tile.minY, tile.maxY, this.tableOptions);
         right = null;
       }
-      import_loader_utils3.log.timeEnd(2, "clipping tile")();
+      import_loader_utils4.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);