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

package/README.md

@@ -1,5 +1,18 @@
 # @loaders.gl/mvt
 
-This module contains a geometry loader for Mapbox Vector Tiles (MVT).
+This module contains a geometry loader for Mapbox Vector Tiles (MVT) and a writer for generating MVT tiles from GeoJSON.
 
 [loaders.gl](https://loaders.gl/docs) is a collection of framework-independent visualization-focused loaders (parsers).
+
+## Writing
+
+Use the `MVTWriter` with `@loaders.gl/core`'s `encode` helper to serialize GeoJSON into a Mapbox Vector Tile `ArrayBuffer`.
+
+```typescript
+import {encode} from '@loaders.gl/core';
+import {MVTWriter} from '@loaders.gl/mvt';
+
+const arrayBuffer = await encode(geojson, MVTWriter, {
+  mvt: {layerName: 'my-layer', version: 2, extent: 4096}
+});
+```

package/dist/dist.dev.js

@@ -137,23 +137,23 @@ var __exports__ = (() => {
   var require_pbf = __commonJS({
     "../../node_modules/pbf/index.js"(exports, module) {
       "use strict";
-      module.exports = Pbf;
+      module.exports = Pbf2;
       var ieee754 = require_ieee754();
-      function Pbf(buf) {
+      function Pbf2(buf) {
         this.buf = ArrayBuffer.isView && ArrayBuffer.isView(buf) ? buf : new Uint8Array(buf || 0);
         this.pos = 0;
         this.type = 0;
         this.length = this.buf.length;
       }
-      Pbf.Varint = 0;
-      Pbf.Fixed64 = 1;
-      Pbf.Bytes = 2;
-      Pbf.Fixed32 = 5;
+      Pbf2.Varint = 0;
+      Pbf2.Fixed64 = 1;
+      Pbf2.Bytes = 2;
+      Pbf2.Fixed32 = 5;
       var SHIFT_LEFT_32 = (1 << 16) * (1 << 16);
       var SHIFT_RIGHT_32 = 1 / SHIFT_LEFT_32;
       var TEXT_DECODER_MIN_LENGTH = 12;
       var utf8TextDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder("utf-8");
-      Pbf.prototype = {
+      Pbf2.prototype = {
         destroy: function() {
           this.buf = null;
         },
@@ -251,7 +251,7 @@ var __exports__ = (() => {
         },
         // verbose for performance reasons; doesn't affect gzipped size
         readPackedVarint: function(arr, isSigned) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readVarint(isSigned));
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -260,7 +260,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedSVarint: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readSVarint());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -269,7 +269,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedBoolean: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readBoolean());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -278,7 +278,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedFloat: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readFloat());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -287,7 +287,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedDouble: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readDouble());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -296,7 +296,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedFixed32: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readFixed32());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -305,7 +305,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedSFixed32: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readSFixed32());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -314,7 +314,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedFixed64: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readFixed64());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -323,7 +323,7 @@ var __exports__ = (() => {
           return arr;
         },
         readPackedSFixed64: function(arr) {
-          if (this.type !== Pbf.Bytes)
+          if (this.type !== Pbf2.Bytes)
             return arr.push(this.readSFixed64());
           var end = readPackedEnd(this);
           arr = arr || [];
@@ -333,14 +333,14 @@ var __exports__ = (() => {
         },
         skip: function(val) {
           var type = val & 7;
-          if (type === Pbf.Varint)
+          if (type === Pbf2.Varint)
             while (this.buf[this.pos++] > 127) {
             }
-          else if (type === Pbf.Bytes)
+          else if (type === Pbf2.Bytes)
             this.pos = this.readVarint() + this.pos;
-          else if (type === Pbf.Fixed32)
+          else if (type === Pbf2.Fixed32)
             this.pos += 4;
-          else if (type === Pbf.Fixed64)
+          else if (type === Pbf2.Fixed64)
             this.pos += 8;
           else
             throw new Error("Unimplemented type: " + type);
@@ -453,7 +453,7 @@ var __exports__ = (() => {
           this.pos += len;
         },
         writeMessage: function(tag, fn, obj) {
-          this.writeTag(tag, Pbf.Bytes);
+          this.writeTag(tag, Pbf2.Bytes);
           this.writeRawMessage(fn, obj);
         },
         writePackedVarint: function(tag, arr) {
@@ -493,43 +493,43 @@ var __exports__ = (() => {
             this.writeMessage(tag, writePackedSFixed64, arr);
         },
         writeBytesField: function(tag, buffer) {
-          this.writeTag(tag, Pbf.Bytes);
+          this.writeTag(tag, Pbf2.Bytes);
           this.writeBytes(buffer);
         },
         writeFixed32Field: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed32);
+          this.writeTag(tag, Pbf2.Fixed32);
           this.writeFixed32(val);
         },
         writeSFixed32Field: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed32);
+          this.writeTag(tag, Pbf2.Fixed32);
           this.writeSFixed32(val);
         },
         writeFixed64Field: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed64);
+          this.writeTag(tag, Pbf2.Fixed64);
           this.writeFixed64(val);
         },
         writeSFixed64Field: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed64);
+          this.writeTag(tag, Pbf2.Fixed64);
           this.writeSFixed64(val);
         },
         writeVarintField: function(tag, val) {
-          this.writeTag(tag, Pbf.Varint);
+          this.writeTag(tag, Pbf2.Varint);
           this.writeVarint(val);
         },
         writeSVarintField: function(tag, val) {
-          this.writeTag(tag, Pbf.Varint);
+          this.writeTag(tag, Pbf2.Varint);
           this.writeSVarint(val);
         },
         writeStringField: function(tag, str) {
-          this.writeTag(tag, Pbf.Bytes);
+          this.writeTag(tag, Pbf2.Bytes);
           this.writeString(str);
         },
         writeFloatField: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed32);
+          this.writeTag(tag, Pbf2.Fixed32);
           this.writeFloat(val);
         },
         writeDoubleField: function(tag, val) {
-          this.writeTag(tag, Pbf.Fixed64);
+          this.writeTag(tag, Pbf2.Fixed64);
           this.writeDouble(val);
         },
         writeBooleanField: function(tag, val) {
@@ -565,7 +565,7 @@ var __exports__ = (() => {
         throw new Error("Expected varint not more than 10 bytes");
       }
       function readPackedEnd(pbf) {
-        return pbf.type === Pbf.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
+        return pbf.type === Pbf2.Bytes ? pbf.readVarint() + pbf.pos : pbf.pos + 1;
       }
       function toNum(low, high, isSigned) {
         if (isSigned) {
@@ -796,6 +796,7 @@ var __exports__ = (() => {
     MVTLoader: () => MVTLoader,
     MVTSource: () => MVTSource,
     MVTWorkerLoader: () => MVTWorkerLoader,
+    MVTWriter: () => MVTWriter,
     TableTileSource: () => TableTileSource,
     TileJSONLoader: () => TileJSONLoader
   });
@@ -2713,6 +2714,14 @@ var __exports__ = (() => {
     return filename;
   }
 
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function copyToArrayBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy2 = new Uint8Array(view.length);
+    copy2.set(view);
+    return copy2.buffer;
+  }
+
   // ../loader-utils/src/lib/sources/data-source.ts
   var _DataSource = class {
     optionsType;
@@ -2765,7 +2774,7 @@ var __exports__ = (() => {
     }
   });
   function getFetchFunction(options) {
-    const fetchFunction = options?.fetch;
+    const fetchFunction = options?.core?.fetch;
     if (fetchFunction && typeof fetchFunction === "function") {
       return (url, fetchOptions2) => fetchFunction(url, fetchOptions2);
     }
@@ -3476,8 +3485,368 @@ var __exports__ = (() => {
     binary: true
   };
 
-  // ../images/src/lib/utils/version.ts
+  // src/lib/mapbox-vt-pbf/to-vector-tile.ts
+  var import_pbf2 = __toESM(require_pbf(), 1);
+
+  // src/lib/mvt-pbf/write-mvt-to-pbf.ts
+  function writeMVT(tile, pbf) {
+    for (const key in tile.layers) {
+      const context = {
+        layer: tile.layers[key],
+        keys: [],
+        values: [],
+        keycache: {},
+        valuecache: {}
+      };
+      pbf.writeMessage(3 /* layers */, writeLayer, context);
+    }
+  }
+  function writeLayer(context, pbf) {
+    const { layer } = context;
+    pbf.writeVarintField(15 /* version */, layer.version || 1);
+    pbf.writeStringField(1 /* name */, layer.name || "");
+    pbf.writeVarintField(5 /* extent */, layer.extent || 4096);
+    for (let i = 0; i < layer.length; i++) {
+      context.feature = layer.feature(i);
+      pbf.writeMessage(2 /* features */, writeFeature, context);
+    }
+    const keys = context.keys;
+    for (let i = 0; i < keys.length; i++) {
+      pbf.writeStringField(3 /* keys */, keys[i]);
+    }
+    const values = context.values;
+    for (let i = 0; i < values.length; i++) {
+      pbf.writeMessage(4 /* values */, writeValue, values[i]);
+    }
+  }
+  function writeFeature(context, pbf) {
+    const feature = context.feature;
+    if (feature.id !== void 0) {
+      pbf.writeVarintField(1 /* id */, feature.id);
+    }
+    pbf.writeMessage(2 /* tags */, writeProperties, context);
+    pbf.writeVarintField(3 /* type */, feature.type);
+    pbf.writeMessage(4 /* 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:
+    }
+  }
+
+  // src/lib/mapbox-vt-pbf/geojson-wrapper.ts
+  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];
+    }
+    // toGeoJSON(x, y, z) {
+    //   return VectorTileFeature.prototype.toGeoJSON.call(this, x, y, z);
+    // }
+  };
+
+  // src/lib/mapbox-vt-pbf/to-vector-tile.ts
+  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 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?.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}`);
+    }
+  }
+
+  // src/lib/encode-mvt.ts
+  function encodeMVT(data, options) {
+    const { mvt } = options || {};
+    const encodeOptions = {
+      layerName: mvt?.layerName || "geojsonLayer",
+      version: mvt?.version || 1,
+      extent: mvt?.extent || 4096,
+      tileIndex: mvt?.tileIndex
+    };
+    return fromGeojson(data, encodeOptions);
+  }
+
+  // src/mvt-writer.ts
   var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+  var MVTWriter = {
+    ...MVTFormat,
+    version: VERSION5,
+    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);
+    }
+  };
+
+  // ../images/src/lib/utils/version.ts
+  var VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
@@ -3615,7 +3984,6 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -3643,8 +4011,13 @@ var __exports__ = (() => {
     return await createImageBitmap(blob);
   }
   function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
+    if (!object) {
+      return true;
+    }
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -3875,7 +4248,7 @@ var __exports__ = (() => {
     id: "image",
     module: "images",
     name: "Images",
-    version: VERSION5,
+    version: VERSION6,
     mimeTypes: MIME_TYPES,
     extensions: EXTENSIONS,
     parse: parseImage,
@@ -3982,8 +4355,8 @@ var __exports__ = (() => {
     }
     async _parseVectorTile(arrayBuffer, tileParams) {
       const loadOptions = {
-        shape: "geojson-table",
         mvt: {
+          shape: "geojson-table",
           coordinates: "wgs84",
           tileIndex: { x: tileParams.x, y: tileParams.y, z: tileParams.z },
           ...this.loadOptions?.mvt