How to use the mapnik.Grid function in mapnik

// add this layer to the map
map.add_layer(l);

// zoom to the extent of the new layer (pulled from options since otherwise we cannot know)
map.zoomAll();

// render it! You should see a bunch of red and blue points
map.renderFileSync('memory_points.png');

var options = {
    layer: 0,
    fields: ['POP2005', 'NAME', 'feat_id']
    };

var grid = new mapnik.Grid(map.width, map.height, {key: 'feat_id'});
map.render(grid, options, function(err, grid) {
    if (err) throw err;
    fs.writeFileSync('memory_points.json', JSON.stringify(grid.encodeSync('utf', {resolution: 4})));
});

console.log('rendered to memory_points.png and memory_points.json');

MapnikSource.prototype._renderMetatile = function(options, callback) {
    var source = this;

    // Calculate bbox from xyz, respecting metatile settings.
    var meta = calculateMetatile(options);

    // Set default options.
    if (options.format === 'utf') {
        options.layer = source._info.interactivity_layer;
        options.fields = source._info.interactivity_fields;
        options.resolution = source._uri.query.resolution;
        options.headers = { 'Content-Type': 'application/json' };
        var image = new mapnik.Grid(meta.width, meta.height);
    } else {
        // NOTE: formats use mapnik syntax like `png8:m=h` or `jpeg80`
        // so we need custom handling for png/jpeg
        if (options.format.indexOf('png') != -1) {
            options.headers = { 'Content-Type': 'image/png' };
        } else if (options.format.indexOf('jpeg') != -1 ||
                   options.format.indexOf('jpg') != -1) {
            options.headers = { 'Content-Type': 'image/jpeg' };
        } else {
            // will default to 'application/octet-stream' if unable to detect
            options.headers = { 'Content-Type': mime.lookup(options.format.split(':')[0]) };
        }
        var image = new mapnik.Image(meta.width, meta.height);
    }

    options.scale = +source._uri.query.scale;

// node-mapnik latest defaults to
            // key:"__id__", resolution:4,fields:[]
            // but specify here for clarity and backwards compatibility
            options.fields = options.fields || [];
            options.key = options.key || options.key_name || '__id__';
            options.resolution = options.resolution || 4;
            // this is an override to be able to pass the right argument to mapnik
            // grid.json -> utf
            options.format = 'utf';
            options.content_type = {'Content-Type': 'text/javascript; charset=utf-8'};

            var grid;
            if (options.metatile > 1) {
                var render_size = 256 * options.metasize;
                map.resize(render_size, render_size);
                grid = new mapnik.Grid(render_size, render_size, {key: options.key});
                map.extent = xyz_to_meta_bbox(options);
            } else {
                grid = new mapnik.Grid(map.width, map.height, {key: options.key});
                map.extent = options.bbox;
            }
            try {
                map.render(grid, options, function(err, grid) {
                    if (err) return callback(err, null);
                    if (options.metatile > 1) {
                        split_meta(grid, options, callback);
                    } else {
                        callback(null, [
                            grid.encode('utf', options),
                            options.content_type
                        ]);
                    }

options.fields = options.fields || [];
            options.key = options.key || options.key_name || '__id__';
            options.resolution = options.resolution || 4;
            // this is an override to be able to pass the right argument to mapnik
            // grid.json -> utf
            options.format = 'utf';
            options.content_type = {'Content-Type': 'text/javascript; charset=utf-8'};

            var grid;
            if (options.metatile > 1) {
                var render_size = 256 * options.metasize;
                map.resize(render_size, render_size);
                grid = new mapnik.Grid(render_size, render_size, {key: options.key});
                map.extent = xyz_to_meta_bbox(options);
            } else {
                grid = new mapnik.Grid(map.width, map.height, {key: options.key});
                map.extent = options.bbox;
            }
            try {
                map.render(grid, options, function(err, grid) {
                    if (err) return callback(err, null);
                    if (options.metatile > 1) {
                        split_meta(grid, options, callback);
                    } else {
                        callback(null, [
                            grid.encode('utf', options),
                            options.content_type
                        ]);
                    }
                });
            } catch (err) {
                callback(err);

map.add_layer(layer);

              var vtile = new mapnik.VectorTile( z, x, y );
              map.extent = mercator.bbox(x, y, z, false, '900913');

              map.render( vtile, {}, function( err, vtile ) {
                if (err) {
                  callback( err, null );
                } else {
                  fs.writeFileSync( file, vtile.getData() );
                  callback( null, file );
                }
              });

            } else if ( format == 'utf') {
              var grid = new mapnik.Grid(256, 256, {key: '__id__'});
              map = new mapnik.Map(256, 256);
              map.loadSync(__dirname + '/../templates/renderers/style.xml');
              layer = new mapnik.Layer('tile');
              layer.datasource = new mapnik.Datasource( { type: 'geojson', file: jsonFile } );
              // add styles 
              var options = {layer:0};
              if (geojson && geojson.features && geojson.features.length){
                layer.styles = [geojson.features[0].geometry.type.toLowerCase()];
                options.fields = Object.keys( geojson.features[0].properties );
              }
              map.add_layer(layer);
              map.extent = mercator.bbox(x, y, z, false, '900913');


              map.render( grid, options, function( err, g ) {
                if (err) {

let { tileSize } = global.config;
  if ( req.largeTiles ) { tileSize *= 2; }
  if ( req.params.format === "grid.json" ) {
    fields = _.without( req.query.source.includes,
      global.config.elasticsearch.geoPointField );
    // geohash aggregations will have cellCount
    if ( req.elastic_query.aggregations && req.elastic_query.aggregations.zoom1 ) {
      fields.push( "cellCount" );
    }
    fields = fields.concat( ["latitude", "longitude"] );

    const options = { };
    options.layer = "tile";
    options.fields = fields;
    options.headers = { "Content-Type": "application/json" };
    const im = new mapnik.Grid( tileSize / 2, tileSize / 2, { key: "id" } );
    map.render( im, options, ( err, img ) => {
      if ( err ) { return callback( err, req, res ); }
      req.tileData = img.encodeSync( );
      return callback( null, req, res );
    } );
  } else {
    const im = new mapnik.Image( tileSize, tileSize );
    map.render( im, { scale: 2 }, ( err, img ) => {
      if ( err ) { return callback( err, req, res ); }
      req.tileData = img.encodeSync( );
      return callback( null, req, res );
    } );
  }
};
/* eslint-enable no-param-reassign */

module.exports.utfGrid = async (mapConfig, utfFields) => {
    const grid = new mapnik.Grid(TILE_WIDTH, TILE_HEIGHT)
    const map = await createMap(mapConfig)
    try {
        const tile = await promisifyMethod(map, 'render')(grid, { layer: 0, fields: utfFields })
        const encoded = await promisifyMethod(tile, 'encode')({ resolution: 4 })
        return encoded
    } catch (err) {
        throw postgisFilter(err)
    }
}