### End-to-End Rust Vector Tile Processing

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

A complete Rust example demonstrating the workflow of reading a vector tile from a file, iterating through its layers and features, and collecting statistics.

```rust
use mvt_reader::{Reader, error::ParserError};
use mvt_reader::feature::Value;
use geo_types::Geometry;
use std::fs;
use std::collections::HashMap;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load tile from file
    let tile_path = "data/14_8185_5449.mvt";
    let tile_data = fs::read(tile_path)?;

    println!("Loaded {} bytes from {}", tile_data.len(), tile_path);

    // Create reader
    let reader = Reader::new(tile_data)?;

    // Get layer metadata
    let layers = reader.get_layer_metadata()?;
    println!("\nTile contains {} layers:", layers.len());

    for layer in &layers {
        println!("\n=== Layer: {} ===", layer.name);
        println!("  Version: {}, Extent: {}, Features: {}",
                 layer.version, layer.extent, layer.feature_count);

        // Extract features from this layer
        let features = reader.get_features(layer.layer_index)?;

        // Collect geometry type statistics
        let mut geom_counts: HashMap<&str, usize> = HashMap::new();

        for feature in &features {
            let geom_type = match feature.get_geometry() {
                Geometry::Point(_) => "Point",
                Geometry::MultiPoint(_) => "MultiPoint",
                Geometry::LineString(_) => "LineString",
                Geometry::MultiLineString(_) => "MultiLineString",
                Geometry::Polygon(_) => "Polygon",
                Geometry::MultiPolygon(_) => "MultiPolygon",
                _ => "Other",
            };
            *geom_counts.entry(geom_type).or_insert(0) += 1;
        }

        println!("  Geometry types:");
        for (geom_type, count) in &geom_counts {
            println!("    {}: {}", geom_type, count);
        }

        // Show sample feature properties
        if let Some(first_feature) = features.first() {
            if let Some(props) = &first_feature.properties {
                println!("  Sample properties:");
                for (key, value) in props.iter().take(5) {
                    let value_str = match value {
                        Value::String(s) => format!("\"{}\"", s),
                        Value::Int(i) => i.to_string(),
                        Value::Float(f) => f.to_string(),
                        Value::Double(d) => d.to_string(),
                        Value::Bool(b) => b.to_string(),
                        Value::UInt(u) => u.to_string(),
                        Value::SInt(s) => s.to_string(),
                        Value::Null => "null".to_string(),
                    };
                    println!("    {}: {}", key, value_str);
                }
            }
        }
    }

    Ok(())
}

```

--------------------------------

### Basic Rust usage of mvt-reader

Source: https://github.com/codeart1st/mvt-reader/blob/main/README.md

Demonstrates reading vector tile data, getting layer names, and iterating through features in Rust. Ensure the `ParserError` is handled.

```rust
use mvt_reader::{Reader, ParserError};

fn main() -> Result<(), ParserError> {
  // Read a vector tile from file or data
  let data = vec![/* Vector tile data */];
  let reader = Reader::new(data)?;

  // Get layer names
  let layer_names = reader.get_layer_names()?;
  for name in layer_names {
    println!("Layer: {}", name);
  }

  // Get features for a specific layer
  let layer_index = 0;
  let features = reader.get_features(layer_index)?;
  for feature in features {
    todo!()
  }

  Ok(())
}
```

--------------------------------

### Process and Create Geographic Features

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Demonstrates how to access geometry, ID, and properties of a Feature. Includes an example of manually creating a Feature for testing purposes.

```rust
use mvt_reader::feature::{Feature, Value};
use geo_types::{Geometry, Point};
use std::collections::HashMap;

fn process_feature(feature: &Feature) {
    // Access the geometry reference
    let geom: &Geometry<f32> = feature.get_geometry();

    // Check geometry type and extract coordinates
    if let Geometry::MultiPoint(mp) = geom {
        for point in &mp.0 {
            println!("Point at ({}, {})", point.x(), point.y());
        }
    }

    // Access optional feature ID
    match feature.id {
        Some(id) => println!("Feature ID: {}", id),
        None => println!("Feature has no ID"),
    }

    // Access optional properties
    if let Some(props) = &feature.properties {
        for (key, value) in props {
            println!("{}: {:?}", key, value);
        }
    }
}

// Create a feature manually (for testing)
fn create_test_feature() -> Feature<f32> {
    let mut properties = HashMap::new();
    properties.insert("name".to_string(), Value::String("Test Point".to_string()));
    properties.insert("population".to_string(), Value::Int(1000));

    Feature {
        geometry: Geometry::Point(Point::new(25.0, 17.0)),
        id: Some(1),
        properties: Some(properties),
    }
}
```

--------------------------------

### WebAssembly usage of mvt-reader in JavaScript

Source: https://github.com/codeart1st/mvt-reader/blob/main/README.md

Shows how to import and use the mvt-reader library as a WebAssembly module in a Node.js environment. Requires npm installation.

```js
const { Reader } = require('mvt-reader')
const fs = require('fs')

// Example usage
const reader = new Reader(fs.readFileSync('path/to/tile.mvt'))
const layerNames = reader.getLayerNames()
console.log(layerNames)

// More code...
```

--------------------------------

### Get Layer Names and Metadata in Node.js

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Retrieves the names and metadata for all layers within a loaded vector tile. Metadata includes index, version, feature count, and extent.

```javascript
// Get layer names
const layerNames = reader.getLayerNames();
console.log('Layers:', layerNames);
// Output: ['roads', 'buildings', 'water']
```

```javascript
// Get layer metadata
const layers = reader.getLayerMetadata();
layers.forEach(layer => {
    console.log(`Layer: ${layer.name}`);
    console.log(`  Index: ${layer.layer_index}`);
    console.log(`  Version: ${layer.version}`);
    console.log(`  Features: ${layer.feature_count}`);
    console.log(`  Extent: ${layer.extent}`);
});
```

--------------------------------

### Retrieve Layer Names from Tile

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Get a list of all layer names present in the vector tile. Layer names are strings that categorize data within the tile, such as 'roads' or 'buildings'. This function requires a successfully initialized `Reader`.

```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get all layer names in the tile
    let layer_names = reader.get_layer_names()?;

    for name in &layer_names {
        println!("Layer: {}", name);
    }
    // Output example:
    // Layer: roads
    // Layer: buildings
    // Layer: water
    // Layer: landuse

    Ok(())
}
```

--------------------------------

### Build the mvt-reader project

Source: https://github.com/codeart1st/mvt-reader/blob/main/README.md

Use this command to build the project in release mode.

```sh
cargo build --release
```

--------------------------------

### Load and Read Vector Tile Data in Node.js

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Loads tile data from a file and initializes the mvt-reader. Includes optional error handling during initialization.

```javascript
const { Reader } = require('mvt-reader');
const fs = require('fs');

// Load tile data
const tileData = fs.readFileSync('path/to/tile.mvt');

// Create reader with optional error callback
const reader = new Reader(tileData, (error) => {
    console.error('Parse error:', error);
});
```

--------------------------------

### Run tests for mvt-reader

Source: https://github.com/codeart1st/mvt-reader/blob/main/README.md

Commands to run tests for both native Rust and WebAssembly targets.

```sh
cargo test
wasm-pack build --release --target nodejs -d pkg/node -- --features wasm && npm test
```

--------------------------------

### Create Reader from Vector Tile Data

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Instantiate a `Reader` by providing raw vector tile bytes. This constructor validates the tile format and may return a `ParserError` if decoding fails. Ensure the file path points to a valid .mvt file.

```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    // Read vector tile from file
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read tile file");

    // Create reader from raw bytes
    let reader = Reader::new(tile_data)?;

    // Reader is now ready to extract layers and features
    println!("Tile loaded successfully");
    Ok(())
}
```

--------------------------------

### Display Layer Information

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Shows how to extract and display metadata for a given MVT layer, including its index, name, version, feature count, and extent.

```rust
use mvt_reader::layer::Layer;

fn display_layer_info(layer: &Layer) {
    println!("Layer Details:");
    println!("  Index: {}", layer.layer_index);
    println!("  Name: {}", layer.name);
    println!("  Version: {} (MVT spec version)", layer.version);
    println!("  Features: {}", layer.feature_count);
    println!("  Extent: {} pixels", layer.extent);
}

// Layer struct fields:
// - layer_index: usize   - Position in the tile's layer array
// - version: u32         - MVT specification version (1 or 2)
// - name: String         - Layer identifier
// - feature_count: usize - Number of features in the layer
// - extent: u32          - Tile size in pixels (typically 4096)
```

--------------------------------

### Reader::new - Create a new Reader from vector tile data

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Creates a new `Reader` instance by decoding Protocol Buffers-encoded vector tile data. The constructor validates the tile format and returns a `ParserError` if decoding fails.

```APIDOC
## Reader::new - Create a new Reader from vector tile data

### Description
Creates a new `Reader` instance by decoding Protocol Buffers-encoded vector tile data. The constructor validates the tile format and returns a `ParserError` if decoding fails.

### Method
`new`

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **tile_data** (bytes) - Required - Raw vector tile data.

### Request Example
```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    // Read vector tile from file
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read tile file");

    // Create reader from raw bytes
    let reader = Reader::new(tile_data)?;

    // Reader is now ready to extract layers and features
    println!("Tile loaded successfully");
    Ok(())
}
```

### Response
#### Success Response (Reader)
- **reader** (Reader) - An initialized `Reader` instance.

#### Error Response (ParserError)
- **error** (ParserError) - An error if the tile data is invalid or cannot be decoded.
```

--------------------------------

### Handle MVT Parsing Errors

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Demonstrates how to handle potential errors during MVT tile reading and parsing, including identifying specific error types like GeometryError, TagsError, VersionError, and DecodeError.

```rust
use mvt_reader::{Reader, error::ParserError};
use mvt_reader::error::{GeometryError, TagsError, VersionError, DecodeError};
use std::error::Error;

fn handle_tile_errors(data: Vec<u8>) {
    let reader = match Reader::new(data) {
        Ok(r) => r,
        Err(e) => {
            println!("Failed to create reader: {}", e);
            // Check underlying error type
            if let Some(source) = e.source() {
                println!("Caused by: {}", source);
            }
            return;
        }
    };

    match reader.get_features(0) {
        Ok(features) => {
            println!("Parsed {} features successfully", features.len());
        }
        Err(error) => {
            // Identify specific error type
            if let Some(source) = error.source() {
                if source.is::<GeometryError>() {
                    println!("Geometry parsing failed: {}", source);
                } else if source.is::<TagsError>() {
                    println!("Tags parsing failed: {}", source);
                } else if source.is::<VersionError>() {
                    println!("Unsupported tile version: {}", source);
                } else {
                    println!("Other error: {}", source);
                }
            }
        }
    }
}

// Create custom errors
fn create_custom_error() -> ParserError {
    let io_error = std::io::Error::new(std::io::ErrorKind::Other, "Custom error");
    ParserError::new(io_error)
}
```

--------------------------------

### Handle Invalid Tile Data in Node.js

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Demonstrates error handling when attempting to read invalid or corrupted tile data. The reader will enter an error state, and methods will return null.

```javascript
// Error handling example
const errorReader = new Reader(invalidData, (error) => {
    console.error('Decode failed:', error);
    // Error string format: "ParserError { source: DecodeError { ... } }"
});

// Methods return null on error
const names = errorReader.getLayerNames(); // Returns null if reader failed
if (names === null) {
    console.log('Reader is in error state');
}
```

--------------------------------

### Retrieve Metadata for All Layers

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Fetch detailed metadata for every layer within the vector tile. This includes the layer's index, version, name, the count of features it contains, and its extent (typically the tile's pixel dimensions).

```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get metadata for all layers
    let layers = reader.get_layer_metadata()?;

    for layer in &layers {
        println!("Layer Index: {}", layer.layer_index);
        println!("Name: {}", layer.name);
        println!("Version: {}", layer.version);
        println!("Feature Count: {}", layer.feature_count);
        println!("Extent: {}", layer.extent);
        println!("---");
    }
    // Output example:
    // Layer Index: 0
    // Name: hello
    // Version: 2
    // Feature Count: 1
    // Extent: 4096

    Ok(())
}
```

--------------------------------

### Process MVT Property Values

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Illustrates how to match and process different MVT property value types using the Value enum, including String, Float, Double, Int, UInt, SInt, Bool, and Null.

```rust
use mvt_reader::feature::Value;

fn process_value(key: &str, value: &Value) {
    match value {
        Value::String(s) => println!("{}: \"{}\" (string)", key, s),
        Value::Float(f) => println!("{}: {} (f32)", key, f),
        Value::Double(d) => println!("{}: {} (f64)", key, d),
        Value::Int(i) => println!("{}: {} (i64)", key, i),
        Value::UInt(u) => println!("{}: {} (u64)", key, u),
        Value::SInt(s) => println!("{}: {} (signed i64)", key, s),
        Value::Bool(b) => println!("{}: {} (bool)", key, b),
        Value::Null => println!("{}: null", key),
    }
}

// Example property values from MVT tiles:
// "name" -> Value::String("Main Street")
// "population" -> Value::Int(50000)
// "area_km2" -> Value::Double(125.5)
// "is_capital" -> Value::Bool(true)
```

--------------------------------

### Add mvt-reader dependency to Cargo.toml

Source: https://github.com/codeart1st/mvt-reader/blob/main/README.md

Add this line to your Cargo.toml file to include the mvt-reader library in your Rust project.

```toml
[dependencies]
mvt-reader = "2.3.0"
```

--------------------------------

### Reader::get_layer_metadata - Retrieve metadata for all layers

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Returns detailed metadata for each layer including layer index, version, name, feature count, and extent (tile size in pixels, typically 4096).

```APIDOC
## Reader::get_layer_metadata - Retrieve metadata for all layers

### Description
Returns detailed metadata for each layer including layer index, version, name, feature count, and extent (tile size in pixels, typically 4096).

### Method
`get_layer_metadata`

### Endpoint
N/A (Library function)

### Parameters
None

### Request Example
```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get metadata for all layers
    let layers = reader.get_layer_metadata()?;

    for layer in &layers {
        println!("Layer Index: {}", layer.layer_index);
        println!("Name: {}", layer.name);
        println!("Version: {}", layer.version);
        println!("Feature Count: {}", layer.feature_count);
        println!("Extent: {}", layer.extent);
        println!("---");
    }
    // Output example:
    // Layer Index: 0
    // Name: hello
    // Version: 2
    // Feature Count: 1
    // Extent: 4096

    Ok(())
}
```

### Response
#### Success Response (Vec<LayerMetadata>)
- **layers** (Vec<LayerMetadata>) - A vector of `LayerMetadata` structs, each containing details about a layer.
  - **layer_index** (usize) - The index of the layer.
  - **name** (String) - The name of the layer.
  - **version** (u32) - The version of the layer.
  - **feature_count** (usize) - The number of features in the layer.
  - **extent** (u32) - The extent (tile size in pixels) of the layer.

#### Error Response (ParserError)
- **error** (ParserError) - An error if layer metadata cannot be retrieved.
```

--------------------------------

### Reader::get_layer_names - Retrieve all layer names from a tile

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Returns a vector of layer names present in the vector tile. Layer names are strings that identify different data categories within the tile (e.g., "roads", "buildings", "water").

```APIDOC
## Reader::get_layer_names - Retrieve all layer names from a tile

### Description
Returns a vector of layer names present in the vector tile. Layer names are strings that identify different data categories within the tile (e.g., "roads", "buildings", "water").

### Method
`get_layer_names`

### Endpoint
N/A (Library function)

### Parameters
None

### Request Example
```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get all layer names in the tile
    let layer_names = reader.get_layer_names()?;

    for name in &layer_names {
        println!("Layer: {}", name);
    }
    // Output example:
    // Layer: roads
    // Layer: buildings
    // Layer: water
    // Layer: landuse

    Ok(())
}
```

### Response
#### Success Response (Vec<String>)
- **layer_names** (Vec<String>) - A vector containing the names of all layers in the tile.

#### Error Response (ParserError)
- **error** (ParserError) - An error if layer names cannot be retrieved.
```

--------------------------------

### Extract All Features from a Layer

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Use this function to retrieve all geographic features from a specific layer by its index. Features include geometry, optional ID, and properties. Ensure the MVT tile data is read and the Reader is initialized.

```rust
use mvt_reader::{Reader, error::ParserError};
use mvt_reader::feature::Value;
use geo_types::Geometry;
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    let layer_names = reader.get_layer_names()?;

    // Iterate through all layers and extract features
    for (layer_index, layer_name) in layer_names.iter().enumerate() {
        let features = reader.get_features(layer_index)?;

        println!("Layer '{}' has {} features", layer_name, features.len());

        for feature in &features {
            // Access feature ID (optional)
            if let Some(id) = feature.id {
                println!("  Feature ID: {}", id);
            }

            // Access geometry
            match feature.get_geometry() {
                Geometry::Point(p) => println!("  Point: ({}, {})", p.x(), p.y()),
                Geometry::MultiPoint(mp) => println!("  MultiPoint with {} points", mp.0.len()),
                Geometry::LineString(ls) => println!("  LineString with {} coords", ls.0.len()),
                Geometry::MultiLineString(mls) => println!("  MultiLineString with {} lines", mls.0.len()),
                Geometry::Polygon(p) => println!("  Polygon with {} rings", p.interiors().len() + 1),
                Geometry::MultiPolygon(mp) => println!("  MultiPolygon with {} polygons", mp.0.len()),
                _ => println!("  Other geometry type"),
            }

            // Access properties
            if let Some(props) = &feature.properties {
                for (key, value) in props {
                    match value {
                        Value::String(s) => println!("    {}: \"{}\"", key, s),
                        Value::Int(i) => println!("    {}: {}", key, i),
                        Value::Float(f) => println!("    {}: {}", key, f),
                        Value::Double(d) => println!("    {}: {}", key, d),
                        Value::Bool(b) => println!("    {}: {}", key, b),
                        Value::UInt(u) => println!("    {}: {}", key, u),
                        Value::SInt(s) => println!("    {}: {}", key, s),
                        Value::Null => println!("    {}: null", key),
                    }
                }
            }
        }
    }

    Ok(())
}
```

--------------------------------

### Extract Features with Custom Coordinate Type

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Use the generic `get_features_as` method to specify the coordinate numeric type for extracted features. This is useful for memory optimization or specific precision requirements, supporting `f32`, `i32`, and `i16`.

```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get features with f32 coordinates (default precision)
    let features_f32 = reader.get_features(0)?;
    println!("f32 features: {}", features_f32.len());

    // Get features with i32 coordinates (integer precision)
    let features_i32 = reader.get_features_as::<i32>(0)?;
    println!("i32 features: {}", features_i32.len());

    // Get features with i16 coordinates (compact storage)
    let features_i16 = reader.get_features_as::<i16>(0)?;
    println!("i16 features: {}", features_i16.len());

    Ok(())
}
```

--------------------------------

### Reader::get_features_as - Extract features with custom coordinate type

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Generic version of `get_features` that allows specifying the coordinate numeric type. Useful for memory optimization or precision requirements. Supports `f32` (default), `i32`, and `i16`.

```APIDOC
## Reader::get_features_as - Extract features with custom coordinate type

### Description
Generic version of `get_features` that allows specifying the coordinate numeric type. Useful for memory optimization or precision requirements. Supports `f32` (default), `i32`, and `i16`.

### Method
GET (conceptual, as this is a library function)

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use mvt_reader::{Reader, error::ParserError};
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    // Get features with f32 coordinates (default precision)
    let features_f32 = reader.get_features(0)?;
    println!("f32 features: {}", features_f32.len());

    // Get features with i32 coordinates (integer precision)
    let features_i32 = reader.get_features_as::<i32>(0)?;
    println!("i32 features: {}", features_i32.len());

    // Get features with i16 coordinates (compact storage)
    let features_i16 = reader.get_features_as::<i16>(0)?;
    println!("i16 features: {}", features_i16.len());

    Ok(())
}
```

### Response
#### Success Response (200)
- **features** (Vec<Feature>): A vector of Feature objects with the specified coordinate type.

#### Response Example
```json
{
  "features": [
    {
      "id": 1,
      "geometry": {
        "type": "Point",
        "coordinates": [10, 20]
      },
      "properties": {
        "name": "Example Point"
      }
    }
  ]
}
```
```

--------------------------------

### Reader::get_features - Extract features from a layer

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Retrieves all geographic features from a specific layer by index. Each feature contains geometry (Point, LineString, Polygon, etc.), an optional ID, and optional properties as a HashMap.

```APIDOC
## Reader::get_features - Extract features from a layer

### Description
Retrieves all geographic features from a specific layer by index. Each feature contains geometry (Point, LineString, Polygon, etc.), an optional ID, and optional properties as a HashMap.

### Method
GET (conceptual, as this is a library function)

### Endpoint
N/A (Library function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
use mvt_reader::{Reader, error::ParserError};
use mvt_reader::feature::Value;
use geo_types::Geometry;
use std::fs;

fn main() -> Result<(), ParserError> {
    let tile_data = fs::read("path/to/tile.mvt").expect("Failed to read file");
    let reader = Reader::new(tile_data)?;

    let layer_names = reader.get_layer_names()?;

    // Iterate through all layers and extract features
    for (layer_index, layer_name) in layer_names.iter().enumerate() {
        let features = reader.get_features(layer_index)?;

        println!("Layer '{}' has {} features", layer_name, features.len());

        for feature in &features {
            // Access feature ID (optional)
            if let Some(id) = feature.id {
                println!("  Feature ID: {}", id);
            }

            // Access geometry
            match feature.get_geometry() {
                Geometry::Point(p) => println!("  Point: ({}, {})", p.x(), p.y()),
                Geometry::MultiPoint(mp) => println!("  MultiPoint with {} points", mp.0.len()),
                Geometry::LineString(ls) => println!("  LineString with {} coords", ls.0.len()),
                Geometry::MultiLineString(mls) => println!("  MultiLineString with {} lines", mls.0.len()),
                Geometry::Polygon(p) => println!("  Polygon with {} rings", p.interiors().len() + 1),
                Geometry::MultiPolygon(mp) => println!("  MultiPolygon with {} polygons", mp.0.len()),
                _ => println!("  Other geometry type"),
            }

            // Access properties
            if let Some(props) = &feature.properties {
                for (key, value) in props {
                    match value {
                        Value::String(s) => println!("    {}: \"{}\"", key, s),
                        Value::Int(i) => println!("    {}: {}", key, i),
                        Value::Float(f) => println!("    {}: {}", key, f),
                        Value::Double(d) => println!("    {}: {}", key, d),
                        Value::Bool(b) => println!("    {}: {}", key, b),
                        Value::UInt(u) => println!("    {}: {}", key, u),
                        Value::SInt(s) => println!("    {}: {}", key, s),
                        Value::Null => println!("    {}: null", key),
                    }
                }
            }
        }
    }

    Ok(())
}
```

### Response
#### Success Response (200)
- **features** (Vec<Feature>): A vector of Feature objects, each containing geometry, ID, and properties.

#### Response Example
```json
{
  "features": [
    {
      "id": 1,
      "geometry": {
        "type": "Point",
        "coordinates": [10, 20]
      },
      "properties": {
        "name": "Example Point",
        "value": 100
      }
    }
  ]
}
```
```

--------------------------------

### Extract Features as GeoJSON in Node.js

Source: https://context7.com/codeart1st/mvt-reader/llms.txt

Extracts features from a specific layer (by index) and formats them as GeoJSON objects. Useful for integrating with mapping libraries.

```javascript
// Get features as GeoJSON
const features = reader.getFeatures(0);
features.forEach(feature => {
    console.log('Feature:', JSON.stringify(feature, null, 2));
});
// Output example:
// {
//   "type": "Feature",
//   "id": 1,
//   "geometry": {
//     "type": "MultiPoint",
//     "coordinates": [[25, 17]]
//   },
//   "properties": {
//     "key1": "i am a string value"
//   }
// }
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.