cozy-client 41.4.0 → 41.5.0

package/dist/CozyClient.js

@@ -2703,7 +2703,7 @@ var CozyClient = /*#__PURE__*/function () {
 CozyClient.hooks = CozyClient.hooks || {};
 CozyClient.fetchPolicies = _policies.default; //COZY_CLIENT_VERSION_PACKAGE in replaced by babel. See babel config
 
-CozyClient.version = "41.4.0";
+CozyClient.version = "41.5.0";
 
 _microee.default.mixin(CozyClient);
 

package/dist/models/document/locales/index.js

@@ -13,24 +13,25 @@ var _nodePolyglot = _interopRequireDefault(require("node-polyglot"));
 
 var _emojiCountry = require("../emojiCountry");
 
+var _en = _interopRequireDefault(require("./en.json"));
+
+var _fr = _interopRequireDefault(require("./fr.json"));
+
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
+var locales = {
+  en: _en.default,
+  fr: _fr.default
+};
 var polyglots = {};
 var langs = ['fr', 'en'];
 
 for (var _i = 0, _langs = langs; _i < _langs.length; _i++) {
   var lang = _langs[_i];
-  var locales = {};
-
-  try {
-    locales = require("./".concat(lang, ".json"));
-  } catch (e) {// eslint-disable-line no-empty-block
-  }
-
   var polyglot = new _nodePolyglot.default();
-  polyglot.extend(locales);
+  polyglot.extend(locales[lang]);
   polyglots[lang] = polyglot;
 }
 /**

package/dist/models/geo.js

@@ -3,8 +3,17 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.geodesicDistance = exports.computeSpeed = void 0;
+exports.deltaLatitude = exports.deltaLongitude = exports.computeSphericalCenter = exports.geodesicDistance = exports.computeSpeed = void 0;
 
+function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+// @ts-check
+var EARTH_RADIUS_M = 6378137;
+var EARTH_CIRCUMFERENCE_M = 40075000;
 /**
  * Compute the speed from distance and duration
  *
@@ -12,6 +21,7 @@ exports.geodesicDistance = exports.computeSpeed = void 0;
  * @param {number} duration - The duration in seconds
  * @returns {number} - The speed, in m/s, rounded to 2 decimals
  */
+
 var computeSpeed = function computeSpeed(distance, duration) {
   if (!distance || !duration) {
     return 0;
@@ -19,12 +29,43 @@ var computeSpeed = function computeSpeed(distance, duration) {
 
   return Math.round(distance / duration * 100) / 100;
 };
+/**
+ * Convert degrees to radians
+ *
+ * @param {number} degrees - The degrees to convert
+ * @returns {number} The converted radians
+ */
+
 
 exports.computeSpeed = computeSpeed;
 
 var degreesToRadians = function degreesToRadians(degrees) {
   return degrees * Math.PI / 180;
 };
+/**
+ * Convert radians to degrees
+ *
+ * @param {number} radians - The radians to convert
+ * @returns {number} The converted degrees
+ */
+
+
+var radiansToDegrees = function radiansToDegrees(radians) {
+  return radians * 180 / Math.PI;
+};
+/**
+ * Round the value to the n decimal
+ *
+ * @param {number} value - The value to round
+ * @param {number} n - The number of decimals
+ * @returns {number} The rounded value
+ */
+
+
+var roundToNDecimals = function roundToNDecimals(value, n) {
+  var multiplier = Math.pow(10, n);
+  return Math.round(value * multiplier) / multiplier;
+};
 /**
  * Compute the distance between 2 geographic points, in meters.
  *
@@ -55,10 +96,112 @@ var geodesicDistance = function geodesicDistance(point1, point2) {
   var aLat = Math.pow(Math.sin(diffLat / 2), 2);
   var aLon = Math.pow(Math.sin(diffLon / 2), 2);
   var a = aLat + Math.cos(lat1) * Math.cos(lat2) * aLon;
-  var c = 2 * Math.asin(Math.sqrt(a)); // Radius of earth is 6371 km
+  var c = 2 * Math.asin(Math.sqrt(a));
+  var distance = EARTH_RADIUS_M * c;
+  return roundToNDecimals(distance, 2);
+};
+/**
+ * Compute the geographical center of the given points
+ *
+ * This consists of finding the centroid of a set of points
+ * in a sphere.
+ * Note this assumes the Earth is a perfect sphere, which is not,
+ * but the approximation should be good enough.
+ *
+ * @param {Array<import("../types").Coordinates>} coordinates - The geo points
+ * @returns {import("../types").Coordinates} The center point
+ */
+
+
+exports.geodesicDistance = geodesicDistance;
+
+var computeSphericalCenter = function computeSphericalCenter(coordinates) {
+  if (coordinates.length < 1) {
+    return null;
+  }
+
+  if (coordinates.length === 1) {
+    return coordinates[0];
+  }
+
+  var totalX = 0;
+  var totalY = 0;
+  var totalZ = 0;
+
+  var _iterator = _createForOfIteratorHelper(coordinates),
+      _step;
+
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var coord = _step.value;
+      var lon = degreesToRadians(coord.lon);
+      var lat = degreesToRadians(coord.lat); // Convert spherical coordinates to Cartesian coordinates
+
+      var x = Math.cos(lat) * Math.cos(lon);
+      var y = Math.cos(lat) * Math.sin(lon);
+      var z = Math.sin(lat);
+      totalX += x;
+      totalY += y;
+      totalZ += z;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+
+  var avgX = totalX / coordinates.length;
+  var avgY = totalY / coordinates.length;
+  var avgZ = totalZ / coordinates.length; // Don't forget to convert Cartesian coordinates back to spherical
+
+  var centralLon = radiansToDegrees(Math.atan2(avgY, avgX));
+  var hyp = Math.sqrt(avgX * avgX + avgY * avgY);
+  var centralLat = radiansToDegrees(Math.atan2(avgZ, hyp));
+  return {
+    lat: roundToNDecimals(centralLat, 13),
+    lon: roundToNDecimals(centralLon, 13)
+  };
+};
+/**
+ * Compute the longitude delta from a distance, in meters.
+ *
+ * This requires the latitude: we want to compute the horizontal delta
+ * on the Earth surface. As it is a sphere (kind of), this delta won't be
+ * the same depending on whether it is on the equator (min variation)
+ * or on the poles (max variation), for instance.
+ *
+ * @param {number} latitude - The latitude
+ * @param {number} distance - The distance in meters
+ * @returns {number} the longitude delta degrees
+ */
+
+
+exports.computeSphericalCenter = computeSphericalCenter;
+
+var deltaLongitude = function deltaLongitude(latitude, distance) {
+  var phi = degreesToRadians(latitude);
+  var deltaLambda = distance / (EARTH_RADIUS_M * Math.cos(phi));
+  return roundToNDecimals(radiansToDegrees(deltaLambda), 13);
+};
+/**
+ * Compute the latitude delta from a distance, in meters.
+ *
+ * The reasoning is rather simple: there are 360° of latitudes of same distance.
+ * Then, it consists of computing 1 degree distance, and divide the
+ * given distance by this value.
+ *
+ * @param {number} distance - The distance in meters
+ * @returns {number} The delta latitude degrees
+ */
+
+
+exports.deltaLongitude = deltaLongitude;
+
+var deltaLatitude = function deltaLatitude(distance) {
+  var distOneLatDegree = EARTH_CIRCUMFERENCE_M / 360; // 111 319 meters per degree
 
-  var distance = 6371 * 1000 * c;
-  return Math.round(distance * 100) / 100;
+  var deltaLat = distance / distOneLatDegree;
+  return roundToNDecimals(deltaLat, 13);
 };
 
-exports.geodesicDistance = geodesicDistance;
+exports.deltaLatitude = deltaLatitude;

package/dist/models/geo.spec.js

@@ -1,4 +1,10 @@
-const { geodesicDistance, computeSpeed } = require('./geo')
+const {
+  geodesicDistance,
+  computeSpeed,
+  computeSphericalCenter,
+  deltaLongitude,
+  deltaLatitude
+} = require('./geo')
 
 describe('geodesicDistance', () => {
   it('should return 0 for 2 points with same coordinates', () => {
@@ -15,7 +21,7 @@ describe('geodesicDistance', () => {
   it('should return the correct Paris-NY distance', () => {
     const paris = { lat: 48.8566, lon: 2.3522 }
     const NY = { lat: 40.7128, lon: -74.006 }
-    expect(geodesicDistance(paris, NY)).toEqual(5837240.9)
+    expect(geodesicDistance(paris, NY)).toEqual(5843779.97)
   })
 })
 
@@ -30,3 +36,57 @@ describe('speed', () => {
     expect(computeSpeed(10000, 1800)).toEqual(5.56)
   })
 })
+
+describe('computeSphericalCenter', () => {
+  it('should return null when coordinates are missing', () => {
+    expect(computeSphericalCenter([])).toEqual(null)
+  })
+  it('should return the correct coordinates when there are all equals', () => {
+    expect(computeSphericalCenter([{ lat: 10, lon: 10 }])).toEqual({
+      lat: 10,
+      lon: 10
+    })
+    expect(
+      computeSphericalCenter([
+        { lat: 0.0, lon: 0.0 },
+        { lat: 0.0, lon: 0.0 },
+        { lat: 0.0, lon: 0.0 }
+      ])
+    ).toEqual({ lat: 0, lon: 0 })
+  })
+  it('should return correct center for n points', () => {
+    expect(
+      computeSphericalCenter([{ lat: 10, lon: 10 }, { lat: 10, lon: 10 }])
+    ).toEqual({ lat: 10, lon: 10 })
+
+    expect(
+      computeSphericalCenter([{ lat: 48, lon: 2 }, { lat: 48, lon: 3 }])
+    ).toEqual({ lat: 48.0010848667078, lon: 2.5 })
+
+    expect(
+      computeSphericalCenter([
+        { lat: 10, lon: 10 },
+        { lat: 20, lon: 20 },
+        { lat: 30, lon: 30 }
+      ])
+    ).toEqual({ lat: 20.1866988557583, lon: 19.5721919393414 })
+  })
+})
+
+describe('delta longitude and latitude', () => {
+  it('null distance should give a null delta', () => {
+    expect(deltaLongitude(46.66, 0)).toEqual(0)
+    expect(deltaLatitude(0)).toEqual(0)
+  })
+
+  it('should give the correct longitude delta', () => {
+    expect(deltaLongitude(46.66, 200)).toEqual(0.002617749975)
+    expect(deltaLongitude(0, 200)).toEqual(0.0017966305682) // equator
+    expect(deltaLongitude(89.99, 200)).toEqual(10.2939349426746) // north pole
+    expect(deltaLongitude(-89.99, 200)).toEqual(10.2939349426746) // south pole
+  })
+  it('should give the correct latitude delta', () => {
+    expect(deltaLatitude(200)).toEqual(0.0017966313163)
+    expect(deltaLatitude(2000)).toEqual(0.0179663131628) // contrarily to the longitude, this is linear
+  })
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "41.4.0",
+  "version": "41.5.0",
   "license": "MIT",
   "main": "dist/index.node.js",
   "browser": "dist/index.js",
@@ -75,5 +75,5 @@
     "react-native-ios11-devicecheck": "https://github.com/cozy/react-native-devicecheck#app-attest-v0.1"
   },
   "sideEffects": false,
-  "gitHead": "e5aeef0b9ed86c9052f42de1b93396ebc65657b6"
+  "gitHead": "8930f3135808b75c0b2c52eab95ec0d06fa4c5f8"
 }

package/types/models/geo.d.ts

@@ -1,2 +1,5 @@
 export function computeSpeed(distance: number, duration: number): number;
 export function geodesicDistance(point1: import("../types").Coordinates, point2: import("../types").Coordinates): number;
+export function computeSphericalCenter(coordinates: Array<import("../types").Coordinates>): import("../types").Coordinates;
+export function deltaLongitude(latitude: number, distance: number): number;
+export function deltaLatitude(distance: number): number;