cozy-client 41.3.0 → 41.4.1

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.3.0";
+CozyClient.version = "41.4.1";
 
 _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

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.geodesicDistance = exports.computeSpeed = void 0;
+
+/**
+ * Compute the speed from distance and duration
+ *
+ * @param {number} distance - The distance in meters
+ * @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;
+  }
+
+  return Math.round(distance / duration * 100) / 100;
+};
+
+exports.computeSpeed = computeSpeed;
+
+var degreesToRadians = function degreesToRadians(degrees) {
+  return degrees * Math.PI / 180;
+};
+/**
+ * Compute the distance between 2 geographic points, in meters.
+ *
+ * This is an implementation of the Haversine formula, that
+ * supposes a perfect sphere. We know this is not exactly the case
+ * for Earth, especially at the poles, but this approximation is good enough.
+ * More complex methods do exist, such as Vincenty formula, but we prefer
+ * simplicity over precision here.
+ * See https://en.wikipedia.org/wiki/Geodesics_on_an_ellipsoid
+ *
+ * @param {import("../types").Coordinates} point1 - The first point coordinates, in decimal degrees
+ * @param {import("../types").Coordinates} point2 - The second point coordinates, in decimal degrees
+ * @returns {number} The distance between the points, in meters, rounded to 2 decimals
+ */
+
+
+var geodesicDistance = function geodesicDistance(point1, point2) {
+  if ((point1 === null || point1 === void 0 ? void 0 : point1.lon) === undefined || (point1 === null || point1 === void 0 ? void 0 : point1.lat) === undefined || (point2 === null || point2 === void 0 ? void 0 : point2.lon) === undefined || (point2 === null || point2 === void 0 ? void 0 : point2.lat) === undefined) {
+    return null;
+  }
+
+  var lon1 = degreesToRadians(point1.lon);
+  var lat1 = degreesToRadians(point1.lat);
+  var lon2 = degreesToRadians(point2.lon);
+  var lat2 = degreesToRadians(point2.lat);
+  var diffLon = lon2 - lon1;
+  var diffLat = lat2 - lat1;
+  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 distance = 6371 * 1000 * c;
+  return Math.round(distance * 100) / 100;
+};
+
+exports.geodesicDistance = geodesicDistance;

package/dist/models/geo.spec.js

@@ -0,0 +1,32 @@
+const { geodesicDistance, computeSpeed } = require('./geo')
+
+describe('geodesicDistance', () => {
+  it('should return 0 for 2 points with same coordinates', () => {
+    const p1 = { lat: 0.0, lon: 0.0 }
+    const p2 = { lat: 0.0, lon: 0.0 }
+    expect(geodesicDistance(p1, p2)).toEqual(0)
+  })
+
+  it('should return null when points are not properly formatted', () => {
+    expect(geodesicDistance(null, null)).toEqual(null)
+    expect(geodesicDistance({ lat: 1.0 }, { lon: 5.6 })).toEqual(null)
+  })
+
+  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)
+  })
+})
+
+describe('speed', () => {
+  it('should return 0 when the speed or distance is not set or 0', () => {
+    expect(computeSpeed(0, 0)).toEqual(0)
+    expect(computeSpeed(10, 0)).toEqual(0)
+    expect(computeSpeed(0, 10)).toEqual(0)
+    expect(computeSpeed()).toEqual(0)
+  })
+  it('should return the correct running speed of the developer', () => {
+    expect(computeSpeed(10000, 1800)).toEqual(5.56)
+  })
+})

package/dist/types.js

@@ -493,6 +493,12 @@ var _dsl = require("./queries/dsl");
  *
  */
 
+/**
+ * @typedef {object} Coordinates
+ * @property {number} lat - The latitude, in decimal degrees
+ * @property {number} lon - The longitude, in decimal degrees
+ */
+
 /**
  * Receives the URL to present to the user as a parameter, and should return a promise that resolves with the URL the user was redirected to after accepting the permissions.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cozy-client",
-  "version": "41.3.0",
+  "version": "41.4.1",
   "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": "b69af4c4c28456f2d24e3dffa19f7921cb489e4e"
+  "gitHead": "973c0aa500d04e1463b5a7a9f4f3d5a8d80e2bd9"
 }

package/types/models/geo.d.ts

@@ -0,0 +1,2 @@
+export function computeSpeed(distance: number, duration: number): number;
+export function geodesicDistance(point1: import("../types").Coordinates, point2: import("../types").Coordinates): number;

package/types/types.d.ts

@@ -824,6 +824,16 @@ export type DACCAggregate = {
      */
     std: number;
 };
+export type Coordinates = {
+    /**
+     * - The latitude, in decimal degrees
+     */
+    lat: number;
+    /**
+     * - The longitude, in decimal degrees
+     */
+    lon: number;
+};
 /**
  * Receives the URL to present to the user as a parameter, and should return a promise that resolves with the URL the user was redirected to after accepting the permissions.
  */