' +
12 | error.message + '
= 1000) {
38 | data = {
39 | value: round(d / 1609.344, sensitivity),
40 | unit: un.miles
41 | };
42 | } else {
43 | data = {
44 | value: round(yards, sensitivity),
45 | unit: un.yards
46 | };
47 | }
48 | } else {
49 | v = round(d, sensitivity);
50 | data = {
51 | value: v >= 1000 ? (v / 1000) : v,
52 | unit: v >= 1000 ? un.kilometers : un.meters
53 | };
54 | }
55 |
56 | if (simpleRounding) {
57 | data.value = data.value.toFixed(-sensitivity);
58 | }
59 |
60 | return L.Util.template(this.options.distanceTemplate, data);
61 | },
62 |
63 | _round: function(d, sensitivity) {
64 | var s = sensitivity || this.options.roundingSensitivity,
65 | pow10 = Math.pow(10, (Math.floor(d / s) + '').length - 1),
66 | r = Math.floor(d / pow10),
67 | p = (r > 5) ? pow10 : pow10 / 2;
68 |
69 | return Math.round(d / p) * p;
70 | },
71 |
72 | formatTime: function(t /* Number (seconds) */) {
73 | var un = this.options.unitNames || this._localization.localize('units');
74 | // More than 30 seconds precision looks ridiculous
75 | t = Math.round(t / 30) * 30;
76 |
77 | if (t > 86400) {
78 | return Math.round(t / 3600) + ' ' + un.hours;
79 | } else if (t > 3600) {
80 | return Math.floor(t / 3600) + ' ' + un.hours + ' ' +
81 | Math.round((t % 3600) / 60) + ' ' + un.minutes;
82 | } else if (t > 300) {
83 | return Math.round(t / 60) + ' ' + un.minutes;
84 | } else if (t > 60) {
85 | return Math.floor(t / 60) + ' ' + un.minutes +
86 | (t % 60 !== 0 ? ' ' + (t % 60) + ' ' + un.seconds : '');
87 | } else {
88 | return t + ' ' + un.seconds;
89 | }
90 | },
91 |
92 | formatInstruction: function(instr, i) {
93 | if (instr.text === undefined) {
94 | return this.capitalize(L.Util.template(this._getInstructionTemplate(instr, i),
95 | L.extend({}, instr, {
96 | exitStr: instr.exit ? this._localization.localize('formatOrder')(instr.exit) : '',
97 | dir: this._localization.localize(['directions', instr.direction]),
98 | modifier: this._localization.localize(['directions', instr.modifier])
99 | })));
100 | } else {
101 | return instr.text;
102 | }
103 | },
104 |
105 | getIconName: function(instr, i) {
106 | switch (instr.type) {
107 | case 'Head':
108 | if (i === 0) {
109 | return 'depart';
110 | }
111 | break;
112 | case 'WaypointReached':
113 | return 'via';
114 | case 'Roundabout':
115 | return 'enter-roundabout';
116 | case 'DestinationReached':
117 | return 'arrive';
118 | }
119 |
120 | switch (instr.modifier) {
121 | case 'Straight':
122 | return 'continue';
123 | case 'SlightRight':
124 | return 'bear-right';
125 | case 'Right':
126 | return 'turn-right';
127 | case 'SharpRight':
128 | return 'sharp-right';
129 | case 'TurnAround':
130 | case 'Uturn':
131 | return 'u-turn';
132 | case 'SharpLeft':
133 | return 'sharp-left';
134 | case 'Left':
135 | return 'turn-left';
136 | case 'SlightLeft':
137 | return 'bear-left';
138 | }
139 | },
140 |
141 | capitalize: function(s) {
142 | return s.charAt(0).toUpperCase() + s.substring(1);
143 | },
144 |
145 | _getInstructionTemplate: function(instr, i) {
146 | var type = instr.type === 'Straight' ? (i === 0 ? 'Head' : 'Continue') : instr.type,
147 | strings = this._localization.localize(['instructions', type]);
148 |
149 | if (!strings) {
150 | strings = [
151 | this._localization.localize(['directions', type]),
152 | ' ' + this._localization.localize(['instructions', 'Onto'])
153 | ];
154 | }
155 |
156 | return strings[0] + (strings.length > 1 && instr.road ? strings[1] : '');
157 | }
158 | });
159 | })();
160 |
--------------------------------------------------------------------------------
/src/geocoder-element.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 | var Autocomplete = require('./autocomplete');
6 | var Localization = require('./localization');
7 |
8 | function selectInputText(input) {
9 | if (input.setSelectionRange) {
10 | // On iOS, select() doesn't work
11 | input.setSelectionRange(0, 9999);
12 | } else {
13 | // On at least IE8, setSeleectionRange doesn't exist
14 | input.select();
15 | }
16 | }
17 |
18 | module.exports = L.Class.extend({
19 | includes: ((typeof L.Evented !== 'undefined' && L.Evented.prototype) || L.Mixin.Events),
20 |
21 | options: {
22 | createGeocoder: function(i, nWps, options) {
23 | var container = L.DomUtil.create('div', 'leaflet-routing-geocoder'),
24 | input = L.DomUtil.create('input', '', container),
25 | remove = options.addWaypoints ? L.DomUtil.create('span', 'leaflet-routing-remove-waypoint', container) : undefined;
26 |
27 | input.disabled = !options.addWaypoints;
28 |
29 | return {
30 | container: container,
31 | input: input,
32 | closeButton: remove
33 | };
34 | },
35 | geocoderPlaceholder: function(i, numberWaypoints, geocoderElement) {
36 | var l = new Localization(geocoderElement.options.language).localize('ui');
37 | return i === 0 ?
38 | l.startPlaceholder :
39 | (i < numberWaypoints - 1 ?
40 | L.Util.template(l.viaPlaceholder, {viaNumber: i}) :
41 | l.endPlaceholder);
42 | },
43 |
44 | geocoderClass: function() {
45 | return '';
46 | },
47 |
48 | waypointNameFallback: function(latLng) {
49 | var ns = latLng.lat < 0 ? 'S' : 'N',
50 | ew = latLng.lng < 0 ? 'W' : 'E',
51 | lat = (Math.round(Math.abs(latLng.lat) * 10000) / 10000).toString(),
52 | lng = (Math.round(Math.abs(latLng.lng) * 10000) / 10000).toString();
53 | return ns + lat + ', ' + ew + lng;
54 | },
55 | maxGeocoderTolerance: 200,
56 | autocompleteOptions: {},
57 | language: 'en',
58 | },
59 |
60 | initialize: function(wp, i, nWps, options) {
61 | L.setOptions(this, options);
62 |
63 | var g = this.options.createGeocoder(i, nWps, this.options),
64 | closeButton = g.closeButton,
65 | geocoderInput = g.input;
66 | geocoderInput.setAttribute('placeholder', this.options.geocoderPlaceholder(i, nWps, this));
67 | geocoderInput.className = this.options.geocoderClass(i, nWps);
68 |
69 | this._element = g;
70 | this._waypoint = wp;
71 |
72 | this.update();
73 | // This has to be here, or geocoder's value will not be properly
74 | // initialized.
75 | // TODO: look into why and make _updateWaypointName fix this.
76 | geocoderInput.value = wp.name;
77 |
78 | L.DomEvent.addListener(geocoderInput, 'click', function() {
79 | selectInputText(this);
80 | }, geocoderInput);
81 |
82 | if (closeButton) {
83 | L.DomEvent.addListener(closeButton, 'click', function() {
84 | this.fire('delete', { waypoint: this._waypoint });
85 | }, this);
86 | }
87 |
88 | if (typeof this.options.formatGeocoderResult == 'function') {
89 | this.options.autocompleteOptions.formatGeocoderResult = this.options.formatGeocoderResult;
90 | }
91 |
92 | new Autocomplete(geocoderInput, function(r) {
93 | geocoderInput.value = r.name;
94 | wp.name = r.name;
95 | wp.latLng = r.center;
96 | this.fire('geocoded', { waypoint: wp, value: r });
97 | }, this, L.extend({
98 | resultFn: this.options.geocoder.geocode,
99 | resultContext: this.options.geocoder,
100 | autocompleteFn: this.options.geocoder.suggest,
101 | autocompleteContext: this.options.geocoder
102 | }, this.options.autocompleteOptions));
103 | },
104 |
105 | getContainer: function() {
106 | return this._element.container;
107 | },
108 |
109 | setValue: function(v) {
110 | this._element.input.value = v;
111 | },
112 |
113 | update: function(force) {
114 | var wp = this._waypoint,
115 | wpCoords;
116 |
117 | wp.name = wp.name || '';
118 |
119 | if (wp.latLng && (force || !wp.name)) {
120 | wpCoords = this.options.waypointNameFallback(wp.latLng);
121 | if (this.options.geocoder && this.options.geocoder.reverse) {
122 | this.options.geocoder.reverse(wp.latLng, 67108864 /* zoom 18 */, function(rs) {
123 | if (rs.length > 0 && rs[0].center.distanceTo(wp.latLng) < this.options.maxGeocoderTolerance) {
124 | wp.name = rs[0].name;
125 | } else {
126 | wp.name = wpCoords;
127 | }
128 | this._update();
129 | }, this);
130 | } else {
131 | wp.name = wpCoords;
132 | this._update();
133 | }
134 | }
135 | },
136 |
137 | focus: function() {
138 | var input = this._element.input;
139 | input.focus();
140 | selectInputText(input);
141 | },
142 |
143 | _update: function() {
144 | var wp = this._waypoint,
145 | value = wp && wp.name ? wp.name : '';
146 | this.setValue(value);
147 | this.fire('reversegeocoded', {waypoint: wp, value: value});
148 | }
149 | });
150 | })();
151 |
--------------------------------------------------------------------------------
/src/index.js:
--------------------------------------------------------------------------------
1 | var L = require('leaflet'),
2 | Control = require('./control'),
3 | Itinerary = require('./itinerary'),
4 | Line = require('./line'),
5 | OSRMv1 = require('./osrm-v1'),
6 | Plan = require('./plan'),
7 | Waypoint = require('./waypoint'),
8 | Autocomplete = require('./autocomplete'),
9 | Formatter = require('./formatter'),
10 | GeocoderElement = require('./geocoder-element'),
11 | Localization = require('./localization'),
12 | ItineraryBuilder = require('./itinerary-builder'),
13 | Mapbox = require('./mapbox'),
14 | ErrorControl = require('./error-control');
15 |
16 | L.routing = {
17 | control: function(options) { return new Control(options); },
18 | itinerary: function(options) {
19 | return Itinerary(options);
20 | },
21 | line: function(route, options) {
22 | return new Line(route, options);
23 | },
24 | plan: function(waypoints, options) {
25 | return new Plan(waypoints, options);
26 | },
27 | waypoint: function(latLng, name, options) {
28 | return new Waypoint(latLng, name, options);
29 | },
30 | osrmv1: function(options) {
31 | return new OSRMv1(options);
32 | },
33 | localization: function(options) {
34 | return new Localization(options);
35 | },
36 | formatter: function(options) {
37 | return new Formatter(options);
38 | },
39 | geocoderElement: function(wp, i, nWps, plan) {
40 | return new L.Routing.GeocoderElement(wp, i, nWps, plan);
41 | },
42 | itineraryBuilder: function(options) {
43 | return new ItineraryBuilder(options);
44 | },
45 | mapbox: function(accessToken, options) {
46 | return new Mapbox(accessToken, options);
47 | },
48 | errorControl: function(routingControl, options) {
49 | return new ErrorControl(routingControl, options);
50 | },
51 | autocomplete: function(elem, callback, context, options) {
52 | return new Autocomplete(elem, callback, context, options);
53 | }
54 | };
55 |
56 | module.exports = L.Routing = {
57 | Control: Control,
58 | Itinerary: Itinerary,
59 | Line: Line,
60 | OSRMv1: OSRMv1,
61 | Plan: Plan,
62 | Waypoint: Waypoint,
63 | Autocomplete: Autocomplete,
64 | Formatter: Formatter,
65 | GeocoderElement: GeocoderElement,
66 | Localization: Localization,
67 | ItineraryBuilder: ItineraryBuilder,
68 |
69 | // Legacy; remove these in next major release
70 | control: L.routing.control,
71 | itinerary: L.routing.itinerary,
72 | line: L.routing.line,
73 | plan: L.routing.plan,
74 | waypoint: L.routing.waypoint,
75 | osrmv1: L.routing.osrmv1,
76 | geocoderElement: L.routing.geocoderElement,
77 | mapbox: L.routing.mapbox,
78 | errorControl: L.routing.errorControl,
79 | };
80 |
--------------------------------------------------------------------------------
/src/itinerary-builder.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 |
6 | module.exports = L.Class.extend({
7 | options: {
8 | containerClassName: ''
9 | },
10 |
11 | initialize: function(options) {
12 | L.setOptions(this, options);
13 | },
14 |
15 | createContainer: function(className) {
16 | var table = L.DomUtil.create('table', (className || '') + ' ' + this.options.containerClassName),
17 | colgroup = L.DomUtil.create('colgroup', '', table);
18 |
19 | L.DomUtil.create('col', 'leaflet-routing-instruction-icon', colgroup);
20 | L.DomUtil.create('col', 'leaflet-routing-instruction-text', colgroup);
21 | L.DomUtil.create('col', 'leaflet-routing-instruction-distance', colgroup);
22 |
23 | return table;
24 | },
25 |
26 | createStepsContainer: function() {
27 | return L.DomUtil.create('tbody', '');
28 | },
29 |
30 | createStep: function(text, distance, icon, steps) {
31 | var row = L.DomUtil.create('tr', '', steps),
32 | span,
33 | td;
34 | td = L.DomUtil.create('td', '', row);
35 | span = L.DomUtil.create('span', 'leaflet-routing-icon leaflet-routing-icon-'+icon, td);
36 | td.appendChild(span);
37 | td = L.DomUtil.create('td', '', row);
38 | td.appendChild(document.createTextNode(text));
39 | td = L.DomUtil.create('td', '', row);
40 | td.appendChild(document.createTextNode(distance));
41 | return row;
42 | }
43 | });
44 | })();
45 |
--------------------------------------------------------------------------------
/src/itinerary.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 | var Formatter = require('./formatter');
6 | var ItineraryBuilder = require('./itinerary-builder');
7 |
8 | module.exports = L.Control.extend({
9 | includes: ((typeof L.Evented !== 'undefined' && L.Evented.prototype) || L.Mixin.Events),
10 |
11 | options: {
12 | pointMarkerStyle: {
13 | radius: 5,
14 | color: '#03f',
15 | fillColor: 'white',
16 | opacity: 1,
17 | fillOpacity: 0.7
18 | },
19 | summaryTemplate: '{name}
{distance}, {time}
',
20 | timeTemplate: '{time}',
21 | containerClassName: '',
22 | alternativeClassName: '',
23 | minimizedClassName: '',
24 | itineraryClassName: '',
25 | totalDistanceRoundingSensitivity: -1,
26 | show: true,
27 | collapsible: undefined,
28 | collapseBtn: function(itinerary) {
29 | var collapseBtn = L.DomUtil.create('span', itinerary.options.collapseBtnClass);
30 | L.DomEvent.on(collapseBtn, 'click', itinerary._toggle, itinerary);
31 | itinerary._container.insertBefore(collapseBtn, itinerary._container.firstChild);
32 | },
33 | collapseBtnClass: 'leaflet-routing-collapse-btn'
34 | },
35 |
36 | initialize: function(options) {
37 | L.setOptions(this, options);
38 | this._formatter = this.options.formatter || new Formatter(this.options);
39 | this._itineraryBuilder = this.options.itineraryBuilder || new ItineraryBuilder({
40 | containerClassName: this.options.itineraryClassName
41 | });
42 | },
43 |
44 | onAdd: function(map) {
45 | var collapsible = this.options.collapsible;
46 |
47 | collapsible = collapsible || (collapsible === undefined && map.getSize().x <= 640);
48 |
49 | this._container = L.DomUtil.create('div', 'leaflet-routing-container leaflet-bar ' +
50 | (!this.options.show ? 'leaflet-routing-container-hide ' : '') +
51 | (collapsible ? 'leaflet-routing-collapsible ' : '') +
52 | this.options.containerClassName);
53 | this._altContainer = this.createAlternativesContainer();
54 | this._container.appendChild(this._altContainer);
55 | L.DomEvent.disableClickPropagation(this._container);
56 | L.DomEvent.addListener(this._container, 'mousewheel', function(e) {
57 | L.DomEvent.stopPropagation(e);
58 | });
59 |
60 | if (collapsible) {
61 | this.options.collapseBtn(this);
62 | }
63 |
64 | return this._container;
65 | },
66 |
67 | onRemove: function() {
68 | },
69 |
70 | createAlternativesContainer: function() {
71 | return L.DomUtil.create('div', 'leaflet-routing-alternatives-container');
72 | },
73 |
74 | setAlternatives: function(routes) {
75 | var i,
76 | alt,
77 | altDiv;
78 |
79 | this._clearAlts();
80 |
81 | this._routes = routes;
82 |
83 | for (i = 0; i < this._routes.length; i++) {
84 | alt = this._routes[i];
85 | altDiv = this._createAlternative(alt, i);
86 | this._altContainer.appendChild(altDiv);
87 | this._altElements.push(altDiv);
88 | }
89 |
90 | this._selectRoute({route: this._routes[0], alternatives: this._routes.slice(1)});
91 |
92 | return this;
93 | },
94 |
95 | show: function() {
96 | L.DomUtil.removeClass(this._container, 'leaflet-routing-container-hide');
97 | },
98 |
99 | hide: function() {
100 | L.DomUtil.addClass(this._container, 'leaflet-routing-container-hide');
101 | },
102 |
103 | _toggle: function() {
104 | var collapsed = L.DomUtil.hasClass(this._container, 'leaflet-routing-container-hide');
105 | this[collapsed ? 'show' : 'hide']();
106 | },
107 |
108 | _createAlternative: function(alt, i) {
109 | var altDiv = L.DomUtil.create('div', 'leaflet-routing-alt ' +
110 | this.options.alternativeClassName +
111 | (i > 0 ? ' leaflet-routing-alt-minimized ' + this.options.minimizedClassName : '')),
112 | template = this.options.summaryTemplate,
113 | data = L.extend({
114 | name: alt.name,
115 | distance: this._formatter.formatDistance(alt.summary.totalDistance, this.options.totalDistanceRoundingSensitivity),
116 | time: this._formatter.formatTime(alt.summary.totalTime)
117 | }, alt);
118 | altDiv.innerHTML = typeof(template) === 'function' ? template(data) : L.Util.template(template, data);
119 | L.DomEvent.addListener(altDiv, 'click', this._onAltClicked, this);
120 | this.on('routeselected', this._selectAlt, this);
121 |
122 | altDiv.appendChild(this._createItineraryContainer(alt));
123 | return altDiv;
124 | },
125 |
126 | _clearAlts: function() {
127 | var el = this._altContainer;
128 | while (el && el.firstChild) {
129 | el.removeChild(el.firstChild);
130 | }
131 |
132 | this._altElements = [];
133 | },
134 |
135 | _createItineraryContainer: function(r) {
136 | var container = this._itineraryBuilder.createContainer(),
137 | steps = this._itineraryBuilder.createStepsContainer(),
138 | i,
139 | instr,
140 | step,
141 | distance,
142 | text,
143 | icon;
144 |
145 | container.appendChild(steps);
146 |
147 | for (i = 0; i < r.instructions.length; i++) {
148 | instr = r.instructions[i];
149 | text = this._formatter.formatInstruction(instr, i);
150 | distance = this._formatter.formatDistance(instr.distance);
151 | icon = this._formatter.getIconName(instr, i);
152 | step = this._itineraryBuilder.createStep(text, distance, icon, steps);
153 |
154 | if(instr.index) {
155 | this._addRowListeners(step, r.coordinates[instr.index]);
156 | }
157 | }
158 |
159 | return container;
160 | },
161 |
162 | _addRowListeners: function(row, coordinate) {
163 | L.DomEvent.addListener(row, 'mouseover', function() {
164 | this._marker = L.circleMarker(coordinate,
165 | this.options.pointMarkerStyle).addTo(this._map);
166 | }, this);
167 | L.DomEvent.addListener(row, 'mouseout', function() {
168 | if (this._marker) {
169 | this._map.removeLayer(this._marker);
170 | delete this._marker;
171 | }
172 | }, this);
173 | L.DomEvent.addListener(row, 'click', function(e) {
174 | this._map.panTo(coordinate);
175 | L.DomEvent.stopPropagation(e);
176 | }, this);
177 | },
178 |
179 | _onAltClicked: function(e) {
180 | var altElem = e.target || window.event.srcElement;
181 | while (!L.DomUtil.hasClass(altElem, 'leaflet-routing-alt')) {
182 | altElem = altElem.parentElement;
183 | }
184 |
185 | var j = this._altElements.indexOf(altElem);
186 | var alts = this._routes.slice();
187 | var route = alts.splice(j, 1)[0];
188 |
189 | this.fire('routeselected', {
190 | route: route,
191 | alternatives: alts
192 | });
193 | },
194 |
195 | _selectAlt: function(e) {
196 | var altElem,
197 | j,
198 | n,
199 | classFn;
200 |
201 | altElem = this._altElements[e.route.routesIndex];
202 |
203 | if (L.DomUtil.hasClass(altElem, 'leaflet-routing-alt-minimized')) {
204 | for (j = 0; j < this._altElements.length; j++) {
205 | n = this._altElements[j];
206 | classFn = j === e.route.routesIndex ? 'removeClass' : 'addClass';
207 | L.DomUtil[classFn](n, 'leaflet-routing-alt-minimized');
208 | if (this.options.minimizedClassName) {
209 | L.DomUtil[classFn](n, this.options.minimizedClassName);
210 | }
211 |
212 | if (j !== e.route.routesIndex) n.scrollTop = 0;
213 | }
214 | }
215 |
216 | L.DomEvent.stop(e);
217 | },
218 |
219 | _selectRoute: function(routes) {
220 | if (this._marker) {
221 | this._map.removeLayer(this._marker);
222 | delete this._marker;
223 | }
224 | this.fire('routeselected', routes);
225 | }
226 | });
227 | })();
228 |
--------------------------------------------------------------------------------
/src/line.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 |
6 | module.exports = L.LayerGroup.extend({
7 | includes: ((typeof L.Evented !== 'undefined' && L.Evented.prototype) || L.Mixin.Events),
8 |
9 | options: {
10 | styles: [
11 | {color: 'black', opacity: 0.15, weight: 9},
12 | {color: 'white', opacity: 0.8, weight: 6},
13 | {color: 'red', opacity: 1, weight: 2}
14 | ],
15 | missingRouteStyles: [
16 | {color: 'black', opacity: 0.15, weight: 7},
17 | {color: 'white', opacity: 0.6, weight: 4},
18 | {color: 'gray', opacity: 0.8, weight: 2, dashArray: '7,12'}
19 | ],
20 | addWaypoints: true,
21 | extendToWaypoints: true,
22 | missingRouteTolerance: 10
23 | },
24 |
25 | initialize: function(route, options) {
26 | L.setOptions(this, options);
27 | L.LayerGroup.prototype.initialize.call(this, options);
28 | this._route = route;
29 |
30 | if (this.options.extendToWaypoints) {
31 | this._extendToWaypoints();
32 | }
33 |
34 | this._addSegment(
35 | route.coordinates,
36 | this.options.styles,
37 | this.options.addWaypoints);
38 | },
39 |
40 | getBounds: function() {
41 | return L.latLngBounds(this._route.coordinates);
42 | },
43 |
44 | _findWaypointIndices: function() {
45 | var wps = this._route.inputWaypoints,
46 | indices = [],
47 | i;
48 | for (i = 0; i < wps.length; i++) {
49 | indices.push(this._findClosestRoutePoint(wps[i].latLng));
50 | }
51 |
52 | return indices;
53 | },
54 |
55 | _findClosestRoutePoint: function(latlng) {
56 | var minDist = Number.MAX_VALUE,
57 | minIndex,
58 | i,
59 | d;
60 |
61 | for (i = this._route.coordinates.length - 1; i >= 0 ; i--) {
62 | // TODO: maybe do this in pixel space instead?
63 | d = latlng.distanceTo(this._route.coordinates[i]);
64 | if (d < minDist) {
65 | minIndex = i;
66 | minDist = d;
67 | }
68 | }
69 |
70 | return minIndex;
71 | },
72 |
73 | _extendToWaypoints: function() {
74 | var wps = this._route.inputWaypoints,
75 | wpIndices = this._getWaypointIndices(),
76 | i,
77 | wpLatLng,
78 | routeCoord;
79 |
80 | for (i = 0; i < wps.length; i++) {
81 | wpLatLng = wps[i].latLng;
82 | routeCoord = L.latLng(this._route.coordinates[wpIndices[i]]);
83 | if (wpLatLng.distanceTo(routeCoord) >
84 | this.options.missingRouteTolerance) {
85 | this._addSegment([wpLatLng, routeCoord],
86 | this.options.missingRouteStyles);
87 | }
88 | }
89 | },
90 |
91 | _addSegment: function(coords, styles, mouselistener) {
92 | var i,
93 | pl;
94 |
95 | for (i = 0; i < styles.length; i++) {
96 | pl = L.polyline(coords, styles[i]);
97 | this.addLayer(pl);
98 | if (mouselistener) {
99 | pl.on('mousedown', this._onLineTouched, this);
100 | }
101 | }
102 | },
103 |
104 | _findNearestWpBefore: function(i) {
105 | var wpIndices = this._getWaypointIndices(),
106 | j = wpIndices.length - 1;
107 | while (j >= 0 && wpIndices[j] > i) {
108 | j--;
109 | }
110 |
111 | return j;
112 | },
113 |
114 | _onLineTouched: function(e) {
115 | var afterIndex = this._findNearestWpBefore(this._findClosestRoutePoint(e.latlng));
116 | this.fire('linetouched', {
117 | afterIndex: afterIndex,
118 | latlng: e.latlng
119 | });
120 | L.DomEvent.stop(e);
121 | },
122 |
123 | _getWaypointIndices: function() {
124 | if (!this._wpIndices) {
125 | this._wpIndices = this._route.waypointIndices || this._findWaypointIndices();
126 | }
127 |
128 | return this._wpIndices;
129 | }
130 | });
131 | })();
132 |
--------------------------------------------------------------------------------
/src/localization.js:
--------------------------------------------------------------------------------
1 | /*
2 | NOTICE
3 | Since version 3.2.5, the functionality in this file is by
4 | default NOT used for localizing OSRM instructions.
5 | Instead, we rely on the module osrm-text-instructions (https://github.com/Project-OSRM/osrm-text-instructions/).
6 |
7 | This file can still be used for other routing backends, or if you specify the
8 | stepToText option in the OSRMv1 class.
9 | */
10 |
11 | (function() {
12 | 'use strict';
13 |
14 | var spanish = {
15 | directions: {
16 | N: 'norte',
17 | NE: 'noreste',
18 | E: 'este',
19 | SE: 'sureste',
20 | S: 'sur',
21 | SW: 'suroeste',
22 | W: 'oeste',
23 | NW: 'noroeste',
24 | SlightRight: 'leve giro a la derecha',
25 | Right: 'derecha',
26 | SharpRight: 'giro pronunciado a la derecha',
27 | SlightLeft: 'leve giro a la izquierda',
28 | Left: 'izquierda',
29 | SharpLeft: 'giro pronunciado a la izquierda',
30 | Uturn: 'media vuelta'
31 | },
32 | instructions: {
33 | // instruction, postfix if the road is named
34 | 'Head':
35 | ['Derecho {dir}', ' sobre {road}'],
36 | 'Continue':
37 | ['Continuar {dir}', ' en {road}'],
38 | 'TurnAround':
39 | ['Dar vuelta'],
40 | 'WaypointReached':
41 | ['Llegó a un punto del camino'],
42 | 'Roundabout':
43 | ['Tomar {exitStr} salida en la rotonda', ' en {road}'],
44 | 'DestinationReached':
45 | ['Llegada a destino'],
46 | 'Fork': ['En el cruce gira a {modifier}', ' hacia {road}'],
47 | 'Merge': ['Incorpórate {modifier}', ' hacia {road}'],
48 | 'OnRamp': ['Gira {modifier} en la salida', ' hacia {road}'],
49 | 'OffRamp': ['Toma la salida {modifier}', ' hacia {road}'],
50 | 'EndOfRoad': ['Gira {modifier} al final de la carretera', ' hacia {road}'],
51 | 'Onto': 'hacia {road}'
52 | },
53 | formatOrder: function(n) {
54 | return n + 'º';
55 | },
56 | ui: {
57 | startPlaceholder: 'Inicio',
58 | viaPlaceholder: 'Via {viaNumber}',
59 | endPlaceholder: 'Destino'
60 | },
61 | units: {
62 | meters: 'm',
63 | kilometers: 'km',
64 | yards: 'yd',
65 | miles: 'mi',
66 | hours: 'h',
67 | minutes: 'min',
68 | seconds: 's'
69 | }
70 | };
71 |
72 | L.Routing = L.Routing || {};
73 |
74 | var Localization = L.Class.extend({
75 | initialize: function(langs) {
76 | this._langs = L.Util.isArray(langs) ? langs.slice() : [langs, 'en'];
77 |
78 | for (var i = 0, l = this._langs.length; i < l; i++) {
79 | var generalizedCode = /([A-Za-z]+)/.exec(this._langs[i])[1]
80 | if (!Localization[this._langs[i]]) {
81 | if (Localization[generalizedCode]) {
82 | this._langs[i] = generalizedCode;
83 | } else {
84 | throw new Error('No localization for language "' + this._langs[i] + '".');
85 | }
86 | }
87 | }
88 | },
89 |
90 | localize: function(keys) {
91 | var dict,
92 | key,
93 | value;
94 |
95 | keys = L.Util.isArray(keys) ? keys : [keys];
96 |
97 | for (var i = 0, l = this._langs.length; i < l; i++) {
98 | dict = Localization[this._langs[i]];
99 | for (var j = 0, nKeys = keys.length; dict && j < nKeys; j++) {
100 | key = keys[j];
101 | value = dict[key];
102 | dict = value;
103 | }
104 |
105 | if (value) {
106 | return value;
107 | }
108 | }
109 | }
110 | });
111 |
112 | module.exports = L.extend(Localization, {
113 | 'en': {
114 | directions: {
115 | N: 'north',
116 | NE: 'northeast',
117 | E: 'east',
118 | SE: 'southeast',
119 | S: 'south',
120 | SW: 'southwest',
121 | W: 'west',
122 | NW: 'northwest',
123 | SlightRight: 'slight right',
124 | Right: 'right',
125 | SharpRight: 'sharp right',
126 | SlightLeft: 'slight left',
127 | Left: 'left',
128 | SharpLeft: 'sharp left',
129 | Uturn: 'Turn around'
130 | },
131 | instructions: {
132 | // instruction, postfix if the road is named
133 | 'Head':
134 | ['Head {dir}', ' on {road}'],
135 | 'Continue':
136 | ['Continue {dir}'],
137 | 'TurnAround':
138 | ['Turn around'],
139 | 'WaypointReached':
140 | ['Waypoint reached'],
141 | 'Roundabout':
142 | ['Take the {exitStr} exit in the roundabout', ' onto {road}'],
143 | 'DestinationReached':
144 | ['Destination reached'],
145 | 'Fork': ['At the fork, turn {modifier}', ' onto {road}'],
146 | 'Merge': ['Merge {modifier}', ' onto {road}'],
147 | 'OnRamp': ['Turn {modifier} on the ramp', ' onto {road}'],
148 | 'OffRamp': ['Take the ramp on the {modifier}', ' onto {road}'],
149 | 'EndOfRoad': ['Turn {modifier} at the end of the road', ' onto {road}'],
150 | 'Onto': 'onto {road}'
151 | },
152 | formatOrder: function(n) {
153 | var i = n % 10 - 1,
154 | suffix = ['st', 'nd', 'rd'];
155 |
156 | return suffix[i] ? n + suffix[i] : n + 'th';
157 | },
158 | ui: {
159 | startPlaceholder: 'Start',
160 | viaPlaceholder: 'Via {viaNumber}',
161 | endPlaceholder: 'End'
162 | },
163 | units: {
164 | meters: 'm',
165 | kilometers: 'km',
166 | yards: 'yd',
167 | miles: 'mi',
168 | hours: 'h',
169 | minutes: 'min',
170 | seconds: 's'
171 | }
172 | },
173 |
174 | 'de': {
175 | directions: {
176 | N: 'Norden',
177 | NE: 'Nordosten',
178 | E: 'Osten',
179 | SE: 'Südosten',
180 | S: 'Süden',
181 | SW: 'Südwesten',
182 | W: 'Westen',
183 | NW: 'Nordwesten',
184 | SlightRight: 'leicht rechts',
185 | Right: 'rechts',
186 | SharpRight: 'scharf rechts',
187 | SlightLeft: 'leicht links',
188 | Left: 'links',
189 | SharpLeft: 'scharf links',
190 | Uturn: 'Wenden'
191 | },
192 | instructions: {
193 | // instruction, postfix if the road is named
194 | 'Head':
195 | ['Richtung {dir}', ' auf {road}'],
196 | 'Continue':
197 | ['Geradeaus Richtung {dir}', ' auf {road}'],
198 | 'SlightRight':
199 | ['Leicht rechts abbiegen', ' auf {road}'],
200 | 'Right':
201 | ['Rechts abbiegen', ' auf {road}'],
202 | 'SharpRight':
203 | ['Scharf rechts abbiegen', ' auf {road}'],
204 | 'TurnAround':
205 | ['Wenden'],
206 | 'SharpLeft':
207 | ['Scharf links abbiegen', ' auf {road}'],
208 | 'Left':
209 | ['Links abbiegen', ' auf {road}'],
210 | 'SlightLeft':
211 | ['Leicht links abbiegen', ' auf {road}'],
212 | 'WaypointReached':
213 | ['Zwischenhalt erreicht'],
214 | 'Roundabout':
215 | ['Nehmen Sie die {exitStr} Ausfahrt im Kreisverkehr', ' auf {road}'],
216 | 'DestinationReached':
217 | ['Sie haben ihr Ziel erreicht'],
218 | 'Fork': ['An der Kreuzung {modifier}', ' auf {road}'],
219 | 'Merge': ['Fahren Sie {modifier} weiter', ' auf {road}'],
220 | 'OnRamp': ['Fahren Sie {modifier} auf die Auffahrt', ' auf {road}'],
221 | 'OffRamp': ['Nehmen Sie die Ausfahrt {modifier}', ' auf {road}'],
222 | 'EndOfRoad': ['Fahren Sie {modifier} am Ende der Straße', ' auf {road}'],
223 | 'Onto': 'auf {road}'
224 | },
225 | formatOrder: function(n) {
226 | return n + '.';
227 | },
228 | ui: {
229 | startPlaceholder: 'Start',
230 | viaPlaceholder: 'Via {viaNumber}',
231 | endPlaceholder: 'Ziel'
232 | }
233 | },
234 |
235 | 'sv': {
236 | directions: {
237 | N: 'norr',
238 | NE: 'nordost',
239 | E: 'öst',
240 | SE: 'sydost',
241 | S: 'syd',
242 | SW: 'sydväst',
243 | W: 'väst',
244 | NW: 'nordväst',
245 | SlightRight: 'svagt höger',
246 | Right: 'höger',
247 | SharpRight: 'skarpt höger',
248 | SlightLeft: 'svagt vänster',
249 | Left: 'vänster',
250 | SharpLeft: 'skarpt vänster',
251 | Uturn: 'Vänd'
252 | },
253 | instructions: {
254 | // instruction, postfix if the road is named
255 | 'Head':
256 | ['Åk åt {dir}', ' till {road}'],
257 | 'Continue':
258 | ['Fortsätt {dir}'],
259 | 'SlightRight':
260 | ['Svagt höger', ' till {road}'],
261 | 'Right':
262 | ['Sväng höger', ' till {road}'],
263 | 'SharpRight':
264 | ['Skarpt höger', ' till {road}'],
265 | 'TurnAround':
266 | ['Vänd'],
267 | 'SharpLeft':
268 | ['Skarpt vänster', ' till {road}'],
269 | 'Left':
270 | ['Sväng vänster', ' till {road}'],
271 | 'SlightLeft':
272 | ['Svagt vänster', ' till {road}'],
273 | 'WaypointReached':
274 | ['Viapunkt nådd'],
275 | 'Roundabout':
276 | ['Tag {exitStr} avfarten i rondellen', ' till {road}'],
277 | 'DestinationReached':
278 | ['Framme vid resans mål'],
279 | 'Fork': ['Tag av {modifier}', ' till {road}'],
280 | 'Merge': ['Anslut {modifier} ', ' till {road}'],
281 | 'OnRamp': ['Tag påfarten {modifier}', ' till {road}'],
282 | 'OffRamp': ['Tag avfarten {modifier}', ' till {road}'],
283 | 'EndOfRoad': ['Sväng {modifier} vid vägens slut', ' till {road}'],
284 | 'Onto': 'till {road}'
285 | },
286 | formatOrder: function(n) {
287 | return ['första', 'andra', 'tredje', 'fjärde', 'femte',
288 | 'sjätte', 'sjunde', 'åttonde', 'nionde', 'tionde'
289 | /* Can't possibly be more than ten exits, can there? */][n - 1];
290 | },
291 | ui: {
292 | startPlaceholder: 'Från',
293 | viaPlaceholder: 'Via {viaNumber}',
294 | endPlaceholder: 'Till'
295 | }
296 | },
297 |
298 | 'es': spanish,
299 | 'sp': spanish,
300 |
301 | 'nl': {
302 | directions: {
303 | N: 'noordelijke',
304 | NE: 'noordoostelijke',
305 | E: 'oostelijke',
306 | SE: 'zuidoostelijke',
307 | S: 'zuidelijke',
308 | SW: 'zuidewestelijke',
309 | W: 'westelijke',
310 | NW: 'noordwestelijke'
311 | },
312 | instructions: {
313 | // instruction, postfix if the road is named
314 | 'Head':
315 | ['Vertrek in {dir} richting', ' de {road} op'],
316 | 'Continue':
317 | ['Ga in {dir} richting', ' de {road} op'],
318 | 'SlightRight':
319 | ['Volg de weg naar rechts', ' de {road} op'],
320 | 'Right':
321 | ['Ga rechtsaf', ' de {road} op'],
322 | 'SharpRight':
323 | ['Ga scherpe bocht naar rechts', ' de {road} op'],
324 | 'TurnAround':
325 | ['Keer om'],
326 | 'SharpLeft':
327 | ['Ga scherpe bocht naar links', ' de {road} op'],
328 | 'Left':
329 | ['Ga linksaf', ' de {road} op'],
330 | 'SlightLeft':
331 | ['Volg de weg naar links', ' de {road} op'],
332 | 'WaypointReached':
333 | ['Aangekomen bij tussenpunt'],
334 | 'Roundabout':
335 | ['Neem de {exitStr} afslag op de rotonde', ' de {road} op'],
336 | 'DestinationReached':
337 | ['Aangekomen op eindpunt'],
338 | },
339 | formatOrder: function(n) {
340 | if (n === 1 || n >= 20) {
341 | return n + 'ste';
342 | } else {
343 | return n + 'de';
344 | }
345 | },
346 | ui: {
347 | startPlaceholder: 'Vertrekpunt',
348 | viaPlaceholder: 'Via {viaNumber}',
349 | endPlaceholder: 'Bestemming'
350 | }
351 | },
352 | 'fr': {
353 | directions: {
354 | N: 'nord',
355 | NE: 'nord-est',
356 | E: 'est',
357 | SE: 'sud-est',
358 | S: 'sud',
359 | SW: 'sud-ouest',
360 | W: 'ouest',
361 | NW: 'nord-ouest'
362 | },
363 | instructions: {
364 | // instruction, postfix if the road is named
365 | 'Head':
366 | ['Tout droit au {dir}', ' sur {road}'],
367 | 'Continue':
368 | ['Continuer au {dir}', ' sur {road}'],
369 | 'SlightRight':
370 | ['Légèrement à droite', ' sur {road}'],
371 | 'Right':
372 | ['A droite', ' sur {road}'],
373 | 'SharpRight':
374 | ['Complètement à droite', ' sur {road}'],
375 | 'TurnAround':
376 | ['Faire demi-tour'],
377 | 'SharpLeft':
378 | ['Complètement à gauche', ' sur {road}'],
379 | 'Left':
380 | ['A gauche', ' sur {road}'],
381 | 'SlightLeft':
382 | ['Légèrement à gauche', ' sur {road}'],
383 | 'WaypointReached':
384 | ['Point d\'étape atteint'],
385 | 'Roundabout':
386 | ['Au rond-point, prenez la {exitStr} sortie', ' sur {road}'],
387 | 'DestinationReached':
388 | ['Destination atteinte'],
389 | },
390 | formatOrder: function(n) {
391 | return n + 'º';
392 | },
393 | ui: {
394 | startPlaceholder: 'Départ',
395 | viaPlaceholder: 'Intermédiaire {viaNumber}',
396 | endPlaceholder: 'Arrivée'
397 | }
398 | },
399 | 'it': {
400 | directions: {
401 | N: 'nord',
402 | NE: 'nord-est',
403 | E: 'est',
404 | SE: 'sud-est',
405 | S: 'sud',
406 | SW: 'sud-ovest',
407 | W: 'ovest',
408 | NW: 'nord-ovest'
409 | },
410 | instructions: {
411 | // instruction, postfix if the road is named
412 | 'Head':
413 | ['Dritto verso {dir}', ' su {road}'],
414 | 'Continue':
415 | ['Continuare verso {dir}', ' su {road}'],
416 | 'SlightRight':
417 | ['Mantenere la destra', ' su {road}'],
418 | 'Right':
419 | ['A destra', ' su {road}'],
420 | 'SharpRight':
421 | ['Strettamente a destra', ' su {road}'],
422 | 'TurnAround':
423 | ['Fare inversione di marcia'],
424 | 'SharpLeft':
425 | ['Strettamente a sinistra', ' su {road}'],
426 | 'Left':
427 | ['A sinistra', ' sur {road}'],
428 | 'SlightLeft':
429 | ['Mantenere la sinistra', ' su {road}'],
430 | 'WaypointReached':
431 | ['Punto di passaggio raggiunto'],
432 | 'Roundabout':
433 | ['Alla rotonda, prendere la {exitStr} uscita'],
434 | 'DestinationReached':
435 | ['Destinazione raggiunta'],
436 | },
437 | formatOrder: function(n) {
438 | return n + 'º';
439 | },
440 | ui: {
441 | startPlaceholder: 'Partenza',
442 | viaPlaceholder: 'Intermedia {viaNumber}',
443 | endPlaceholder: 'Destinazione'
444 | }
445 | },
446 | 'pt': {
447 | directions: {
448 | N: 'norte',
449 | NE: 'nordeste',
450 | E: 'leste',
451 | SE: 'sudeste',
452 | S: 'sul',
453 | SW: 'sudoeste',
454 | W: 'oeste',
455 | NW: 'noroeste',
456 | SlightRight: 'curva ligeira a direita',
457 | Right: 'direita',
458 | SharpRight: 'curva fechada a direita',
459 | SlightLeft: 'ligeira a esquerda',
460 | Left: 'esquerda',
461 | SharpLeft: 'curva fechada a esquerda',
462 | Uturn: 'Meia volta'
463 | },
464 | instructions: {
465 | // instruction, postfix if the road is named
466 | 'Head':
467 | ['Siga {dir}', ' na {road}'],
468 | 'Continue':
469 | ['Continue {dir}', ' na {road}'],
470 | 'SlightRight':
471 | ['Curva ligeira a direita', ' na {road}'],
472 | 'Right':
473 | ['Curva a direita', ' na {road}'],
474 | 'SharpRight':
475 | ['Curva fechada a direita', ' na {road}'],
476 | 'TurnAround':
477 | ['Retorne'],
478 | 'SharpLeft':
479 | ['Curva fechada a esquerda', ' na {road}'],
480 | 'Left':
481 | ['Curva a esquerda', ' na {road}'],
482 | 'SlightLeft':
483 | ['Curva ligueira a esquerda', ' na {road}'],
484 | 'WaypointReached':
485 | ['Ponto de interesse atingido'],
486 | 'Roundabout':
487 | ['Pegue a {exitStr} saída na rotatória', ' na {road}'],
488 | 'DestinationReached':
489 | ['Destino atingido'],
490 | 'Fork': ['Na encruzilhada, vire a {modifier}', ' na {road}'],
491 | 'Merge': ['Entre à {modifier}', ' na {road}'],
492 | 'OnRamp': ['Vire {modifier} na rampa', ' na {road}'],
493 | 'OffRamp': ['Entre na rampa na {modifier}', ' na {road}'],
494 | 'EndOfRoad': ['Vire {modifier} no fim da rua', ' na {road}'],
495 | 'Onto': 'na {road}'
496 | },
497 | formatOrder: function(n) {
498 | return n + 'º';
499 | },
500 | ui: {
501 | startPlaceholder: 'Origem',
502 | viaPlaceholder: 'Intermédio {viaNumber}',
503 | endPlaceholder: 'Destino'
504 | }
505 | },
506 | 'sk': {
507 | directions: {
508 | N: 'sever',
509 | NE: 'serverovýchod',
510 | E: 'východ',
511 | SE: 'juhovýchod',
512 | S: 'juh',
513 | SW: 'juhozápad',
514 | W: 'západ',
515 | NW: 'serverozápad'
516 | },
517 | instructions: {
518 | // instruction, postfix if the road is named
519 | 'Head':
520 | ['Mierte na {dir}', ' na {road}'],
521 | 'Continue':
522 | ['Pokračujte na {dir}', ' na {road}'],
523 | 'SlightRight':
524 | ['Mierne doprava', ' na {road}'],
525 | 'Right':
526 | ['Doprava', ' na {road}'],
527 | 'SharpRight':
528 | ['Prudko doprava', ' na {road}'],
529 | 'TurnAround':
530 | ['Otočte sa'],
531 | 'SharpLeft':
532 | ['Prudko doľava', ' na {road}'],
533 | 'Left':
534 | ['Doľava', ' na {road}'],
535 | 'SlightLeft':
536 | ['Mierne doľava', ' na {road}'],
537 | 'WaypointReached':
538 | ['Ste v prejazdovom bode.'],
539 | 'Roundabout':
540 | ['Odbočte na {exitStr} výjazde', ' na {road}'],
541 | 'DestinationReached':
542 | ['Prišli ste do cieľa.'],
543 | },
544 | formatOrder: function(n) {
545 | var i = n % 10 - 1,
546 | suffix = ['.', '.', '.'];
547 |
548 | return suffix[i] ? n + suffix[i] : n + '.';
549 | },
550 | ui: {
551 | startPlaceholder: 'Začiatok',
552 | viaPlaceholder: 'Cez {viaNumber}',
553 | endPlaceholder: 'Koniec'
554 | }
555 | },
556 | 'el': {
557 | directions: {
558 | N: 'βόρεια',
559 | NE: 'βορειοανατολικά',
560 | E: 'ανατολικά',
561 | SE: 'νοτιοανατολικά',
562 | S: 'νότια',
563 | SW: 'νοτιοδυτικά',
564 | W: 'δυτικά',
565 | NW: 'βορειοδυτικά'
566 | },
567 | instructions: {
568 | // instruction, postfix if the road is named
569 | 'Head':
570 | ['Κατευθυνθείτε {dir}', ' στην {road}'],
571 | 'Continue':
572 | ['Συνεχίστε {dir}', ' στην {road}'],
573 | 'SlightRight':
574 | ['Ελαφρώς δεξιά', ' στην {road}'],
575 | 'Right':
576 | ['Δεξιά', ' στην {road}'],
577 | 'SharpRight':
578 | ['Απότομη δεξιά στροφή', ' στην {road}'],
579 | 'TurnAround':
580 | ['Κάντε αναστροφή'],
581 | 'SharpLeft':
582 | ['Απότομη αριστερή στροφή', ' στην {road}'],
583 | 'Left':
584 | ['Αριστερά', ' στην {road}'],
585 | 'SlightLeft':
586 | ['Ελαφρώς αριστερά', ' στην {road}'],
587 | 'WaypointReached':
588 | ['Φτάσατε στο σημείο αναφοράς'],
589 | 'Roundabout':
590 | ['Ακολουθήστε την {exitStr} έξοδο στο κυκλικό κόμβο', ' στην {road}'],
591 | 'DestinationReached':
592 | ['Φτάσατε στον προορισμό σας'],
593 | },
594 | formatOrder: function(n) {
595 | return n + 'º';
596 | },
597 | ui: {
598 | startPlaceholder: 'Αφετηρία',
599 | viaPlaceholder: 'μέσω {viaNumber}',
600 | endPlaceholder: 'Προορισμός'
601 | }
602 | },
603 | 'ca': {
604 | directions: {
605 | N: 'nord',
606 | NE: 'nord-est',
607 | E: 'est',
608 | SE: 'sud-est',
609 | S: 'sud',
610 | SW: 'sud-oest',
611 | W: 'oest',
612 | NW: 'nord-oest',
613 | SlightRight: 'lleu gir a la dreta',
614 | Right: 'dreta',
615 | SharpRight: 'gir pronunciat a la dreta',
616 | SlightLeft: 'gir pronunciat a l\'esquerra',
617 | Left: 'esquerra',
618 | SharpLeft: 'lleu gir a l\'esquerra',
619 | Uturn: 'mitja volta'
620 | },
621 | instructions: {
622 | 'Head':
623 | ['Recte {dir}', ' sobre {road}'],
624 | 'Continue':
625 | ['Continuar {dir}'],
626 | 'TurnAround':
627 | ['Donar la volta'],
628 | 'WaypointReached':
629 | ['Ha arribat a un punt del camí'],
630 | 'Roundabout':
631 | ['Agafar {exitStr} sortida a la rotonda', ' a {road}'],
632 | 'DestinationReached':
633 | ['Arribada al destí'],
634 | 'Fork': ['A la cruïlla gira a la {modifier}', ' cap a {road}'],
635 | 'Merge': ['Incorpora\'t {modifier}', ' a {road}'],
636 | 'OnRamp': ['Gira {modifier} a la sortida', ' cap a {road}'],
637 | 'OffRamp': ['Pren la sortida {modifier}', ' cap a {road}'],
638 | 'EndOfRoad': ['Gira {modifier} al final de la carretera', ' cap a {road}'],
639 | 'Onto': 'cap a {road}'
640 | },
641 | formatOrder: function(n) {
642 | return n + 'º';
643 | },
644 | ui: {
645 | startPlaceholder: 'Origen',
646 | viaPlaceholder: 'Via {viaNumber}',
647 | endPlaceholder: 'Destí'
648 | },
649 | units: {
650 | meters: 'm',
651 | kilometers: 'km',
652 | yards: 'yd',
653 | miles: 'mi',
654 | hours: 'h',
655 | minutes: 'min',
656 | seconds: 's'
657 | }
658 | },
659 | 'ru': {
660 | directions: {
661 | N: 'север',
662 | NE: 'северовосток',
663 | E: 'восток',
664 | SE: 'юговосток',
665 | S: 'юг',
666 | SW: 'югозапад',
667 | W: 'запад',
668 | NW: 'северозапад',
669 | SlightRight: 'плавно направо',
670 | Right: 'направо',
671 | SharpRight: 'резко направо',
672 | SlightLeft: 'плавно налево',
673 | Left: 'налево',
674 | SharpLeft: 'резко налево',
675 | Uturn: 'развернуться'
676 | },
677 | instructions: {
678 | 'Head':
679 | ['Начать движение на {dir}', ' по {road}'],
680 | 'Continue':
681 | ['Продолжать движение на {dir}', ' по {road}'],
682 | 'SlightRight':
683 | ['Плавный поворот направо', ' на {road}'],
684 | 'Right':
685 | ['Направо', ' на {road}'],
686 | 'SharpRight':
687 | ['Резкий поворот направо', ' на {road}'],
688 | 'TurnAround':
689 | ['Развернуться'],
690 | 'SharpLeft':
691 | ['Резкий поворот налево', ' на {road}'],
692 | 'Left':
693 | ['Поворот налево', ' на {road}'],
694 | 'SlightLeft':
695 | ['Плавный поворот налево', ' на {road}'],
696 | 'WaypointReached':
697 | ['Точка достигнута'],
698 | 'Roundabout':
699 | ['{exitStr} съезд с кольца', ' на {road}'],
700 | 'DestinationReached':
701 | ['Окончание маршрута'],
702 | 'Fork': ['На развилке поверните {modifier}', ' на {road}'],
703 | 'Merge': ['Перестройтесь {modifier}', ' на {road}'],
704 | 'OnRamp': ['Поверните {modifier} на съезд', ' на {road}'],
705 | 'OffRamp': ['Съезжайте на {modifier}', ' на {road}'],
706 | 'EndOfRoad': ['Поверните {modifier} в конце дороги', ' на {road}'],
707 | 'Onto': 'на {road}'
708 | },
709 | formatOrder: function(n) {
710 | return n + '-й';
711 | },
712 | ui: {
713 | startPlaceholder: 'Начало',
714 | viaPlaceholder: 'Через {viaNumber}',
715 | endPlaceholder: 'Конец'
716 | },
717 | units: {
718 | meters: 'м',
719 | kilometers: 'км',
720 | yards: 'ярд',
721 | miles: 'ми',
722 | hours: 'ч',
723 | minutes: 'м',
724 | seconds: 'с'
725 | }
726 | },
727 |
728 | 'pl': {
729 | directions: {
730 | N: 'północ',
731 | NE: 'północny wschód',
732 | E: 'wschód',
733 | SE: 'południowy wschód',
734 | S: 'południe',
735 | SW: 'południowy zachód',
736 | W: 'zachód',
737 | NW: 'północny zachód',
738 | SlightRight: 'lekko w prawo',
739 | Right: 'w prawo',
740 | SharpRight: 'ostro w prawo',
741 | SlightLeft: 'lekko w lewo',
742 | Left: 'w lewo',
743 | SharpLeft: 'ostro w lewo',
744 | Uturn: 'zawróć'
745 | },
746 | instructions: {
747 | // instruction, postfix if the road is named
748 | 'Head':
749 | ['Kieruj się na {dir}', ' na {road}'],
750 | 'Continue':
751 | ['Jedź dalej przez {dir}'],
752 | 'TurnAround':
753 | ['Zawróć'],
754 | 'WaypointReached':
755 | ['Punkt pośredni'],
756 | 'Roundabout':
757 | ['Wyjedź {exitStr} zjazdem na rondzie', ' na {road}'],
758 | 'DestinationReached':
759 | ['Dojechano do miejsca docelowego'],
760 | 'Fork': ['Na rozwidleniu {modifier}', ' na {road}'],
761 | 'Merge': ['Zjedź {modifier}', ' na {road}'],
762 | 'OnRamp': ['Wjazd {modifier}', ' na {road}'],
763 | 'OffRamp': ['Zjazd {modifier}', ' na {road}'],
764 | 'EndOfRoad': ['Skręć {modifier} na końcu drogi', ' na {road}'],
765 | 'Onto': 'na {road}'
766 | },
767 | formatOrder: function(n) {
768 | return n + '.';
769 | },
770 | ui: {
771 | startPlaceholder: 'Początek',
772 | viaPlaceholder: 'Przez {viaNumber}',
773 | endPlaceholder: 'Koniec'
774 | },
775 | units: {
776 | meters: 'm',
777 | kilometers: 'km',
778 | yards: 'yd',
779 | miles: 'mi',
780 | hours: 'godz',
781 | minutes: 'min',
782 | seconds: 's'
783 | }
784 | },
785 | 'uk': {
786 | directions: {
787 | N: 'північ',
788 | NE: 'північний схід',
789 | E: 'схід',
790 | SE: 'південний схід',
791 | S: 'південь',
792 | SW: 'південний захід',
793 | W: 'захід',
794 | NW: 'північний захід',
795 | SlightRight: 'плавно направо',
796 | Right: 'направо',
797 | SharpRight: 'різко направо',
798 | SlightLeft: 'плавно наліво',
799 | Left: 'наліво',
800 | SharpLeft: 'різко наліво',
801 | Uturn: 'розвернутися',
802 | },
803 | instructions: {
804 | 'Head':
805 | [ 'Почати рух на {dir}', 'по {road}'],
806 | 'Continue':
807 | [ 'Продовжувати рух на {dir}', 'по {road}'],
808 | 'SlightRight':
809 | [ 'Плавний поворот направо', 'на {road}'],
810 | 'Right':
811 | [ 'Направо', 'на {road}'],
812 | 'SharpRight':
813 | [ 'Різкий поворот направо', 'на {road}'],
814 | 'TurnAround':
815 | [ 'Розгорнутися'],
816 | 'SharpLeft':
817 | [ 'Різкий поворот наліво', 'на {road}'],
818 | 'Left':
819 | [ 'Поворот наліво', 'на {road}'],
820 | 'SlightLeft':
821 | [ 'Плавний поворот наліво', 'на {road}'],
822 | 'WaypointReached':
823 | [ 'Точка досягнута'],
824 | 'Roundabout':
825 | [ "{ExitStr} з'їзд з кільця", 'на {road}'],
826 | 'DestinationReached':
827 | [ 'Закінчення маршруту'],
828 | 'Fork': [ 'На розвилці поверніть {modifier}', 'на {road}'],
829 | 'Merge': [ 'Візьміть {modifier}', 'на {road}'],
830 | 'OnRamp': [ "Поверніть {modifier} на з'їзд", 'на {road}'],
831 | 'OffRamp': [ "З'їжджайте на {modifier}", 'на {road}'],
832 | 'EndOfRoad': [ 'Поверніть {modifier} в кінці дороги', 'на {road}'],
833 | 'Onto': 'на {road}'
834 | },
835 | formatOrder: function(n) {
836 | return n + '-й';
837 | },
838 | ui: {
839 | startPlaceholder: 'Початок',
840 | viaPlaceholder: 'Через {viaNumber}',
841 | endPlaceholder: 'Кінець'
842 | },
843 | units: {
844 | meters: 'м',
845 | kilometers: 'км',
846 | yards: 'ярд',
847 | miles: 'ми',
848 | hours: 'г',
849 | minutes: 'хв',
850 | seconds: 'сек'
851 | }
852 | }
853 | });
854 | })();
855 |
--------------------------------------------------------------------------------
/src/mapbox.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 |
6 | var OSRMv1 = require('./osrm-v1');
7 |
8 | /**
9 | * Works against OSRM's new API in version 5.0; this has
10 | * the API version v1.
11 | */
12 | module.exports = OSRMv1.extend({
13 | options: {
14 | serviceUrl: 'https://api.mapbox.com/directions/v5',
15 | profile: 'mapbox/driving',
16 | useHints: false
17 | },
18 |
19 | initialize: function(accessToken, options) {
20 | L.Routing.OSRMv1.prototype.initialize.call(this, options);
21 | this.options.requestParameters = this.options.requestParameters || {};
22 | /* jshint camelcase: false */
23 | this.options.requestParameters.access_token = accessToken;
24 | /* jshint camelcase: true */
25 | }
26 | });
27 | })();
28 |
--------------------------------------------------------------------------------
/src/osrm-v1.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet'),
5 | corslite = require('@mapbox/corslite'),
6 | polyline = require('@mapbox/polyline'),
7 | osrmTextInstructions = require('osrm-text-instructions')('v5');
8 |
9 | // Ignore camelcase naming for this file, since OSRM's API uses
10 | // underscores.
11 | /* jshint camelcase: false */
12 |
13 | var Waypoint = require('./waypoint');
14 |
15 | /**
16 | * Works against OSRM's new API in version 5.0; this has
17 | * the API version v1.
18 | */
19 | module.exports = L.Class.extend({
20 | options: {
21 | serviceUrl: 'https://router.project-osrm.org/route/v1',
22 | profile: 'driving',
23 | timeout: 30 * 1000,
24 | routingOptions: {
25 | alternatives: true,
26 | steps: true
27 | },
28 | polylinePrecision: 5,
29 | useHints: true,
30 | suppressDemoServerWarning: false,
31 | language: 'en'
32 | },
33 |
34 | initialize: function(options) {
35 | L.Util.setOptions(this, options);
36 | this._hints = {
37 | locations: {}
38 | };
39 |
40 | if (!this.options.suppressDemoServerWarning &&
41 | this.options.serviceUrl.indexOf('//router.project-osrm.org') >= 0) {
42 | console.warn('You are using OSRM\'s demo server. ' +
43 | 'Please note that it is **NOT SUITABLE FOR PRODUCTION USE**.\n' +
44 | 'Refer to the demo server\'s usage policy: ' +
45 | 'https://github.com/Project-OSRM/osrm-backend/wiki/Api-usage-policy\n\n' +
46 | 'To change, set the serviceUrl option.\n\n' +
47 | 'Please do not report issues with this server to neither ' +
48 | 'Leaflet Routing Machine or OSRM - it\'s for\n' +
49 | 'demo only, and will sometimes not be available, or work in ' +
50 | 'unexpected ways.\n\n' +
51 | 'Please set up your own OSRM server, or use a paid service ' +
52 | 'provider for production.');
53 | }
54 | },
55 |
56 | route: function(waypoints, callback, context, options) {
57 | var timedOut = false,
58 | wps = [],
59 | url,
60 | timer,
61 | wp,
62 | i,
63 | xhr;
64 |
65 | options = L.extend({}, this.options.routingOptions, options);
66 | url = this.buildRouteUrl(waypoints, options);
67 | if (this.options.requestParameters) {
68 | url += L.Util.getParamString(this.options.requestParameters, url);
69 | }
70 |
71 | timer = setTimeout(function() {
72 | timedOut = true;
73 | callback.call(context || callback, {
74 | status: -1,
75 | message: 'OSRM request timed out.'
76 | });
77 | }, this.options.timeout);
78 |
79 | // Create a copy of the waypoints, since they
80 | // might otherwise be asynchronously modified while
81 | // the request is being processed.
82 | for (i = 0; i < waypoints.length; i++) {
83 | wp = waypoints[i];
84 | wps.push(new Waypoint(wp.latLng, wp.name, wp.options));
85 | }
86 |
87 | return xhr = corslite(url, L.bind(function(err, resp) {
88 | var data,
89 | error = {};
90 |
91 | clearTimeout(timer);
92 | if (!timedOut) {
93 | if (!err) {
94 | try {
95 | data = JSON.parse(resp.responseText);
96 | try {
97 | return this._routeDone(data, wps, options, callback, context);
98 | } catch (ex) {
99 | error.status = -3;
100 | error.message = ex.toString();
101 | }
102 | } catch (ex) {
103 | error.status = -2;
104 | error.message = 'Error parsing OSRM response: ' + ex.toString();
105 | }
106 | } else {
107 | var message = err.type + (err.target && err.target.status ? ' HTTP ' + err.target.status + ': ' + err.target.statusText : '');
108 | if (err.responseText) {
109 | try {
110 | data = JSON.parse(err.responseText);
111 | if (data.message)
112 | message = data.message;
113 | } catch (ex) {
114 | }
115 | }
116 | error.message = 'HTTP request failed: ' + message;
117 | error.url = url;
118 | error.status = -1;
119 | error.target = err;
120 | }
121 |
122 | callback.call(context || callback, error);
123 | } else {
124 | xhr.abort();
125 | }
126 | }, this));
127 | },
128 |
129 | requiresMoreDetail: function(route, zoom, bounds) {
130 | if (!route.properties.isSimplified) {
131 | return false;
132 | }
133 |
134 | var waypoints = route.inputWaypoints,
135 | i;
136 | for (i = 0; i < waypoints.length; ++i) {
137 | if (!bounds.contains(waypoints[i].latLng)) {
138 | return true;
139 | }
140 | }
141 |
142 | return false;
143 | },
144 |
145 | _routeDone: function(response, inputWaypoints, options, callback, context) {
146 | var alts = [],
147 | actualWaypoints,
148 | i,
149 | route;
150 |
151 | context = context || callback;
152 | if (response.code !== 'Ok') {
153 | callback.call(context, {
154 | status: response.code
155 | });
156 | return;
157 | }
158 |
159 | actualWaypoints = this._toWaypoints(inputWaypoints, response.waypoints);
160 |
161 | for (i = 0; i < response.routes.length; i++) {
162 | route = this._convertRoute(response.routes[i]);
163 | route.inputWaypoints = inputWaypoints;
164 | route.waypoints = actualWaypoints;
165 | route.properties = {isSimplified: !options || !options.geometryOnly || options.simplifyGeometry};
166 | alts.push(route);
167 | }
168 |
169 | this._saveHintData(response.waypoints, inputWaypoints);
170 |
171 | callback.call(context, null, alts);
172 | },
173 |
174 | _convertRoute: function(responseRoute) {
175 | var result = {
176 | name: '',
177 | coordinates: [],
178 | instructions: [],
179 | summary: {
180 | totalDistance: responseRoute.distance,
181 | totalTime: responseRoute.duration
182 | }
183 | },
184 | legNames = [],
185 | waypointIndices = [],
186 | index = 0,
187 | legCount = responseRoute.legs.length,
188 | hasSteps = responseRoute.legs[0].steps.length > 0,
189 | i,
190 | j,
191 | leg,
192 | step,
193 | geometry,
194 | type,
195 | modifier,
196 | text,
197 | stepToText;
198 |
199 | if (this.options.stepToText) {
200 | stepToText = this.options.stepToText;
201 | } else {
202 | stepToText = L.bind(osrmTextInstructions.compile, osrmTextInstructions, this.options.language);
203 | }
204 |
205 | for (i = 0; i < legCount; i++) {
206 | leg = responseRoute.legs[i];
207 | legNames.push(leg.summary && leg.summary.charAt(0).toUpperCase() + leg.summary.substring(1));
208 | for (j = 0; j < leg.steps.length; j++) {
209 | step = leg.steps[j];
210 | geometry = this._decodePolyline(step.geometry);
211 | result.coordinates.push.apply(result.coordinates, geometry);
212 | type = this._maneuverToInstructionType(step.maneuver, i === legCount - 1);
213 | modifier = this._maneuverToModifier(step.maneuver);
214 | text = stepToText(step, {legCount: legCount, legIndex: i});
215 |
216 | if (type) {
217 | if ((i == 0 && step.maneuver.type == 'depart') || step.maneuver.type == 'arrive') {
218 | waypointIndices.push(index);
219 | }
220 |
221 | result.instructions.push({
222 | type: type,
223 | distance: step.distance,
224 | time: step.duration,
225 | road: step.name,
226 | direction: this._bearingToDirection(step.maneuver.bearing_after),
227 | exit: step.maneuver.exit,
228 | index: index,
229 | mode: step.mode,
230 | modifier: modifier,
231 | text: text
232 | });
233 | }
234 |
235 | index += geometry.length;
236 | }
237 | }
238 |
239 | result.name = legNames.join(', ');
240 | if (!hasSteps) {
241 | result.coordinates = this._decodePolyline(responseRoute.geometry);
242 | } else {
243 | result.waypointIndices = waypointIndices;
244 | }
245 |
246 | return result;
247 | },
248 |
249 | _bearingToDirection: function(bearing) {
250 | var oct = Math.round(bearing / 45) % 8;
251 | return ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'][oct];
252 | },
253 |
254 | _maneuverToInstructionType: function(maneuver, lastLeg) {
255 | switch (maneuver.type) {
256 | case 'new name':
257 | return 'Continue';
258 | case 'depart':
259 | return 'Head';
260 | case 'arrive':
261 | return lastLeg ? 'DestinationReached' : 'WaypointReached';
262 | case 'roundabout':
263 | case 'rotary':
264 | return 'Roundabout';
265 | case 'merge':
266 | case 'fork':
267 | case 'on ramp':
268 | case 'off ramp':
269 | case 'end of road':
270 | return this._camelCase(maneuver.type);
271 | // These are all reduced to the same instruction in the current model
272 | //case 'turn':
273 | //case 'ramp': // deprecated in v5.1
274 | default:
275 | return this._camelCase(maneuver.modifier);
276 | }
277 | },
278 |
279 | _maneuverToModifier: function(maneuver) {
280 | var modifier = maneuver.modifier;
281 |
282 | switch (maneuver.type) {
283 | case 'merge':
284 | case 'fork':
285 | case 'on ramp':
286 | case 'off ramp':
287 | case 'end of road':
288 | modifier = this._leftOrRight(modifier);
289 | }
290 |
291 | return modifier && this._camelCase(modifier);
292 | },
293 |
294 | _camelCase: function(s) {
295 | var words = s.split(' '),
296 | result = '';
297 | for (var i = 0, l = words.length; i < l; i++) {
298 | result += words[i].charAt(0).toUpperCase() + words[i].substring(1);
299 | }
300 |
301 | return result;
302 | },
303 |
304 | _leftOrRight: function(d) {
305 | return d.indexOf('left') >= 0 ? 'Left' : 'Right';
306 | },
307 |
308 | _decodePolyline: function(routeGeometry) {
309 | var cs = polyline.decode(routeGeometry, this.options.polylinePrecision),
310 | result = new Array(cs.length),
311 | i;
312 | for (i = cs.length - 1; i >= 0; i--) {
313 | result[i] = L.latLng(cs[i]);
314 | }
315 |
316 | return result;
317 | },
318 |
319 | _toWaypoints: function(inputWaypoints, vias) {
320 | var wps = [],
321 | i,
322 | viaLoc;
323 | for (i = 0; i < vias.length; i++) {
324 | viaLoc = vias[i].location;
325 | wps.push(new Waypoint(L.latLng(viaLoc[1], viaLoc[0]),
326 | inputWaypoints[i].name,
327 | inputWaypoints[i].options));
328 | }
329 |
330 | return wps;
331 | },
332 |
333 | buildRouteUrl: function(waypoints, options) {
334 | var locs = [],
335 | hints = [],
336 | wp,
337 | latLng,
338 | computeInstructions,
339 | computeAlternative = true;
340 |
341 | for (var i = 0; i < waypoints.length; i++) {
342 | wp = waypoints[i];
343 | latLng = wp.latLng;
344 | locs.push(latLng.lng + ',' + latLng.lat);
345 | hints.push(this._hints.locations[this._locationKey(latLng)] || '');
346 | }
347 |
348 | computeInstructions =
349 | true;
350 |
351 | return this.options.serviceUrl + '/' + this.options.profile + '/' +
352 | locs.join(';') + '?' +
353 | (options.geometryOnly ? (options.simplifyGeometry ? '' : 'overview=full') : 'overview=false') +
354 | '&alternatives=' + computeAlternative.toString() +
355 | '&steps=' + computeInstructions.toString() +
356 | (this.options.useHints ? '&hints=' + hints.join(';') : '') +
357 | (options.allowUTurns ? '&continue_straight=' + !options.allowUTurns : '');
358 | },
359 |
360 | _locationKey: function(location) {
361 | return location.lat + ',' + location.lng;
362 | },
363 |
364 | _saveHintData: function(actualWaypoints, waypoints) {
365 | var loc;
366 | this._hints = {
367 | locations: {}
368 | };
369 | for (var i = actualWaypoints.length - 1; i >= 0; i--) {
370 | loc = waypoints[i].latLng;
371 | this._hints.locations[this._locationKey(loc)] = actualWaypoints[i].hint;
372 | }
373 | },
374 | });
375 | })();
376 |
--------------------------------------------------------------------------------
/src/plan.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 | var GeocoderElement = require('./geocoder-element');
6 | var Waypoint = require('./waypoint');
7 |
8 | module.exports = (L.Layer || L.Class).extend({
9 | includes: ((typeof L.Evented !== 'undefined' && L.Evented.prototype) || L.Mixin.Events),
10 |
11 | options: {
12 | dragStyles: [
13 | {color: 'black', opacity: 0.15, weight: 9},
14 | {color: 'white', opacity: 0.8, weight: 6},
15 | {color: 'red', opacity: 1, weight: 2, dashArray: '7,12'}
16 | ],
17 | draggableWaypoints: true,
18 | routeWhileDragging: false,
19 | addWaypoints: true,
20 | reverseWaypoints: false,
21 | addButtonClassName: '',
22 | language: 'en',
23 | createGeocoderElement: function(wp, i, nWps, plan) {
24 | return new GeocoderElement(wp, i, nWps, plan);
25 | },
26 | createMarker: function(i, wp) {
27 | var options = {
28 | draggable: this.draggableWaypoints
29 | },
30 | marker = L.marker(wp.latLng, options);
31 |
32 | return marker;
33 | },
34 | geocodersClassName: ''
35 | },
36 |
37 | initialize: function(waypoints, options) {
38 | L.Util.setOptions(this, options);
39 | this._waypoints = [];
40 | this.setWaypoints(waypoints);
41 | },
42 |
43 | isReady: function() {
44 | var i;
45 | for (i = 0; i < this._waypoints.length; i++) {
46 | if (!this._waypoints[i].latLng) {
47 | return false;
48 | }
49 | }
50 |
51 | return true;
52 | },
53 |
54 | getWaypoints: function() {
55 | var i,
56 | wps = [];
57 |
58 | for (i = 0; i < this._waypoints.length; i++) {
59 | wps.push(this._waypoints[i]);
60 | }
61 |
62 | return wps;
63 | },
64 |
65 | setWaypoints: function(waypoints) {
66 | var args = [0, this._waypoints.length].concat(waypoints);
67 | this.spliceWaypoints.apply(this, args);
68 | return this;
69 | },
70 |
71 | spliceWaypoints: function() {
72 | var args = [arguments[0], arguments[1]],
73 | i;
74 |
75 | for (i = 2; i < arguments.length; i++) {
76 | args.push(arguments[i] && arguments[i].hasOwnProperty('latLng') ? arguments[i] : new Waypoint(arguments[i]));
77 | }
78 |
79 | [].splice.apply(this._waypoints, args);
80 |
81 | // Make sure there's always at least two waypoints
82 | while (this._waypoints.length < 2) {
83 | this.spliceWaypoints(this._waypoints.length, 0, null);
84 | }
85 |
86 | this._updateMarkers();
87 | this._fireChanged.apply(this, args);
88 | },
89 |
90 | onAdd: function(map) {
91 | this._map = map;
92 | this._updateMarkers();
93 | },
94 |
95 | onRemove: function() {
96 | var i;
97 | this._removeMarkers();
98 |
99 | if (this._newWp) {
100 | for (i = 0; i < this._newWp.lines.length; i++) {
101 | this._map.removeLayer(this._newWp.lines[i]);
102 | }
103 | }
104 |
105 | delete this._map;
106 | },
107 |
108 | createGeocoders: function() {
109 | var container = L.DomUtil.create('div', 'leaflet-routing-geocoders ' + this.options.geocodersClassName),
110 | waypoints = this._waypoints,
111 | addWpBtn,
112 | reverseBtn;
113 |
114 | this._geocoderContainer = container;
115 | this._geocoderElems = [];
116 |
117 |
118 | if (this.options.addWaypoints) {
119 | addWpBtn = L.DomUtil.create('button', 'leaflet-routing-add-waypoint ' + this.options.addButtonClassName, container);
120 | addWpBtn.setAttribute('type', 'button');
121 | L.DomEvent.addListener(addWpBtn, 'click', function() {
122 | this.spliceWaypoints(waypoints.length, 0, null);
123 | }, this);
124 | }
125 |
126 | if (this.options.reverseWaypoints) {
127 | reverseBtn = L.DomUtil.create('button', 'leaflet-routing-reverse-waypoints', container);
128 | reverseBtn.setAttribute('type', 'button');
129 | L.DomEvent.addListener(reverseBtn, 'click', function() {
130 | this._waypoints.reverse();
131 | this.setWaypoints(this._waypoints);
132 | }, this);
133 | }
134 |
135 | this._updateGeocoders();
136 | this.on('waypointsspliced', this._updateGeocoders);
137 |
138 | return container;
139 | },
140 |
141 | _createGeocoder: function(i) {
142 | var geocoder = this.options.createGeocoderElement(this._waypoints[i], i, this._waypoints.length, this.options);
143 | geocoder
144 | .on('delete', function() {
145 | if (i > 0 || this._waypoints.length > 2) {
146 | this.spliceWaypoints(i, 1);
147 | } else {
148 | this.spliceWaypoints(i, 1, new Waypoint());
149 | }
150 | }, this)
151 | .on('geocoded', function(e) {
152 | this._updateMarkers();
153 | this._fireChanged();
154 | this._focusGeocoder(i + 1);
155 | this.fire('waypointgeocoded', {
156 | waypointIndex: i,
157 | waypoint: e.waypoint
158 | });
159 | }, this)
160 | .on('reversegeocoded', function(e) {
161 | this.fire('waypointgeocoded', {
162 | waypointIndex: i,
163 | waypoint: e.waypoint
164 | });
165 | }, this);
166 |
167 | return geocoder;
168 | },
169 |
170 | _updateGeocoders: function() {
171 | var elems = [],
172 | i,
173 | geocoderElem;
174 |
175 | for (i = 0; i < this._geocoderElems.length; i++) {
176 | this._geocoderContainer.removeChild(this._geocoderElems[i].getContainer());
177 | }
178 |
179 | for (i = this._waypoints.length - 1; i >= 0; i--) {
180 | geocoderElem = this._createGeocoder(i);
181 | this._geocoderContainer.insertBefore(geocoderElem.getContainer(), this._geocoderContainer.firstChild);
182 | elems.push(geocoderElem);
183 | }
184 |
185 | this._geocoderElems = elems.reverse();
186 | },
187 |
188 | _removeMarkers: function() {
189 | var i;
190 | if (this._markers) {
191 | for (i = 0; i < this._markers.length; i++) {
192 | if (this._markers[i]) {
193 | this._map.removeLayer(this._markers[i]);
194 | }
195 | }
196 | }
197 | this._markers = [];
198 | },
199 |
200 | _updateMarkers: function() {
201 | var i,
202 | m;
203 |
204 | if (!this._map) {
205 | return;
206 | }
207 |
208 | this._removeMarkers();
209 |
210 | for (i = 0; i < this._waypoints.length; i++) {
211 | if (this._waypoints[i].latLng) {
212 | m = this.options.createMarker(i, this._waypoints[i], this._waypoints.length);
213 | if (m) {
214 | m.addTo(this._map);
215 | if (this.options.draggableWaypoints) {
216 | this._hookWaypointEvents(m, i);
217 | }
218 | }
219 | } else {
220 | m = null;
221 | }
222 | this._markers.push(m);
223 | }
224 | },
225 |
226 | _fireChanged: function() {
227 | this.fire('waypointschanged', {waypoints: this.getWaypoints()});
228 |
229 | if (arguments.length >= 2) {
230 | this.fire('waypointsspliced', {
231 | index: Array.prototype.shift.call(arguments),
232 | nRemoved: Array.prototype.shift.call(arguments),
233 | added: arguments
234 | });
235 | }
236 | },
237 |
238 | _hookWaypointEvents: function(m, i, trackMouseMove) {
239 | var eventLatLng = function(e) {
240 | return trackMouseMove ? e.latlng : e.target.getLatLng();
241 | },
242 | dragStart = L.bind(function(e) {
243 | this.fire('waypointdragstart', {index: i, latlng: eventLatLng(e)});
244 | }, this),
245 | drag = L.bind(function(e) {
246 | this._waypoints[i].latLng = eventLatLng(e);
247 | this.fire('waypointdrag', {index: i, latlng: eventLatLng(e)});
248 | }, this),
249 | dragEnd = L.bind(function(e) {
250 | this._waypoints[i].latLng = eventLatLng(e);
251 | this._waypoints[i].name = '';
252 | if (this._geocoderElems) {
253 | this._geocoderElems[i].update(true);
254 | }
255 | this.fire('waypointdragend', {index: i, latlng: eventLatLng(e)});
256 | this._fireChanged();
257 | }, this),
258 | mouseMove,
259 | mouseUp;
260 |
261 | if (trackMouseMove) {
262 | mouseMove = L.bind(function(e) {
263 | this._markers[i].setLatLng(e.latlng);
264 | drag(e);
265 | }, this);
266 | mouseUp = L.bind(function(e) {
267 | this._map.dragging.enable();
268 | this._map.off('mouseup', mouseUp);
269 | this._map.off('mousemove', mouseMove);
270 | dragEnd(e);
271 | }, this);
272 | this._map.dragging.disable();
273 | this._map.on('mousemove', mouseMove);
274 | this._map.on('mouseup', mouseUp);
275 | dragStart({latlng: this._waypoints[i].latLng});
276 | } else {
277 | m.on('dragstart', dragStart);
278 | m.on('drag', drag);
279 | m.on('dragend', dragEnd);
280 | }
281 | },
282 |
283 | dragNewWaypoint: function(e) {
284 | var newWpIndex = e.afterIndex + 1;
285 | if (this.options.routeWhileDragging) {
286 | this.spliceWaypoints(newWpIndex, 0, e.latlng);
287 | this._hookWaypointEvents(this._markers[newWpIndex], newWpIndex, true);
288 | } else {
289 | this._dragNewWaypoint(newWpIndex, e.latlng);
290 | }
291 | },
292 |
293 | _dragNewWaypoint: function(newWpIndex, initialLatLng) {
294 | newWpIndex = (newWpIndex === 0) ? 1 : newWpIndex;
295 | var wp = new Waypoint(initialLatLng),
296 | prevWp = this._waypoints[newWpIndex - 1],
297 | nextWp = this._waypoints[newWpIndex],
298 | marker = this.options.createMarker(newWpIndex, wp, this._waypoints.length + 1),
299 | lines = [],
300 | draggingEnabled = this._map.dragging.enabled(),
301 | mouseMove = L.bind(function(e) {
302 | var i,
303 | latLngs;
304 | if (marker) {
305 | marker.setLatLng(e.latlng);
306 | }
307 | for (i = 0; i < lines.length; i++) {
308 | latLngs = lines[i].getLatLngs();
309 | latLngs.splice(1, 1, e.latlng);
310 | lines[i].setLatLngs(latLngs);
311 | }
312 |
313 | L.DomEvent.stop(e);
314 | }, this),
315 | mouseUp = L.bind(function(e) {
316 | var i;
317 | if (marker) {
318 | this._map.removeLayer(marker);
319 | }
320 | for (i = 0; i < lines.length; i++) {
321 | this._map.removeLayer(lines[i]);
322 | }
323 | this._map.off('mousemove', mouseMove);
324 | this._map.off('mouseup', mouseUp);
325 | this.spliceWaypoints(newWpIndex, 0, e.latlng);
326 | if (draggingEnabled) {
327 | this._map.dragging.enable();
328 | }
329 |
330 | L.DomEvent.stop(e);
331 | }, this),
332 | i;
333 |
334 | if (marker) {
335 | marker.addTo(this._map);
336 | }
337 |
338 | for (i = 0; i < this.options.dragStyles.length; i++) {
339 | lines.push(L.polyline([prevWp.latLng, initialLatLng, nextWp.latLng],
340 | this.options.dragStyles[i]).addTo(this._map));
341 | }
342 |
343 | if (draggingEnabled) {
344 | this._map.dragging.disable();
345 | }
346 |
347 | this._map.on('mousemove', mouseMove);
348 | this._map.on('mouseup', mouseUp);
349 | },
350 |
351 | _focusGeocoder: function(i) {
352 | if (this._geocoderElems[i]) {
353 | this._geocoderElems[i].focus();
354 | } else {
355 | document.activeElement.blur();
356 | }
357 | }
358 | });
359 | })();
360 |
--------------------------------------------------------------------------------
/src/waypoint.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | var L = require('leaflet');
5 |
6 | module.exports = L.Class.extend({
7 | options: {
8 | allowUTurn: false,
9 | },
10 | initialize: function(latLng, name, options) {
11 | L.Util.setOptions(this, options);
12 | this.latLng = L.latLng(latLng);
13 | this.name = name;
14 | }
15 | });
16 | })();
17 |
--------------------------------------------------------------------------------
/test/SpecRunner.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Jasmine Spec Runner v2.0.0
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.0.0/boot.js:
--------------------------------------------------------------------------------
1 | /**
2 | Starting with version 2.0, this file "boots" Jasmine, performing all of the necessary initialization before executing the loaded environment and all of a project's specs. This file should be loaded after `jasmine.js`, but before any project source files or spec files are loaded. Thus this file can also be used to customize Jasmine for a project.
3 |
4 | If a project is using Jasmine via the standalone distribution, this file can be customized directly. If a project is using Jasmine via the [Ruby gem][jasmine-gem], this file can be copied into the support directory via `jasmine copy_boot_js`. Other environments (e.g., Python) will have different mechanisms.
5 |
6 | The location of `boot.js` can be specified and/or overridden in `jasmine.yml`.
7 |
8 | [jasmine-gem]: http://github.com/pivotal/jasmine-gem
9 | */
10 |
11 | (function() {
12 |
13 | /**
14 | * ## Require & Instantiate
15 | *
16 | * Require Jasmine's core files. Specifically, this requires and attaches all of Jasmine's code to the `jasmine` reference.
17 | */
18 | window.jasmine = jasmineRequire.core(jasmineRequire);
19 |
20 | /**
21 | * Since this is being run in a browser and the results should populate to an HTML page, require the HTML-specific Jasmine code, injecting the same reference.
22 | */
23 | jasmineRequire.html(jasmine);
24 |
25 | /**
26 | * Create the Jasmine environment. This is used to run all specs in a project.
27 | */
28 | var env = jasmine.getEnv();
29 |
30 | /**
31 | * ## The Global Interface
32 | *
33 | * Build up the functions that will be exposed as the Jasmine public interface. A project can customize, rename or alias any of these functions as desired, provided the implementation remains unchanged.
34 | */
35 | var jasmineInterface = {
36 | describe: function(description, specDefinitions) {
37 | return env.describe(description, specDefinitions);
38 | },
39 |
40 | xdescribe: function(description, specDefinitions) {
41 | return env.xdescribe(description, specDefinitions);
42 | },
43 |
44 | it: function(desc, func) {
45 | return env.it(desc, func);
46 | },
47 |
48 | xit: function(desc, func) {
49 | return env.xit(desc, func);
50 | },
51 |
52 | beforeEach: function(beforeEachFunction) {
53 | return env.beforeEach(beforeEachFunction);
54 | },
55 |
56 | afterEach: function(afterEachFunction) {
57 | return env.afterEach(afterEachFunction);
58 | },
59 |
60 | expect: function(actual) {
61 | return env.expect(actual);
62 | },
63 |
64 | pending: function() {
65 | return env.pending();
66 | },
67 |
68 | spyOn: function(obj, methodName) {
69 | return env.spyOn(obj, methodName);
70 | },
71 |
72 | jsApiReporter: new jasmine.JsApiReporter({
73 | timer: new jasmine.Timer()
74 | })
75 | };
76 |
77 | /**
78 | * Add all of the Jasmine global/public interface to the proper global, so a project can use the public interface directly. For example, calling `describe` in specs instead of `jasmine.getEnv().describe`.
79 | */
80 | if (typeof window == "undefined" && typeof exports == "object") {
81 | extend(exports, jasmineInterface);
82 | } else {
83 | extend(window, jasmineInterface);
84 | }
85 |
86 | /**
87 | * Expose the interface for adding custom equality testers.
88 | */
89 | jasmine.addCustomEqualityTester = function(tester) {
90 | env.addCustomEqualityTester(tester);
91 | };
92 |
93 | /**
94 | * Expose the interface for adding custom expectation matchers
95 | */
96 | jasmine.addMatchers = function(matchers) {
97 | return env.addMatchers(matchers);
98 | };
99 |
100 | /**
101 | * Expose the mock interface for the JavaScript timeout functions
102 | */
103 | jasmine.clock = function() {
104 | return env.clock;
105 | };
106 |
107 | /**
108 | * ## Runner Parameters
109 | *
110 | * More browser specific code - wrap the query string in an object and to allow for getting/setting parameters from the runner user interface.
111 | */
112 |
113 | var queryString = new jasmine.QueryString({
114 | getWindowLocation: function() { return window.location; }
115 | });
116 |
117 | var catchingExceptions = queryString.getParam("catch");
118 | env.catchExceptions(typeof catchingExceptions === "undefined" ? true : catchingExceptions);
119 |
120 | /**
121 | * ## Reporters
122 | * The `HtmlReporter` builds all of the HTML UI for the runner page. This reporter paints the dots, stars, and x's for specs, as well as all spec names and all failures (if any).
123 | */
124 | var htmlReporter = new jasmine.HtmlReporter({
125 | env: env,
126 | onRaiseExceptionsClick: function() { queryString.setParam("catch", !env.catchingExceptions()); },
127 | getContainer: function() { return document.body; },
128 | createElement: function() { return document.createElement.apply(document, arguments); },
129 | createTextNode: function() { return document.createTextNode.apply(document, arguments); },
130 | timer: new jasmine.Timer()
131 | });
132 |
133 | /**
134 | * The `jsApiReporter` also receives spec results, and is used by any environment that needs to extract the results from JavaScript.
135 | */
136 | env.addReporter(jasmineInterface.jsApiReporter);
137 | env.addReporter(htmlReporter);
138 |
139 | /**
140 | * Filter which specs will be run by matching the start of the full name against the `spec` query param.
141 | */
142 | var specFilter = new jasmine.HtmlSpecFilter({
143 | filterString: function() { return queryString.getParam("spec"); }
144 | });
145 |
146 | env.specFilter = function(spec) {
147 | return specFilter.matches(spec.getFullName());
148 | };
149 |
150 | /**
151 | * Setting up timing functions to be able to be overridden. Certain browsers (Safari, IE 8, phantomjs) require this hack.
152 | */
153 | window.setTimeout = window.setTimeout;
154 | window.setInterval = window.setInterval;
155 | window.clearTimeout = window.clearTimeout;
156 | window.clearInterval = window.clearInterval;
157 |
158 | /**
159 | * ## Execution
160 | *
161 | * Replace the browser window's `onload`, ensure it's called, and then run all of the loaded specs. This includes initializing the `HtmlReporter` instance and then executing the loaded Jasmine environment. All of this will happen after all of the specs are loaded.
162 | */
163 | var currentWindowOnload = window.onload;
164 |
165 | window.onload = function() {
166 | if (currentWindowOnload) {
167 | currentWindowOnload();
168 | }
169 | htmlReporter.initialize();
170 | env.execute();
171 | };
172 |
173 | /**
174 | * Helper function for readability above.
175 | */
176 | function extend(destination, source) {
177 | for (var property in source) destination[property] = source[property];
178 | return destination;
179 | }
180 |
181 | }());
182 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.0.0/console.js:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2008-2013 Pivotal Labs
3 |
4 | Permission is hereby granted, free of charge, to any person obtaining
5 | a copy of this software and associated documentation files (the
6 | "Software"), to deal in the Software without restriction, including
7 | without limitation the rights to use, copy, modify, merge, publish,
8 | distribute, sublicense, and/or sell copies of the Software, and to
9 | permit persons to whom the Software is furnished to do so, subject to
10 | the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 | */
23 | function getJasmineRequireObj() {
24 | if (typeof module !== "undefined" && module.exports) {
25 | return exports;
26 | } else {
27 | window.jasmineRequire = window.jasmineRequire || {};
28 | return window.jasmineRequire;
29 | }
30 | }
31 |
32 | getJasmineRequireObj().console = function(jRequire, j$) {
33 | j$.ConsoleReporter = jRequire.ConsoleReporter();
34 | };
35 |
36 | getJasmineRequireObj().ConsoleReporter = function() {
37 |
38 | var noopTimer = {
39 | start: function(){},
40 | elapsed: function(){ return 0; }
41 | };
42 |
43 | function ConsoleReporter(options) {
44 | var print = options.print,
45 | showColors = options.showColors || false,
46 | onComplete = options.onComplete || function() {},
47 | timer = options.timer || noopTimer,
48 | specCount,
49 | failureCount,
50 | failedSpecs = [],
51 | pendingCount,
52 | ansi = {
53 | green: '\x1B[32m',
54 | red: '\x1B[31m',
55 | yellow: '\x1B[33m',
56 | none: '\x1B[0m'
57 | };
58 |
59 | this.jasmineStarted = function() {
60 | specCount = 0;
61 | failureCount = 0;
62 | pendingCount = 0;
63 | print("Started");
64 | printNewline();
65 | timer.start();
66 | };
67 |
68 | this.jasmineDone = function() {
69 | printNewline();
70 | for (var i = 0; i < failedSpecs.length; i++) {
71 | specFailureDetails(failedSpecs[i]);
72 | }
73 |
74 | printNewline();
75 | var specCounts = specCount + " " + plural("spec", specCount) + ", " +
76 | failureCount + " " + plural("failure", failureCount);
77 |
78 | if (pendingCount) {
79 | specCounts += ", " + pendingCount + " pending " + plural("spec", pendingCount);
80 | }
81 |
82 | print(specCounts);
83 |
84 | printNewline();
85 | var seconds = timer.elapsed() / 1000;
86 | print("Finished in " + seconds + " " + plural("second", seconds));
87 |
88 | printNewline();
89 |
90 | onComplete(failureCount === 0);
91 | };
92 |
93 | this.specDone = function(result) {
94 | specCount++;
95 |
96 | if (result.status == "pending") {
97 | pendingCount++;
98 | print(colored("yellow", "*"));
99 | return;
100 | }
101 |
102 | if (result.status == "passed") {
103 | print(colored("green", '.'));
104 | return;
105 | }
106 |
107 | if (result.status == "failed") {
108 | failureCount++;
109 | failedSpecs.push(result);
110 | print(colored("red", 'F'));
111 | }
112 | };
113 |
114 | return this;
115 |
116 | function printNewline() {
117 | print("\n");
118 | }
119 |
120 | function colored(color, str) {
121 | return showColors ? (ansi[color] + str + ansi.none) : str;
122 | }
123 |
124 | function plural(str, count) {
125 | return count == 1 ? str : str + "s";
126 | }
127 |
128 | function repeat(thing, times) {
129 | var arr = [];
130 | for (var i = 0; i < times; i++) {
131 | arr.push(thing);
132 | }
133 | return arr;
134 | }
135 |
136 | function indent(str, spaces) {
137 | var lines = (str || '').split("\n");
138 | var newArr = [];
139 | for (var i = 0; i < lines.length; i++) {
140 | newArr.push(repeat(" ", spaces).join("") + lines[i]);
141 | }
142 | return newArr.join("\n");
143 | }
144 |
145 | function specFailureDetails(result) {
146 | printNewline();
147 | print(result.fullName);
148 |
149 | for (var i = 0; i < result.failedExpectations.length; i++) {
150 | var failedExpectation = result.failedExpectations[i];
151 | printNewline();
152 | print(indent(failedExpectation.stack, 2));
153 | }
154 |
155 | printNewline();
156 | }
157 | }
158 |
159 | return ConsoleReporter;
160 | };
161 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.0.0/jasmine-html.js:
--------------------------------------------------------------------------------
1 | /*
2 | Copyright (c) 2008-2013 Pivotal Labs
3 |
4 | Permission is hereby granted, free of charge, to any person obtaining
5 | a copy of this software and associated documentation files (the
6 | "Software"), to deal in the Software without restriction, including
7 | without limitation the rights to use, copy, modify, merge, publish,
8 | distribute, sublicense, and/or sell copies of the Software, and to
9 | permit persons to whom the Software is furnished to do so, subject to
10 | the following conditions:
11 |
12 | The above copyright notice and this permission notice shall be
13 | included in all copies or substantial portions of the Software.
14 |
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
16 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
17 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
18 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
19 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
20 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
21 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22 | */
23 | jasmineRequire.html = function(j$) {
24 | j$.ResultsNode = jasmineRequire.ResultsNode();
25 | j$.HtmlReporter = jasmineRequire.HtmlReporter(j$);
26 | j$.QueryString = jasmineRequire.QueryString();
27 | j$.HtmlSpecFilter = jasmineRequire.HtmlSpecFilter();
28 | };
29 |
30 | jasmineRequire.HtmlReporter = function(j$) {
31 |
32 | var noopTimer = {
33 | start: function() {},
34 | elapsed: function() { return 0; }
35 | };
36 |
37 | function HtmlReporter(options) {
38 | var env = options.env || {},
39 | getContainer = options.getContainer,
40 | createElement = options.createElement,
41 | createTextNode = options.createTextNode,
42 | onRaiseExceptionsClick = options.onRaiseExceptionsClick || function() {},
43 | timer = options.timer || noopTimer,
44 | results = [],
45 | specsExecuted = 0,
46 | failureCount = 0,
47 | pendingSpecCount = 0,
48 | htmlReporterMain,
49 | symbols;
50 |
51 | this.initialize = function() {
52 | htmlReporterMain = createDom("div", {className: "html-reporter"},
53 | createDom("div", {className: "banner"},
54 | createDom("span", {className: "title"}, "Jasmine"),
55 | createDom("span", {className: "version"}, j$.version)
56 | ),
57 | createDom("ul", {className: "symbol-summary"}),
58 | createDom("div", {className: "alert"}),
59 | createDom("div", {className: "results"},
60 | createDom("div", {className: "failures"})
61 | )
62 | );
63 | getContainer().appendChild(htmlReporterMain);
64 |
65 | symbols = find(".symbol-summary");
66 | };
67 |
68 | var totalSpecsDefined;
69 | this.jasmineStarted = function(options) {
70 | totalSpecsDefined = options.totalSpecsDefined || 0;
71 | timer.start();
72 | };
73 |
74 | var summary = createDom("div", {className: "summary"});
75 |
76 | var topResults = new j$.ResultsNode({}, "", null),
77 | currentParent = topResults;
78 |
79 | this.suiteStarted = function(result) {
80 | currentParent.addChild(result, "suite");
81 | currentParent = currentParent.last();
82 | };
83 |
84 | this.suiteDone = function(result) {
85 | if (currentParent == topResults) {
86 | return;
87 | }
88 |
89 | currentParent = currentParent.parent;
90 | };
91 |
92 | this.specStarted = function(result) {
93 | currentParent.addChild(result, "spec");
94 | };
95 |
96 | var failures = [];
97 | this.specDone = function(result) {
98 | if (result.status != "disabled") {
99 | specsExecuted++;
100 | }
101 |
102 | symbols.appendChild(createDom("li", {
103 | className: result.status,
104 | id: "spec_" + result.id,
105 | title: result.fullName
106 | }
107 | ));
108 |
109 | if (result.status == "failed") {
110 | failureCount++;
111 |
112 | var failure =
113 | createDom("div", {className: "spec-detail failed"},
114 | createDom("div", {className: "description"},
115 | createDom("a", {title: result.fullName, href: specHref(result)}, result.fullName)
116 | ),
117 | createDom("div", {className: "messages"})
118 | );
119 | var messages = failure.childNodes[1];
120 |
121 | for (var i = 0; i < result.failedExpectations.length; i++) {
122 | var expectation = result.failedExpectations[i];
123 | messages.appendChild(createDom("div", {className: "result-message"}, expectation.message));
124 | messages.appendChild(createDom("div", {className: "stack-trace"}, expectation.stack));
125 | }
126 |
127 | failures.push(failure);
128 | }
129 |
130 | if (result.status == "pending") {
131 | pendingSpecCount++;
132 | }
133 | };
134 |
135 | this.jasmineDone = function() {
136 | var banner = find(".banner");
137 | banner.appendChild(createDom("span", {className: "duration"}, "finished in " + timer.elapsed() / 1000 + "s"));
138 |
139 | var alert = find(".alert");
140 |
141 | alert.appendChild(createDom("span", { className: "exceptions" },
142 | createDom("label", { className: "label", 'for': "raise-exceptions" }, "raise exceptions"),
143 | createDom("input", {
144 | className: "raise",
145 | id: "raise-exceptions",
146 | type: "checkbox"
147 | })
148 | ));
149 | var checkbox = find("input");
150 |
151 | checkbox.checked = !env.catchingExceptions();
152 | checkbox.onclick = onRaiseExceptionsClick;
153 |
154 | if (specsExecuted < totalSpecsDefined) {
155 | var skippedMessage = "Ran " + specsExecuted + " of " + totalSpecsDefined + " specs - run all";
156 | alert.appendChild(
157 | createDom("span", {className: "bar skipped"},
158 | createDom("a", {href: "?", title: "Run all specs"}, skippedMessage)
159 | )
160 | );
161 | }
162 | var statusBarMessage = "" + pluralize("spec", specsExecuted) + ", " + pluralize("failure", failureCount);
163 | if (pendingSpecCount) { statusBarMessage += ", " + pluralize("pending spec", pendingSpecCount); }
164 |
165 | var statusBarClassName = "bar " + ((failureCount > 0) ? "failed" : "passed");
166 | alert.appendChild(createDom("span", {className: statusBarClassName}, statusBarMessage));
167 |
168 | var results = find(".results");
169 | results.appendChild(summary);
170 |
171 | summaryList(topResults, summary);
172 |
173 | function summaryList(resultsTree, domParent) {
174 | var specListNode;
175 | for (var i = 0; i < resultsTree.children.length; i++) {
176 | var resultNode = resultsTree.children[i];
177 | if (resultNode.type == "suite") {
178 | var suiteListNode = createDom("ul", {className: "suite", id: "suite-" + resultNode.result.id},
179 | createDom("li", {className: "suite-detail"},
180 | createDom("a", {href: specHref(resultNode.result)}, resultNode.result.description)
181 | )
182 | );
183 |
184 | summaryList(resultNode, suiteListNode);
185 | domParent.appendChild(suiteListNode);
186 | }
187 | if (resultNode.type == "spec") {
188 | if (domParent.getAttribute("class") != "specs") {
189 | specListNode = createDom("ul", {className: "specs"});
190 | domParent.appendChild(specListNode);
191 | }
192 | specListNode.appendChild(
193 | createDom("li", {
194 | className: resultNode.result.status,
195 | id: "spec-" + resultNode.result.id
196 | },
197 | createDom("a", {href: specHref(resultNode.result)}, resultNode.result.description)
198 | )
199 | );
200 | }
201 | }
202 | }
203 |
204 | if (failures.length) {
205 | alert.appendChild(
206 | createDom('span', {className: "menu bar spec-list"},
207 | createDom("span", {}, "Spec List | "),
208 | createDom('a', {className: "failures-menu", href: "#"}, "Failures")));
209 | alert.appendChild(
210 | createDom('span', {className: "menu bar failure-list"},
211 | createDom('a', {className: "spec-list-menu", href: "#"}, "Spec List"),
212 | createDom("span", {}, " | Failures ")));
213 |
214 | find(".failures-menu").onclick = function() {
215 | setMenuModeTo('failure-list');
216 | };
217 | find(".spec-list-menu").onclick = function() {
218 | setMenuModeTo('spec-list');
219 | };
220 |
221 | setMenuModeTo('failure-list');
222 |
223 | var failureNode = find(".failures");
224 | for (var i = 0; i < failures.length; i++) {
225 | failureNode.appendChild(failures[i]);
226 | }
227 | }
228 | };
229 |
230 | return this;
231 |
232 | function find(selector) {
233 | return getContainer().querySelector(selector);
234 | }
235 |
236 | function createDom(type, attrs, childrenVarArgs) {
237 | var el = createElement(type);
238 |
239 | for (var i = 2; i < arguments.length; i++) {
240 | var child = arguments[i];
241 |
242 | if (typeof child === 'string') {
243 | el.appendChild(createTextNode(child));
244 | } else {
245 | if (child) {
246 | el.appendChild(child);
247 | }
248 | }
249 | }
250 |
251 | for (var attr in attrs) {
252 | if (attr == "className") {
253 | el[attr] = attrs[attr];
254 | } else {
255 | el.setAttribute(attr, attrs[attr]);
256 | }
257 | }
258 |
259 | return el;
260 | }
261 |
262 | function pluralize(singular, count) {
263 | var word = (count == 1 ? singular : singular + "s");
264 |
265 | return "" + count + " " + word;
266 | }
267 |
268 | function specHref(result) {
269 | return "?spec=" + encodeURIComponent(result.fullName);
270 | }
271 |
272 | function setMenuModeTo(mode) {
273 | htmlReporterMain.setAttribute("class", "html-reporter " + mode);
274 | }
275 | }
276 |
277 | return HtmlReporter;
278 | };
279 |
280 | jasmineRequire.HtmlSpecFilter = function() {
281 | function HtmlSpecFilter(options) {
282 | var filterString = options && options.filterString() && options.filterString().replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
283 | var filterPattern = new RegExp(filterString);
284 |
285 | this.matches = function(specName) {
286 | return filterPattern.test(specName);
287 | };
288 | }
289 |
290 | return HtmlSpecFilter;
291 | };
292 |
293 | jasmineRequire.ResultsNode = function() {
294 | function ResultsNode(result, type, parent) {
295 | this.result = result;
296 | this.type = type;
297 | this.parent = parent;
298 |
299 | this.children = [];
300 |
301 | this.addChild = function(result, type) {
302 | this.children.push(new ResultsNode(result, type, this));
303 | };
304 |
305 | this.last = function() {
306 | return this.children[this.children.length - 1];
307 | };
308 | }
309 |
310 | return ResultsNode;
311 | };
312 |
313 | jasmineRequire.QueryString = function() {
314 | function QueryString(options) {
315 |
316 | this.setParam = function(key, value) {
317 | var paramMap = queryStringToParamMap();
318 | paramMap[key] = value;
319 | options.getWindowLocation().search = toQueryString(paramMap);
320 | };
321 |
322 | this.getParam = function(key) {
323 | return queryStringToParamMap()[key];
324 | };
325 |
326 | return this;
327 |
328 | function toQueryString(paramMap) {
329 | var qStrPairs = [];
330 | for (var prop in paramMap) {
331 | qStrPairs.push(encodeURIComponent(prop) + "=" + encodeURIComponent(paramMap[prop]));
332 | }
333 | return "?" + qStrPairs.join('&');
334 | }
335 |
336 | function queryStringToParamMap() {
337 | var paramStr = options.getWindowLocation().search.substring(1),
338 | params = [],
339 | paramMap = {};
340 |
341 | if (paramStr.length > 0) {
342 | params = paramStr.split('&');
343 | for (var i = 0; i < params.length; i++) {
344 | var p = params[i].split('=');
345 | var value = decodeURIComponent(p[1]);
346 | if (value === "true" || value === "false") {
347 | value = JSON.parse(value);
348 | }
349 | paramMap[decodeURIComponent(p[0])] = value;
350 | }
351 | }
352 |
353 | return paramMap;
354 | }
355 |
356 | }
357 |
358 | return QueryString;
359 | };
360 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.0.0/jasmine.css:
--------------------------------------------------------------------------------
1 | body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
2 |
3 | .html-reporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
4 | .html-reporter a { text-decoration: none; }
5 | .html-reporter a:hover { text-decoration: underline; }
6 | .html-reporter p, .html-reporter h1, .html-reporter h2, .html-reporter h3, .html-reporter h4, .html-reporter h5, .html-reporter h6 { margin: 0; line-height: 14px; }
7 | .html-reporter .banner, .html-reporter .symbol-summary, .html-reporter .summary, .html-reporter .result-message, .html-reporter .spec .description, .html-reporter .spec-detail .description, .html-reporter .alert .bar, .html-reporter .stack-trace { padding-left: 9px; padding-right: 9px; }
8 | .html-reporter .banner .version { margin-left: 14px; }
9 | .html-reporter #jasmine_content { position: fixed; right: 100%; }
10 | .html-reporter .version { color: #aaaaaa; }
11 | .html-reporter .banner { margin-top: 14px; }
12 | .html-reporter .duration { color: #aaaaaa; float: right; }
13 | .html-reporter .symbol-summary { overflow: hidden; *zoom: 1; margin: 14px 0; }
14 | .html-reporter .symbol-summary li { display: inline-block; height: 8px; width: 14px; font-size: 16px; }
15 | .html-reporter .symbol-summary li.passed { font-size: 14px; }
16 | .html-reporter .symbol-summary li.passed:before { color: #5e7d00; content: "\02022"; }
17 | .html-reporter .symbol-summary li.failed { line-height: 9px; }
18 | .html-reporter .symbol-summary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
19 | .html-reporter .symbol-summary li.disabled { font-size: 14px; }
20 | .html-reporter .symbol-summary li.disabled:before { color: #bababa; content: "\02022"; }
21 | .html-reporter .symbol-summary li.pending { line-height: 17px; }
22 | .html-reporter .symbol-summary li.pending:before { color: #ba9d37; content: "*"; }
23 | .html-reporter .exceptions { color: #fff; float: right; margin-top: 5px; margin-right: 5px; }
24 | .html-reporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
25 | .html-reporter .bar.failed { background-color: #b03911; }
26 | .html-reporter .bar.passed { background-color: #a6b779; }
27 | .html-reporter .bar.skipped { background-color: #bababa; }
28 | .html-reporter .bar.menu { background-color: #fff; color: #aaaaaa; }
29 | .html-reporter .bar.menu a { color: #333333; }
30 | .html-reporter .bar a { color: white; }
31 | .html-reporter.spec-list .bar.menu.failure-list, .html-reporter.spec-list .results .failures { display: none; }
32 | .html-reporter.failure-list .bar.menu.spec-list, .html-reporter.failure-list .summary { display: none; }
33 | .html-reporter .running-alert { background-color: #666666; }
34 | .html-reporter .results { margin-top: 14px; }
35 | .html-reporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
36 | .html-reporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
37 | .html-reporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
38 | .html-reporter.showDetails .summary { display: none; }
39 | .html-reporter.showDetails #details { display: block; }
40 | .html-reporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
41 | .html-reporter .summary { margin-top: 14px; }
42 | .html-reporter .summary ul { list-style-type: none; margin-left: 14px; padding-top: 0; padding-left: 0; }
43 | .html-reporter .summary ul.suite { margin-top: 7px; margin-bottom: 7px; }
44 | .html-reporter .summary li.passed a { color: #5e7d00; }
45 | .html-reporter .summary li.failed a { color: #b03911; }
46 | .html-reporter .summary li.pending a { color: #ba9d37; }
47 | .html-reporter .description + .suite { margin-top: 0; }
48 | .html-reporter .suite { margin-top: 14px; }
49 | .html-reporter .suite a { color: #333333; }
50 | .html-reporter .failures .spec-detail { margin-bottom: 28px; }
51 | .html-reporter .failures .spec-detail .description { background-color: #b03911; }
52 | .html-reporter .failures .spec-detail .description a { color: white; }
53 | .html-reporter .result-message { padding-top: 14px; color: #333333; white-space: pre; }
54 | .html-reporter .result-message span.result { display: block; }
55 | .html-reporter .stack-trace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
56 |
--------------------------------------------------------------------------------
/test/lib/jasmine-2.0.0/jasmine_favicon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/perliedman/leaflet-routing-machine/8dc939a314425684883dc6f016b3aa9d04c8b7ca/test/lib/jasmine-2.0.0/jasmine_favicon.png
--------------------------------------------------------------------------------
/test/spec/formatter-spec.js:
--------------------------------------------------------------------------------
1 | describe('L.Routing.Formatter', function() {
2 | describe('._round', function() {
3 | it('rounds 0 < x < 5 to multiple of 0.5', function() {
4 | var p = new L.Routing.Formatter(undefined);
5 | expect(p._round(1)).toBe(1);
6 | expect(p._round(1.4)).toBe(1.5);
7 | expect(p._round(1.75)).toBe(2);
8 | });
9 | it('rounds 5 < x < 10 to nearest integer', function() {
10 | var p = new L.Routing.Formatter(undefined);
11 | expect(p._round(7)).toBe(7);
12 | expect(p._round(9.4)).toBe(9);
13 | expect(p._round(9.8)).toBe(10);
14 | });
15 | it('rounds 10 < x < 50 values to multiples of 5', function() {
16 | var p = new L.Routing.Formatter(undefined);
17 | expect(p._round(11.5)).toBe(10);
18 | expect(p._round(14)).toBe(15);
19 | expect(p._round(42)).toBe(40);
20 | expect(p._round(43)).toBe(45);
21 | });
22 | it('rounds 50 < x < 100 to multiples of 10', function() {
23 | var p = new L.Routing.Formatter(undefined);
24 | expect(p._round(72)).toBe(70);
25 | expect(p._round(76)).toBe(80);
26 | expect(p._round(97.6)).toBe(100);
27 | });
28 | it('rounds 100 < x < 150 to multiples of 50', function() {
29 | var p = new L.Routing.Formatter(undefined);
30 | expect(p._round(105)).toBe(100);
31 | expect(p._round(125)).toBe(150);
32 | });
33 | it('rounds large values to multiples of 100', function() {
34 | var p = new L.Routing.Formatter(undefined);
35 | expect(p._round(686)).toBe(700);
36 | expect(p._round(860)).toBe(900);
37 | });
38 | it('considers rounding sensitivity', function() {
39 | var p = new L.Routing.Formatter({roundingSensitivity: 5});
40 | expect(p._round(24)).toBe(24);
41 | expect(p._round(52)).toBe(50);
42 | });
43 | });
44 |
45 | describe('.formatDistance', function() {
46 | it('rounds long distances reasonably', function() {
47 | var p = new L.Routing.Formatter({
48 | distanceTemplate: '{value}'
49 | });
50 | expect(parseInt(p.formatDistance(22000), 10)).toBe(20);
51 | expect(parseInt(p.formatDistance(24000), 10)).toBe(25);
52 | expect(parseInt(p.formatDistance(86000), 10)).toBe(90);
53 | });
54 | it('formats imperial units properly', function() {
55 | var p = new L.Routing.Formatter({
56 | distanceTemplate: '{value}',
57 | units: 'imperial'
58 | });
59 | expect(parseInt(p.formatDistance(800), 10)).toBe(900);
60 | expect(parseInt(p.formatDistance(22000), 10)).toBe(15);
61 | expect(parseInt(p.formatDistance(24500), 10)).toBe(15);
62 | expect(parseInt(p.formatDistance(86000), 10)).toBe(55);
63 | });
64 | });
65 |
66 | describe('.formatTime', function() {
67 | it('rounds whole minutes without seconds', function() {
68 | var p = new L.Routing.Formatter();
69 | expect(p.formatTime(240)).toBe('4 min');
70 | })
71 | it('rounds just under five minutes to five minutes without seconds', function() {
72 | var p = new L.Routing.Formatter();
73 | expect(p.formatTime(299.10000000005)).toBe('5 min');
74 | })
75 | });
76 | });
77 |
--------------------------------------------------------------------------------
/test/spec/osrmv1-spec.js:
--------------------------------------------------------------------------------
1 | describe('L.Routing.OSRMv1', function() {
2 | describe('#route', function() {
3 | var waypoints = [
4 | new L.Routing.Waypoint([57.73, 11.94]),
5 | new L.Routing.Waypoint([57.7, 11.9])
6 | ];
7 | it('returns correct waypoints', function(done) {
8 | var router = new L.Routing.OSRMv1();
9 | router.route(waypoints, function(err, routes) {
10 | if (err) {
11 | return done(err);
12 | }
13 |
14 | if (!routes.length) {
15 | return done('No routes :(');
16 | }
17 |
18 | waypoints.forEach(function(wp, i) {
19 | var returnedWp = routes[0].waypoints[i];
20 | expect(Math.abs(returnedWp.latLng.lat - wp.latLng.lat)).to.be.lessThan(0.1);
21 | expect(Math.abs(returnedWp.latLng.lng - wp.latLng.lng)).to.be.lessThan(0.1);
22 | });
23 |
24 | done();
25 | });
26 | });
27 | });
28 | });
29 |
--------------------------------------------------------------------------------