Reading, Modifying and Writing a pmtiles file using node (preferably)

[amdevelopment-world]

Hello, i would like to read a planet.pmtiles file add some properties, and write the result, i thought that is an easier way to add data to my pmtiles file than to generate the whole file from pbf, because all the geometry is allready present
i just need to add some tags from OSM, anyway, i can't find how to do this with the pmtiles node module, i saw some examples in python, but that is not a language i use often, and i allready have a lot of node code that would be involved in selecting what features i want to "enrich", sadly i can't find any sample code, and my friend chatGPT seems to ignore that the API has changed and keeps suggesting me to use methods and classes that no longer exist, by default PMTiles will download tiles from a server, i would prefer to use a local file instead, all i need is a function that takes two paths (input and output) and a callback that is called for each feature.

[bdon]

There isn't a package I know of to do this in NodeJS right now. You would need to:

1. use the NodeJS standard library to do file I/o
2. read the PMTiles header and directory to determine all the file contents
3. iterate through all the tile contents by offset, parse them via the @mapbox/vector-tile library, modify the tags, and write out a new vector tile, keeping track of the new sizes
4. write a new PMTiles header and directory based on the new sizes

[amdevelopment-world]

i tried a new approach, reading from pmtiles, writing to mbtiles, it works !

the final working code :) thx for inspiration.

`import fs from 'fs'
import path from 'path'
import { fileURLToPath } from 'url'
import { Worker, isMainThread, parentPort, workerData } from 'worker_threads'

import { PMTiles } from 'pmtiles'
import MBTiles from '@mapbox/mbtiles'
import { VectorTile } from '@mapbox/vector-tile'
import Pbf from 'pbf'
import vtpbf from 'vt-pbf'

import { lngLatToTileCoord } from '@mymap/map_utilities'

const pathToThisModule = fileURLToPath(import.meta.url)

class FileSource {
constructor(filename) {
this.fd = fs.openSync(filename, 'r')
}

getKey() {
return ''
}

async getBytes(offset, length) {
const buffer = Buffer.alloc(length)
await new Promise((resolve, reject) => fs.read(this.fd, buffer, 0, length, offset, err => (err ? reject(err) : resolve())))
const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength)
return { data: arrayBuffer }
}
}

/*
"segment" is an object containing
topLeft: [lng, lat]
bottomRight: : [lng, lat],
minZoom: 14,
maxZoom: 15,
*/

const processSegment = async (sourceFilePath, destinationFilePath, segment) => {
const reader = new PMTiles(new FileSource(sourceFilePath))

new MBTiles(destinationFilePath + '?mode=rwc', (error, mbtiles) => {
if (error) throw error
mbtiles.startWriting(async error => {
if (error) throw error

  for (let z = segment.minZoom; z <= segment.maxZoom; z++) {
    const topLeft = lngLatToTileCoord(...segment.topLeft, z)
    const bottomRight = lngLatToTileCoord(...segment.bottomRight, z)

    const minX = Math.min(topLeft.x, bottomRight.x)
    const maxX = Math.max(topLeft.x, bottomRight.x)

    const minY = Math.min(topLeft.y, bottomRight.y)
    const maxY = Math.max(topLeft.y, bottomRight.y)


    for (let x = minX; x < maxX; x++) {
      for (let y = minY; y < maxY; y++) {
        const tile = await reader.getZxy(z, x, y)

        if (!tile) continue

        let tileNeedsReencode = false

        let pbfBuffer = Buffer.from(tile.data)

        const vectorTile = new VectorTile(new Pbf(pbfBuffer))

        for (const layerName in vectorTile.layers) {
          let layerNeedsReencode = false

          const layer = vectorTile.layers[layerName]
          const modifiedFeatures = new Array(layer.length)

          for (let i = 0; i < layer.length; i++) {
            const feature = layer.feature(i)

            if (feature.id == 321323213213213212123213123) {
              layerNeedsReencode = true
              feature.properties.hello = "Hello, i'm here :)"
            }

            modifiedFeatures[i] = feature
          }

          if (layerNeedsReencode) {
            tileNeedsReencode = true
            layer.modifiedFeatures = modifiedFeatures
            // "patch" the feature method to make it return the modified features
            layer.feature = function (index) {
              return this.modifiedFeatures[index]
            }
          }
        }

        if (tileNeedsReencode) {
          pbfBuffer = Buffer.from(vtpbf.fromVectorTileJs(vectorTile))
        }

        mbtiles.putTile(z, x, y, pbfBuffer, error => {
          if (error) throw error
        })
      }
    }
  }

  mbtiles.stopWriting(error => {
    if (error) throw error
  })
})

})
}
`