@wemap/geo 2.7.1 → 2.7.4

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/geo"
     },
     "name": "@wemap/geo",
-    "version": "2.7.1",
+    "version": "2.7.4",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -28,10 +28,10 @@
     "license": "ISC",
     "dependencies": {
         "@wemap/logger": "^2.7.0",
-        "@wemap/maths": "^2.7.0",
+        "@wemap/maths": "^2.7.2",
         "lodash.isfinite": "^3.3.2",
         "lodash.isnumber": "^3.0.3",
         "lodash.isstring": "^4.0.1"
     },
-    "gitHead": "3d332f1dce308ba28f2a551c2e709e840c54bd83"
+    "gitHead": "346dd50c4934b77b831a081f3543405865f1a65e"
 }

package/src/coordinates/Level.js

@@ -89,12 +89,16 @@ class Level {
 
     /**
      * Retrieve the intersection of two levels
-     * @param {Level} other The other level
+     * @param {Level} first The first level
+     * @param {Level} second The second level
      */
     static intersect(first, second) {
 
         if (first === second) {
-            return first;
+            if (first instanceof Level) {
+                return first.clone();
+            }
+            return null;
         }
 
         if (!second) {
@@ -107,13 +111,13 @@ class Level {
 
         if (first.isRange && !second.isRange) {
             if (first.isInside(second.val)) {
-                return second;
+                return second.clone();
             }
             return null;
         }
         if (!first.isRange && second.isRange) {
             if (second.isInside(first.val)) {
-                return first;
+                return first.clone();
             }
             return null;
         }
@@ -143,15 +147,18 @@ class Level {
     static union(first, second) {
 
         if (first === second) {
-            return first;
+            if (first instanceof Level) {
+                return first.clone();
+            }
+            return null;
         }
 
         if (!second) {
-            return first;
+            return first.clone();
         }
 
         if (!first) {
-            return second;
+            return second.clone();
         }
 
         let low, up;
@@ -218,6 +225,43 @@ class Level {
 
     }
 
+    static diff(first, second) {
+
+        if (first === null || second === null) {
+            return null;
+        }
+
+        if (!first.isRange && !second.isRange) {
+            return second.val - first.val;
+        }
+
+        if (first.isRange && !second.isRange) {
+            if (first.low === second.val) {
+                return second.val - first.up;
+            }
+            if (first.up === second.val) {
+                return second.val - first.low;
+            }
+            return null;
+        }
+
+        if (second.isRange && !first.isRange) {
+            if (first.val === second.low) {
+                return second.up - first.val;
+            }
+            if (first.val === second.up) {
+                return second.low - first.val;
+            }
+            return null;
+        }
+
+        if (Level.equalsTo(first, second)) {
+            return 0;
+        }
+
+        return null;
+    }
+
 }
 
 export default Level;

package/src/coordinates/Level.spec.js

@@ -138,9 +138,9 @@ describe('Level', () => {
         expect(Level.intersect(null, null)).is.null;
 
         const level = new Level(1);
-        expect(Level.intersect(level, null)).equals(null);
-        expect(Level.intersect(null, level)).equals(null);
-        expect(Level.intersect(level, level)).equals(level);
+        expect(Level.intersect(level, null)).is.null;
+        expect(Level.intersect(null, level)).is.null;
+        expect(Level.equalsTo(Level.intersect(level, level), new Level(1))).true;
 
         expect(Level.equalsTo(Level.intersect(new Level(1), new Level(1)), new Level(1))).true;
         expect(Level.intersect(new Level(1), new Level(2))).is.null;
@@ -167,9 +167,9 @@ describe('Level', () => {
         expect(Level.union(null, null)).is.null;
 
         const level = new Level(1);
-        expect(Level.union(level, null)).equals(level);
-        expect(Level.union(null, level)).equals(level);
-        expect(Level.union(level, level)).equals(level);
+        expect(Level.equalsTo(Level.union(level, null), new Level(1))).true;
+        expect(Level.equalsTo(Level.union(null, level), new Level(1))).true;
+        expect(Level.equalsTo(Level.union(level, level), new Level(1))).true;
 
         expect(Level.equalsTo(Level.union(new Level(1), new Level(1)), new Level(1))).true;
         expect(Level.equalsTo(Level.union(new Level(1), new Level(2)), new Level(1, 2))).true;
@@ -200,4 +200,22 @@ describe('Level', () => {
         expect(Level.equalsTo(new Level(1, -1).multiplyBy(5), new Level(-5, 5))).true;
     });
 
+    it('diff', () => {
+        expect(Level.diff(null, null)).is.null;
+        expect(Level.diff(null, new Level(0))).is.null;
+        expect(Level.diff(new Level(0), null)).is.null;
+        expect(Level.diff(new Level(0), new Level(0))).equals(0);
+        expect(Level.diff(new Level(2), new Level(2))).equals(0);
+        expect(Level.diff(new Level(0), new Level(2))).equals(2);
+        expect(Level.diff(new Level(2), new Level(0))).equals(-2);
+        expect(Level.diff(new Level(0, 1), new Level(0))).equals(-1);
+        expect(Level.diff(new Level(0, 1), new Level(1))).equals(1);
+        expect(Level.diff(new Level(0, 1), new Level(2))).is.null;
+        expect(Level.diff(new Level(0), new Level(0, 1))).equals(1);
+        expect(Level.diff(new Level(1), new Level(0, 1))).equals(-1);
+        expect(Level.diff(new Level(2), new Level(0, 1))).is.null;
+        expect(Level.diff(new Level(0, 1), new Level(0, 1))).equals(0);
+        expect(Level.diff(new Level(0, 1), new Level(0, 2))).is.null;
+    });
+
 });