nakarte

commit d013dc0a6dfb4362a7844e8417f71b1b944467d8
parent 6337c1495c98dbf0548ff87ff19d2e616e05c4f4
Author: Sergej Orlov <wladimirych@gmail.com>
Date:   Tue,  3 Jul 2018 01:10:36 +0300

[coordinates] refactor for #85

Diffstat:
M
src/lib/leaflet.control.coordinates/formats.js
 | 
56
+++++++++++++++++++++-----------------------------------
M
src/lib/leaflet.control.coordinates/index.js
 | 
34
+++++++++++++++++++---------------

2 files changed, 40 insertions(+), 50 deletions(-)
diff --git a/src/lib/leaflet.control.coordinates/formats.js b/src/lib/leaflet.control.coordinates/formats.js
@@ -1,4 +1,4 @@
-function pad(value, size, precision = 0) {
+function formatNumber(value, size, precision = 0) {
     if (value < 0) {
       return value.toFixed(precision);
     }
@@ -8,35 +8,35 @@ function pad(value, size, precision = 0) {
     return value.toFixed(precision).padStart(size + precision, '0');
 }
 
-function parseLatLng(signedDegrees, isLat) {
-    const degrees    = Math.abs(signedDegrees);
+function coordinatePresentations(coordinate, isLat) {
+    const degrees    = Math.abs(coordinate);
     const intDegrees = Math.floor(degrees);
     const minutes    = (degrees - intDegrees) * 60;
     const intMinutes = Math.floor(minutes);
     const seconds    = (minutes - intMinutes) * 60;
 
-    let direction
+    let direction;
     if (isLat) {
-        direction = (signedDegrees < 0) ? 'S' : 'N';
+        direction = (coordinate < 0) ? 'S' : 'N';
     } else {
-        direction = (signedDegrees < 0) ? 'W' : 'E';
+        direction = (coordinate < 0) ? 'W' : 'E';
     }
 
     return {
-        signedDegrees: pad(signedDegrees, 0, 5),
-        degrees:       pad(degrees, 0, 5),
-        intDegrees:    pad(intDegrees, 0),
-        minutes:       pad(minutes, 2, 3),
-        intMinutes:    pad(intMinutes, 2),
-        seconds:       pad(seconds, 2, 2),
+        signedDegrees: formatNumber(coordinate, 0, 5),
+        degrees:       formatNumber(degrees, 0, 5),
+        intDegrees:    formatNumber(intDegrees, 0),
+        minutes:       formatNumber(minutes, 2, 3),
+        intMinutes:    formatNumber(intMinutes, 2),
+        seconds:       formatNumber(seconds, 2, 2),
         direction
     };
 }
 
-function transform(latlng, format) {
+function formatLatLng(latlng, format) {
     return {
-        lat: format(parseLatLng(latlng.lat, true)),
-        lng: format(parseLatLng(latlng.lng, false))
+        lat: format.formatter(coordinatePresentations(latlng.lat, true)),
+        lng: format.formatter(coordinatePresentations(latlng.lng, false))
     }
 }
 
@@ -44,47 +44,33 @@ const SIGNED_DEGREES = {
     code: 'd',
     label: '±ddd.ddddd',
     wrapperClass: 'leaflet-coordinates-wrapper-signed-degrees',
-    process: (latlng) => {
-        return transform(latlng, ({signedDegrees}) => signedDegrees);
-    }
+    formatter: ({signedDegrees}) => signedDegrees
 };
 
 const DEGREES = {
     code: 'D',
     label: 'ddd.ddddd°',
     wrapperClass: 'leaflet-coordinates-wrapper-degrees',
-    process: (latlng) => {
-        return transform(latlng, ({degrees, direction}) => {
-            return `${direction} ${degrees}°`;
-        });
-    }
+    formatter: ({degrees, direction}) => `${direction} ${degrees}°`
 };
 
 const DEGREES_AND_MINUTES = {
     code: 'DM',
     label: 'ddd°mm.mmm′',
     wrapperClass: 'leaflet-coordinates-wrapper-degrees-and-minutes',
-    process: (latlng) => {
-        return transform(latlng, ({intDegrees, minutes, direction}) => {
-            return `${direction} ${intDegrees}°${minutes}′`;
-        });
-    }
+    formatter: ({intDegrees, minutes, direction}) => `${direction} ${intDegrees}°${minutes}′`
 };
 
 const DEGREES_AND_MINUTES_AND_SECONDS = {
     code: 'DMS',
     label: 'ddd°mm′ss.s″',
     wrapperClass: 'leaflet-coordinates-wrapper-degrees-and-minutes-and-seconds',
-    process: (latlng) => {
-        return transform(latlng, ({intDegrees, intMinutes, seconds, direction}) => {
-            return `${direction} ${intDegrees}°${intMinutes}′${seconds}″`;
-        });
-    }
-};
+    formatter: ({intDegrees, intMinutes, seconds, direction}) => `${direction} ${intDegrees}°${intMinutes}′${seconds}″`};
 
 export default {
     SIGNED_DEGREES,
     DEGREES,
     DEGREES_AND_MINUTES,
-    DEGREES_AND_MINUTES_AND_SECONDS
+    DEGREES_AND_MINUTES_AND_SECONDS,
+    formatLatLng
 }
diff --git a/src/lib/leaflet.control.coordinates/index.js b/src/lib/leaflet.control.coordinates/index.js
@@ -6,9 +6,9 @@ import Contextmenu from 'lib/contextmenu';
 import {makeButtonWithBar} from 'lib/leaflet.control.commons';
 import safeLocalStorage from 'lib/safe-localstorage';
 import 'lib/controls-styles/controls-styles.css';
-import FORMATS from './formats';
+import formats from './formats';
 
-const DEFAULT_FORMAT = FORMATS.DEGREES;
+const DEFAULT_FORMAT = formats.DEGREES;
 const UNKNOWN_COORDINATES = {
     lat: '-------',
     lng: '-------'
@@ -20,28 +20,32 @@ L.Control.Coordinates = L.Control.extend({
         },
 
         formats: [
-            FORMATS.SIGNED_DEGREES,
-            FORMATS.DEGREES,
-            FORMATS.DEGREES_AND_MINUTES,
-            FORMATS.DEGREES_AND_MINUTES_AND_SECONDS
+            formats.SIGNED_DEGREES,
+            formats.DEGREES,
+            formats.DEGREES_AND_MINUTES,
+            formats.DEGREES_AND_MINUTES_AND_SECONDS
         ],
 
         initialize: function(options) {
             L.Control.prototype.initialize.call(this, options);
 
             this.latlng = ko.observable();
-            this.formatCode = ko.observable(DEFAULT_FORMAT.code);
-
-            this.format = ko.pureComputed(() => {
-                for (let format of this.formats) {
-                    if (format.code === this.formatCode()) return format;
+            this.format = ko.observable(DEFAULT_FORMAT);
+            this.formatCode = ko.pureComputed({
+                read: () => this.format().code,
+                write: (value) => {
+                    for (let format of this.formats) {
+                        if (value === format.code) {
+                            this.format(format);
+                            break
+                        }
+                    }
                 }
-                return DEFAULT_FORMAT;
-            }, this);
+            });
 
             this.formattedCoordinates = ko.pureComputed(() => {
                 if (this.latlng()) {
-                    return this.format().process(this.latlng().wrap());
+                    return formats.formatLatLng(this.latlng().wrap(), this.format());
                 }
                 return UNKNOWN_COORDINATES;
             }, this);
@@ -133,7 +137,7 @@ L.Control.Coordinates = L.Control.extend({
             L.DomEvent.stop(e);
 
             const createItem = (format, options = {}) => {
-                const {lat, lng} = format.process(e.latlng.wrap());
+                const {lat, lng} = formats.formatLatLng(e.latlng.wrap(), format);
                 const coordinates = `${lat} ${lng}`;
 
                 return Object.assign({