leaflet-js 0.6.beta4

data/lib/leaflet/build/build.js

@@ -0,0 +1,193 @@
+var fs = require('fs'),
+    jshint = require('jshint'),
+    UglifyJS = require('uglify-js'),
+
+    deps = require('./deps.js').deps,
+    hintrc = require('./hintrc.js').config;
+
+function lintFiles(files) {
+
+	var errorsFound = 0,
+	    i, j, len, len2, src, errors, e;
+
+	for (i = 0, len = files.length; i < len; i++) {
+
+		jshint.JSHINT(fs.readFileSync(files[i], 'utf8'), hintrc, i ? {L: true} : null);
+		errors = jshint.JSHINT.errors;
+
+		for (j = 0, len2 = errors.length; j < len2; j++) {
+			e = errors[j];
+			console.log(files[i] + '\tline ' + e.line + '\tcol ' + e.character + '\t ' + e.reason);
+		}
+
+		errorsFound += len2;
+	}
+
+	return errorsFound;
+}
+
+function getFiles(compsBase32) {
+	var memo = {},
+	    comps;
+
+	if (compsBase32) {
+		comps = parseInt(compsBase32, 32).toString(2).split('');
+		console.log('Managing dependencies...');
+	}
+
+	function addFiles(srcs) {
+		for (var j = 0, len = srcs.length; j < len; j++) {
+			memo[srcs[j]] = true;
+		}
+	}
+
+	for (var i in deps) {
+		if (comps) {
+			if (parseInt(comps.pop(), 2) === 1) {
+				console.log('\t* ' + i);
+				addFiles(deps[i].src);
+			} else {
+				console.log('\t  ' + i);
+			}
+		} else {
+			addFiles(deps[i].src);
+		}
+	}
+
+	var files = [];
+
+	for (var src in memo) {
+		files.push('src/' + src);
+	}
+
+	return files;
+}
+
+exports.getFiles = getFiles;
+
+exports.lint = function () {
+
+	var files = getFiles();
+
+	console.log('Checking for JS errors...');
+
+	var errorsFound = lintFiles(files);
+
+	if (errorsFound > 0) {
+		console.log(errorsFound + ' error(s) found.\n');
+		fail();
+	} else {
+		console.log('\tCheck passed');
+	}
+};
+
+
+function getSizeDelta(newContent, oldContent) {
+	if (!oldContent) {
+		return 'new';
+	}
+	var newLen = newContent.replace(/\r\n?/g, '\n').length,
+		oldLen = oldContent.replace(/\r\n?/g, '\n').length,
+		delta = newLen - oldLen;
+
+	return (delta >= 0 ? '+' : '') + delta;
+}
+
+function loadSilently(path) {
+	try {
+		return fs.readFileSync(path, 'utf8');
+	} catch (e) {
+		return null;
+	}
+}
+
+function combineFiles(files) {
+	var content = '';
+	for (var i = 0, len = files.length; i < len; i++) {
+		content += fs.readFileSync(files[i], 'utf8') + '\n\n';
+	}
+	return content;
+}
+
+exports.build = function (compsBase32, buildName) {
+
+	var files = getFiles(compsBase32);
+
+	console.log('Concatenating ' + files.length + ' files...');
+
+	var copy = fs.readFileSync('src/copyright.js', 'utf8'),
+	    intro = '(function (window, document, undefined) {',
+	    outro = '}(window, document));',
+	    newSrc = copy + intro + combineFiles(files) + outro,
+
+	    pathPart = 'dist/leaflet' + (buildName ? '-' + buildName : ''),
+	    srcPath = pathPart + '-src.js',
+
+	    oldSrc = loadSilently(srcPath),
+	    srcDelta = getSizeDelta(newSrc, oldSrc);
+
+	console.log('\tUncompressed size: ' + newSrc.length + ' bytes (' + srcDelta + ')');
+
+	if (newSrc === oldSrc) {
+		console.log('\tNo changes');
+	} else {
+		fs.writeFileSync(srcPath, newSrc);
+		console.log('\tSaved to ' + srcPath);
+	}
+
+	console.log('Compressing...');
+
+	var path = pathPart + '.js',
+	    oldCompressed = loadSilently(path),
+	    newCompressed = copy + UglifyJS.minify(newSrc, {
+	        warnings: true,
+	        fromString: true
+	    }).code,
+	    delta = getSizeDelta(newCompressed, oldCompressed);
+
+	console.log('\tCompressed size: ' + newCompressed.length + ' bytes (' + delta + ')');
+
+	if (newCompressed === oldCompressed) {
+		console.log('\tNo changes');
+	} else {
+		fs.writeFileSync(path, newCompressed);
+		console.log('\tSaved to ' + path);
+	}
+};
+
+exports.test = function() {
+	var karma = require('karma'),
+	    testConfig = {configFile : __dirname + '/../spec/karma.conf.js'};
+
+	testConfig.browsers = ['PhantomJS'];
+
+	if (isArgv('--chrome')) {
+		testConfig.browsers.push('Chrome');
+	}
+	if (isArgv('--safari')) {
+		testConfig.browsers.push('Safari');
+	}
+	if (isArgv('--ff')) {
+		testConfig.browsers.push('Firefox');
+	}
+	if (isArgv('--ie')) {
+		testConfig.browsers.push('IE');
+	}
+
+	if (isArgv('--cov')) {
+		testConfig.preprocessors = {
+			'../src/**/*.js': 'coverage'
+		};
+		testConfig.coverageReporter = {
+			type : 'html',
+			dir : 'coverage/'
+		};
+		testConfig.reporters = ['coverage'];
+	}
+
+	karma.server.start(testConfig);
+
+	function isArgv(optName) {
+		return process.argv.indexOf(optName) !== -1;
+	}
+};

data/lib/leaflet/build/deps.js

@@ -0,0 +1,256 @@
+var deps = {
+	Core: {
+		src: ['Leaflet.js',
+		      'core/Util.js',
+		      'core/Class.js',
+		      'core/Events.js',
+		      'core/Browser.js',
+		      'geometry/Point.js',
+		      'geometry/Bounds.js',
+		      'geometry/Transformation.js',
+		      'dom/DomUtil.js',
+		      'geo/LatLng.js',
+		      'geo/LatLngBounds.js',
+		      'geo/projection/Projection.js',
+		      'geo/projection/Projection.SphericalMercator.js',
+		      'geo/projection/Projection.LonLat.js',
+		      'geo/crs/CRS.js',
+		      'geo/crs/CRS.Simple.js',
+		      'geo/crs/CRS.EPSG3857.js',
+		      'geo/crs/CRS.EPSG4326.js',
+		      'map/Map.js'],
+		desc: 'The core of the library, including OOP, events, DOM facilities, basic units, projections (EPSG:3857 and EPSG:4326) and the base Map class.'
+	},
+
+	EPSG3395: {
+		src: ['geo/projection/Projection.Mercator.js',
+		      'geo/crs/CRS.EPSG3395.js'],
+		desc: 'EPSG:3395 projection (used by some map providers).',
+		heading: 'Additional projections'
+	},
+
+	TileLayer: {
+		src: ['layer/tile/TileLayer.js'],
+		desc: 'The base class for displaying tile layers on the map.',
+		heading: 'Layers'
+	},
+
+	TileLayerWMS: {
+		src: ['layer/tile/TileLayer.WMS.js'],
+		desc: 'WMS tile layer.',
+		deps: ['TileLayer']
+	},
+
+	TileLayerCanvas: {
+		src: ['layer/tile/TileLayer.Canvas.js'],
+		desc: 'Tile layer made from canvases (for custom drawing purposes).',
+		deps: ['TileLayer']
+	},
+
+	ImageOverlay: {
+		src: ['layer/ImageOverlay.js'],
+		desc: 'Used to display an image over a particular rectangular area of the map.'
+	},
+
+	Marker: {
+		src: ['layer/marker/Icon.js',
+		      'layer/marker/Icon.Default.js',
+		      'layer/marker/Marker.js'],
+		desc: 'Markers to put on the map.'
+	},
+
+	DivIcon: {
+		src: ['layer/marker/DivIcon.js'],
+		deps: ['Marker'],
+		desc: 'Lightweight div-based icon for markers.'
+	},
+
+	Popup: {
+		src: ['layer/Popup.js',
+		      'layer/marker/Marker.Popup.js'],
+		deps: ['Marker'],
+		desc: 'Used to display the map popup (used mostly for binding HTML data to markers and paths on click).'
+	},
+
+	LayerGroup: {
+		src: ['layer/LayerGroup.js'],
+		desc: 'Allows grouping several layers to handle them as one.'
+	},
+
+	FeatureGroup: {
+		src: ['layer/FeatureGroup.js'],
+		deps: ['LayerGroup', 'Popup'],
+		desc: 'Extends LayerGroup with mouse events and bindPopup method shared between layers.'
+	},
+
+	Path: {
+		src: ['layer/vector/Path.js',
+		      'layer/vector/Path.SVG.js',
+		      'layer/vector/Path.Popup.js'],
+		desc: 'Vector rendering core (SVG-powered), enables overlaying the map with SVG paths.',
+		heading: 'Vector layers'
+	},
+
+	PathVML: {
+		src: ['layer/vector/Path.VML.js'],
+		desc: 'VML fallback for vector rendering core (IE 6-8).'
+	},
+
+	PathCanvas: {
+		src: ['layer/vector/canvas/Path.Canvas.js'],
+		deps: ['Path', 'Polyline', 'Polygon', 'Circle'],
+		desc: 'Canvas fallback for vector rendering core (makes it work on Android 2+).'
+	},
+
+	Polyline: {
+		src: ['geometry/LineUtil.js',
+		      'layer/vector/Polyline.js'],
+		deps: ['Path'],
+		desc: 'Polyline overlays.'
+	},
+
+	Polygon: {
+		src: ['geometry/PolyUtil.js',
+		      'layer/vector/Polygon.js'],
+		deps: ['Polyline'],
+		desc: 'Polygon overlays.'
+	},
+
+	MultiPoly: {
+		src: ['layer/vector/MultiPoly.js'],
+		deps: ['FeatureGroup', 'Polyline', 'Polygon'],
+		desc: 'MultiPolygon and MultyPolyline layers.'
+	},
+
+	Rectangle: {
+		src: ['layer/vector/Rectangle.js'],
+		deps: ['Polygon'],
+		desc: ['Rectangle overlays.']
+	},
+
+	Circle: {
+		src: ['layer/vector/Circle.js'],
+		deps: ['Path'],
+		desc: 'Circle overlays (with radius in meters).'
+	},
+
+	CircleMarker: {
+		src: ['layer/vector/CircleMarker.js'],
+		deps: ['Circle'],
+		desc: 'Circle overlays with a constant pixel radius.'
+	},
+
+	VectorsCanvas: {
+		src: ['layer/vector/canvas/Polyline.Canvas.js',
+		      'layer/vector/canvas/Polygon.Canvas.js',
+		      'layer/vector/canvas/Circle.Canvas.js'],
+		deps: ['PathCanvas', 'Polyline', 'Polygon', 'Circle'],
+		desc: 'Canvas fallback for vector layers (polygons, polylines, circles)'
+	},
+
+	GeoJSON: {
+		src: ['layer/GeoJSON.js'],
+		deps: ['Marker', 'MultiPoly', 'FeatureGroup'],
+		desc: 'GeoJSON layer, parses the data and adds corresponding layers above.'
+	},
+
+
+	MapDrag: {
+		src: ['dom/DomEvent.js',
+		      'dom/Draggable.js',
+		      'core/Handler.js',
+		      'map/handler/Map.Drag.js'],
+		desc: 'Makes the map draggable (by mouse or touch).',
+		heading: 'Interaction'
+	},
+
+	MouseZoom: {
+		src: ['dom/DomEvent.js',
+		      'core/Handler.js',
+		      'map/handler/Map.DoubleClickZoom.js',
+		      'map/handler/Map.ScrollWheelZoom.js'],
+		desc: 'Scroll wheel zoom and double click zoom on the map.'
+	},
+
+	TouchZoom: {
+		src: ['dom/DomEvent.js',
+		      'dom/DomEvent.DoubleTap.js',
+		      'dom/DomEvent.MsTouch.js',
+		      'core/Handler.js',
+		      'map/handler/Map.TouchZoom.js'],
+		deps: ['AnimationZoom'],
+		desc: 'Enables smooth touch zooming on iOS and IE10 and double tap on iOS/IE10/Android.'
+	},
+
+	BoxZoom: {
+		src: ['map/handler/Map.BoxZoom.js'],
+		desc: 'Enables zooming to bounding box by shift-dragging the map.'
+	},
+
+	Keyboard: {
+		src: ['map/handler/Map.Keyboard.js'],
+		desc: 'Enables keyboard pan/zoom when the map is focused.'
+	},
+
+	MarkerDrag: {
+		src: ['layer/marker/Marker.Drag.js'],
+		deps: ['Marker'],
+		desc: 'Makes markers draggable (by mouse or touch).'
+	},
+
+	ControlZoom: {
+		src: ['control/Control.js',
+		      'control/Control.Zoom.js'],
+		heading: 'Controls',
+		desc: 'Basic zoom control with two buttons (zoom in / zoom out).'
+	},
+
+	ControlAttrib: {
+		src: ['control/Control.js',
+		      'control/Control.Attribution.js'],
+		desc: 'Attribution control.'
+	},
+
+	ControlScale: {
+		src: ['control/Control.js',
+		      'control/Control.Scale.js'],
+		desc: 'Scale control.'
+	},
+
+	ControlLayers: {
+		src: ['control/Control.js',
+		      'control/Control.Layers.js'],
+		desc: 'Layer Switcher control.'
+	},
+
+	AnimationPan: {
+		src: [
+			'dom/DomEvent.js',
+			'dom/PosAnimation.js',
+			'map/anim/Map.PanAnimation.js'
+			],
+		desc: 'Core panning animation support.'
+	},
+
+	AnimationTimer: {
+		src: ['dom/PosAnimation.Timer.js'],
+		deps: ['AnimationPan'],
+		desc: 'Timer-based pan animation fallback for browsers that don\'t support CSS3 transitions.'
+	},
+
+	AnimationZoom: {
+		src: ['map/anim/Map.ZoomAnimation.js', 'layer/tile/TileLayer.Anim.js'],
+		deps: ['AnimationPan'],
+		desc: 'Smooth zooming animation. Works only on browsers that support CSS3 Transitions.'
+	},
+
+	Geolocation: {
+		src: ['map/ext/Map.Geolocation.js'],
+		desc: 'Adds Map#locate method and related events to make geolocation easier.',
+		heading: 'Misc'
+	}
+};
+
+if (typeof exports !== 'undefined') {
+	exports.deps = deps;
+}

data/lib/leaflet/build/hintrc.js

@@ -0,0 +1,37 @@
+exports.config = {
+
+	// environment
+	"browser": true,
+	"node": true,
+	"predef": ['define'],
+	"strict": false,
+
+	// code style
+	"bitwise": true,
+	"camelcase": true,
+	"curly": true,
+	"eqeqeq": true,
+	"forin": false,
+	"immed": true,
+	"latedef": true,
+	"newcap": true,
+	"noarg": true,
+	"noempty": true,
+	"nonew": true,
+	"undef": true,
+	"unused": true,
+	"quotmark": "single",
+
+	// whitespace
+	"indent": 4,
+	"trailing": true,
+	"white": true,
+	"smarttabs": true,
+	"maxlen": 120
+
+	// code simplicity - not enforced but nice to check from time to time
+	// "maxstatements": 20,
+	// "maxcomplexity": 5
+	// "maxparams": 4,
+	// "maxdepth": 4
+};