vtt 0.0.1

package/LICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "vtt",
+  "version": "0.0.1",
+  "description": "Vector Tile Transform",
+  "main": "vtt.js",
+  "author": "yetzt <node@yetzt.me>",
+  "license": "Unlicense",
+  "dependencies": {
+    "pbf": "^3"
+  },
+  "keywords": [
+    "vt",
+    "vector",
+    "tile",
+    "tiles",
+    "maps",
+    "map",
+    "pbf",
+    "mvt",
+    "stream",
+    "vector-tile",
+    "vectortile",
+    "modify",
+    "edit",
+    "change"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yetzt/node-vtt.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yetzt/node-vtt/issues"
+  },
+  "homepage": "https://github.com/yetzt/node-vtt#readme"
+}

package/readme.md

@@ -0,0 +1,72 @@
+# Vector Tile Transformer
+
+Vector Tile Transformer lets you change [Vector Tiles](https://github.com/mapbox/vector-tile-spec) in a stream.
+
+## API
+
+### `stream = vtt(function(data, fn){ /* ... */ })`
+
+A transform stream passing the unpacked vector tile data to a function for modification.
+
+#### Example
+
+``` js
+
+const fs = require("fs");
+
+const src = fs.createReadStream("tile-in.pbf");
+const dest = fs.createWriteStream("tile-out.pbf");
+
+const vtt = require("vtt");
+
+src.pipe(vtt(function(layers, done){
+	
+	// filter layers by name
+	layers = layers.filter(function(layer){
+		return (layer.name !== "keepme");
+	});
+	
+	// add a property to all features in a layer
+	layers[0] = layers[0].map(function(feature){
+		feature.properties.modified = true;
+		return feature;
+	});
+	
+	done(null, layers); // err, data
+	
+})).pipe(dest);
+
+```
+
+#### `data`
+
+``` js
+
+[{
+	version: 2,
+	name: "name",
+	extent: 4096,
+	features: [{
+		id: 1,
+		type: 1,
+		properties: {
+			key: "value",
+		},
+		geometry: (...geometry),
+	}],
+}]
+
+```
+
+
+### `data = vtt.unpack(buffer);`
+
+Sync convenience method to turn an uncompressed vector tile into an object
+
+### `buffer = vtt.pack(data);`
+
+Sync convenience method to turn an object back into an uncompressed vector tile
+
+## License
+
+[UNLICENSE](https://unlicense.org/)

package/vtt.js

@@ -0,0 +1,240 @@
+const pbf = require("pbf");
+const stream = require("stream");
+
+const vtt = module.exports = function vtt(){
+	if (!(this instanceof vtt)) return new vtt(...arguments);
+	const fn = Array.from(arguments).find(function(arg){ return (typeof arg === "function") });
+	// data = args.find(function(arg){ return (typeof arg === "object" && Buffer.isBuffer(arg)) });
+
+	let buf = [];
+	return new stream.Transform({
+		transform: function(chunk, encoding, done) {
+			buf.push(chunk);
+			done();
+		},
+		flush: function(done) {
+			const s = this;
+			if (!fn) return s.emit("error", new Error("Missing Modify Function")), done();
+			fn(unpack(Buffer.concat(buf)), function(err, data){ // FIXME error?
+				if (err) return s.emit("error", new Error(err)), done();
+				s.emit("data", pack(data)), done();
+			});
+		}
+	});
+
+};
+
+const unpack = module.exports.unpack = function unpack(buf){
+	return (new pbf(buf)).readFields(function(tag, layers, pb){
+		if (tag === 0x3) {
+			
+			const layer = {
+				version: 1,
+				name: null,
+				extent: 4096,
+				features: [],
+				keys: [],
+				values: [],
+			};
+
+			pb.readFields(function(tag, l, pb) {
+				switch (tag) {
+					case 0xf: l.version = pb.readVarint(); break;
+					case 0x1: l.name = pb.readString(); break;
+					case 0x5: l.extent = pb.readVarint(); break;
+					case 0x2: 
+						const feature = { type: 0, properties: [], geometry: -1 };
+						pb.readFields(function(tag, f, pb) {
+							let end;
+							switch (tag) {
+								case 0x1: f.id = pb.readVarint(); break;
+								case 0x3: f.type = pb.readVarint(); break;
+								case 0x2: // read properties
+									end = pb.readVarint() + pb.pos;
+									while (pb.pos < end) f.properties.push([ pb.readVarint(), pb.readVarint() ]);
+								break;
+								case 0x4: // read geometry
+									f.geometry = [];
+									end = pb.readVarint() + pb.pos;
+									let cmd = 1;
+									let len = 0;
+									let x = 0;
+									let y = 0;
+									let ring = [];
+									let inst;
+									while (pb.pos < end) {
+										if (len-- <= 0) inst = pb.readVarint(), cmd = inst & 0x7, len = (inst >> 3) - 1;
+										switch (cmd) {
+											case 0x1: // moveto; new ring
+												if (ring.length > 0) f.geometry.push(ring), ring = [];
+												case 0x2: // lineto, fill ring
+												ring.push([ x += pb.readSVarint(), y += pb.readSVarint() ]);
+											break;
+											case 0x7: // close, close polygon
+												if (ring.length > 0) ring.push([ ring[0][0], ring[0][1] ]); // close polygon
+											break;
+											default:
+												throw new Error("unknown command "+cmd);
+											break;
+										}
+									}
+									if (ring.length > 0) f.geometry.push(ring);
+								break;
+							}
+						}, feature, pb.readVarint()+pb.pos);
+						l.features.push(feature);
+					break;
+					case 0x3: l.keys.push(pb.readString()); break;
+					case 0x4: 
+						let end = (pb.readVarint()+pb.pos);
+						while (pb.pos < end) {
+							switch (pb.readVarint() >> 3) {
+								case 0x1: l.values.push(pb.readString()); break;
+								case 0x2: l.values.push(pb.readFloat()); break;
+								case 0x3: l.values.push(pb.readDouble()); break;
+								case 0x4: l.values.push(pb.readVarint64()); break; // deprecated
+								case 0x5: l.values.push(pb.readVarint()); break;
+								case 0x6: l.values.push(pb.readSVarint()); break;
+								case 0x7: l.values.push(pb.readBoolean()); break;
+							};
+						};
+					break;
+				};
+			}, layer, pb.readVarint()+pb.pos);
+
+			// map keys and values
+			layer.features = layer.features.map(function(f){
+				return f.properties = f.properties.reduce(function(p,v){
+					return p[layer.keys[v[0]]]=layer.values[v[1]],p;
+				},{}), f;
+			});
+			
+			layers.push(layer);
+		}
+			
+	}, []);
+};
+
+const pack = module.exports.pack = function js2pbf(tile){
+
+	const pb = new pbf();
+
+	tile.map(function(layer){
+		
+		// destruct properties
+		const keys = {};
+		const values = {};
+		let kidx = 0;
+		let vidx = 0;
+		
+		layer.features = layer.features.map(function(feature){
+			
+			feature.properties = Object.entries(feature.properties).filter(function([ k, v ]){
+				return (v === null || typeof v !== undefined);
+			}).map(function([ k, v ]){
+
+				// create a unique string for value, good enough™
+				const vk = (typeof v)+":"+v.toString();
+
+				if (!keys.hasOwnProperty(k)) keys[k] = kidx++;
+				if (!values.hasOwnProperty(vk)) values[vk] = [ vidx++, v ];
+				return [ keys[k], values[vk][0] ];
+				
+			});
+			
+			return feature;
+			
+		});
+		
+		// flatten keys and values
+		layer.keys = Object.entries(keys).reduce(function(l, [ k, v ]){ return l[v]=k,l },[]);
+		layer.values = Object.entries(values).reduce(function(l, [ k, v ]){ return l[v[0]]=v[1],l },[]);
+		
+		return layer;
+		
+	}).forEach(function(layer){
+			
+		// construct protobuf
+		pb.writeMessage(3, function(l, p){
+			
+			// write version, name and extent
+			pb.writeVarintField(15, layer.version || 1);
+			pb.writeStringField(1, layer.name || "");
+			pb.writeVarintField(5, layer.extent || 4096);
+			
+			// write keys
+			layer.keys.forEach(function(k){
+				pb.writeStringField(3, k);
+			});
+
+			// write values
+			layer.values.forEach(function(v){
+				pb.writeMessage(4, function(v, pb){
+					switch (typeof v) {
+						case "string": pb.writeStringField(1, v); break;
+						case "boolean": pb.writeBooleanField(7, v); break;
+						case "number":
+							if (v % 1 !== 0) return pb.writeDoubleField(3, v); // in js all floats are doubles regardless
+							if (v < 0) return pb.writeSVarintField(6, v);
+							pb.writeVarintField(5, v);
+						break;
+						case "bigint":
+							pb.writeVarintField(4, v);
+						break;
+						default:
+							throw new Error("Property value has invalid type: "+(typeof v));
+						break;
+					}
+				}, v);
+				
+			});
+
+			// write features
+			layer.features.forEach(function(feature){
+				
+				// write feature
+				pb.writeMessage(2, function(){
+
+					// write id and type
+					if (feature.id !== undefined) pb.writeVarintField(1, feature.id);
+					pb.writeVarintField(3, feature.type);
+
+					// write properties
+					pb.writeMessage(2, function(properties,pb){
+						feature.properties.forEach(function(property){
+							pb.writeVarint(property[0]); // key-id
+							pb.writeVarint(property[1]); // value-id
+						});
+					}, feature.properties);
+					
+					// write geometry — https://github.com/mapbox/vector-tile-spec/blob/master/2.1/README.md#43-geometry-encoding
+					pb.writeMessage(4, function(feature, pb){
+						let x = 0, y = 0;
+						feature.geometry.forEach(function(ring){
+							let dx = 0, dy = 0;
+							// write length 1 and MoveTo first coordinate pair
+
+							pb.writeVarint((1<<3)+0x1);
+							pb.writeSVarint(dx = ring[0][0] - x);
+							pb.writeSVarint(dy = ring[0][1] - y);
+							if (feature.type > 0x1) { // only lines and polygons
+								let len = ring.length+2-feature.type; // omit last coordinate pair for polygons
+								pb.writeVarint(((len-1)<<3)+0x2); // length (without first element) and LineTo
+								for (let i = 1; i < len; i++) { // write remaining coordinates, start with second coordinate
+									pb.writeSVarint(dx = ring[i][0] - (x += dx));
+									pb.writeSVarint(dy = ring[i][1] - (y += dy));
+								};
+								// in case of more rings:
+								x += dx, y += dy;
+							};
+							if (feature.type === 0x3) pb.writeVarint((1<<3)+0x7); // ClosePath for polygons
+						});
+					}, feature);
+				}, feature);
+			});
+		}, layer);
+	});
+	
+	return pb.finish();
+
+};