hoffmation-base 2.17.0 → 2.17.1

package/lib/server/devices/espresense/espresenseDevice.d.ts

@@ -14,7 +14,7 @@ export declare class EspresenseDevice implements iRoomDevice, iBluetoothDetector
     deviceType: DeviceType;
     readonly name: string;
     private deviceMap;
-    private proximityCallback;
+    private proximityCallbackMap;
     constructor(name: string, roomName: string, x: number, y: number, z: number);
     get customName(): string;
     protected _info: DeviceInfo;

package/lib/server/devices/espresense/espresenseDevice.js

@@ -17,7 +17,7 @@ class EspresenseDevice {
         this.deviceCapabilities = [DeviceCapability_1.DeviceCapability.bluetoothDetector];
         this.deviceType = deviceType_1.DeviceType.Espresense;
         this.deviceMap = new Map();
-        this.proximityCallback = new Map();
+        this.proximityCallbackMap = new Map();
         this.position = new trilaterationBasePoint_1.TrilaterationBasePoint(x, y, z, roomName);
         this.name = name;
         this._info = new DeviceInfo_1.DeviceInfo();
@@ -77,7 +77,7 @@ class EspresenseDevice {
         }
         dev.updateDistance(this, data.distance);
         dev.guessRoom();
-        const cbs = this.proximityCallback.get(dev.name);
+        const cbs = this.proximityCallbackMap.get(dev.name);
         if (cbs === undefined) {
             return;
         }
@@ -125,12 +125,12 @@ class EspresenseDevice {
         // Nothing
     }
     addProximityCallback(cb) {
-        let currentValue = this.proximityCallback.get(cb.deviceName);
+        let currentValue = this.proximityCallbackMap.get(cb.deviceName);
         if (currentValue == undefined) {
             currentValue = [];
         }
         currentValue.push(cb);
-        this.proximityCallback.set(cb.deviceName, currentValue);
+        this.proximityCallbackMap.set(cb.deviceName, currentValue);
     }
     addDeviceTracking(devName) {
         const dev = detectedBluetoothDevice_1.DetectedBluetoothDevice.getOrCreate(devName);

package/lib/server/devices/espresense/trilateration.js

@@ -35,7 +35,7 @@ class Trilateration {
         return bestMatches;
     }
     static getBestRatedCoordinates(distances) {
-        const allRatedCoordinates = new Map();
+        const allRatedCoordinatesMap = new Map();
         for (const dist of distances) {
             const point = this.basePoints.find((basePoint) => basePoint.ownPoint.coordinateName === dist.pointName);
             if (point === undefined) {
@@ -49,16 +49,16 @@ class Trilateration {
             const ratedCoordinates = point.getRatedCoordinates(dist.distance);
             services_1.ServerLogService.writeLog(models_1.LogLevel.Debug, `Found ${ratedCoordinates.length} rated coordinates for ${dist.pointName} within distance of ${dist.distance}m`, { debugType: services_1.LogDebugType.Trilateration });
             for (const ratedCoordinate of ratedCoordinates) {
-                const existingCoordinate = allRatedCoordinates.get(ratedCoordinate.coordinateName);
+                const existingCoordinate = allRatedCoordinatesMap.get(ratedCoordinate.coordinateName);
                 if (existingCoordinate === undefined) {
-                    allRatedCoordinates.set(ratedCoordinate.coordinateName, ratedCoordinate);
+                    allRatedCoordinatesMap.set(ratedCoordinate.coordinateName, ratedCoordinate);
                     continue;
                 }
                 existingCoordinate.rating += ratedCoordinate.rating;
                 existingCoordinate.matchCount++;
             }
         }
-        return this.getBestRatedCoordinatesFromMap(allRatedCoordinates);
+        return this.getBestRatedCoordinatesFromMap(allRatedCoordinatesMap);
     }
     static checkRoom(distances) {
         var _a;
@@ -71,13 +71,13 @@ class Trilateration {
             return bestMatches[0].roomName;
         }
         // As we have multiple possible winners, we need to check how often which room occurs
-        const roomCount = new Map();
+        const roomCountMap = new Map();
         for (const point of bestMatches) {
             const room = point.roomName;
-            const existingCount = (_a = roomCount.get(room)) !== null && _a !== void 0 ? _a : 0;
-            roomCount.set(room, existingCount + 1);
+            const existingCount = (_a = roomCountMap.get(room)) !== null && _a !== void 0 ? _a : 0;
+            roomCountMap.set(room, existingCount + 1);
         }
-        return Array.from(roomCount.entries()).sort((a, b) => b[1] - a[1])[0][0];
+        return Array.from(roomCountMap.entries()).sort((a, b) => b[1] - a[1])[0][0];
     }
     static getBestRatedCoordinatesFromMap(allRatedCoordinates) {
         const sortedCoordinates = Array.from(allRatedCoordinates.values()).sort((a, b) => {

package/lib/server/devices/espresense/trilaterationBasePoint.d.ts

@@ -7,7 +7,7 @@ export declare class TrilaterationBasePoint {
     readonly roomName: string;
     private readonly _maximumDistance;
     readonly ownPoint: TrilaterationPoint;
-    readonly precalculatedDistances: Map<number, string[]>;
+    readonly precalculatedDistancesMap: Map<number, string[]>;
     constructor(x: number, y: number, z: number, roomName: string, _maximumDistance?: number);
     getRatedCoordinates(distance: number): TrilaterationRatedCoordinate[];
     private rateCoordinates;

package/lib/server/devices/espresense/trilaterationBasePoint.js

@@ -12,7 +12,7 @@ class TrilaterationBasePoint {
         this.z = z;
         this.roomName = roomName;
         this._maximumDistance = _maximumDistance;
-        this.precalculatedDistances = new Map();
+        this.precalculatedDistancesMap = new Map();
         this.ownPoint = new trilaterationPoint_1.TrilaterationPoint(x, y, z, roomName);
     }
     getRatedCoordinates(distance) {
@@ -28,7 +28,7 @@ class TrilaterationBasePoint {
         return result;
     }
     rateCoordinates(distance, result, rating) {
-        const possiblePoints = this.precalculatedDistances.get(distance);
+        const possiblePoints = this.precalculatedDistancesMap.get(distance);
         if (possiblePoints !== undefined) {
             for (const point of possiblePoints) {
                 result.push(new trilaterationRatedCoordinate_1.TrilaterationRatedCoordinate(point, rating));
@@ -44,9 +44,9 @@ class TrilaterationBasePoint {
                 continue;
             }
             count++;
-            const distancePoints = (_a = this.precalculatedDistances.get(distance)) !== null && _a !== void 0 ? _a : [];
+            const distancePoints = (_a = this.precalculatedDistancesMap.get(distance)) !== null && _a !== void 0 ? _a : [];
             distancePoints.push(point.coordinateName);
-            this.precalculatedDistances.set(distance, distancePoints);
+            this.precalculatedDistancesMap.set(distance, distancePoints);
         }
         services_1.ServerLogService.writeLog(models_1.LogLevel.Info, `Filled ${count} distances for Trilateration in room: ${this.roomName}`);
     }

package/lib/server/services/utils/utils.js

@@ -185,6 +185,10 @@ class Utils {
                     const newKey = lowerKey.replace('map', 'dict');
                     const dict = {};
                     const map = value;
+                    if (typeof map.keys !== 'function') {
+                        log_service_1.ServerLogService.writeLog(models_1.LogLevel.Error, `Map ${currentKey}.${lowerKey} is not a map`);
+                        return;
+                    }
                     for (const mapName of map.keys()) {
                         dict[mapName] = lodash_1.default.isObject(map.get(mapName))
                             ? this.deepOmit(map.get(mapName), keysToOmit, level + 1, `${currentKey}.${lowerKey}.${mapName}`)