@swimedge/metrics 1.1.1 → 1.1.3

package/dist/index.d.ts

@@ -53,6 +53,7 @@ export interface SwimSession {
     avgDistancePerStroke?: number;
     routeCoordinates?: number[][];
     routeMapImage?: string;
+    routeMapThumbnail?: string;
     deviceType?: string;
     osVersion?: string;
     healthKitWorkoutId?: string;

package/dist/index.js

@@ -37,7 +37,9 @@ const formatTime = (seconds) => {
     if (mins >= 60) {
         const hours = Math.floor(mins / 60);
         const remainingMins = mins % 60;
-        return `${hours}:${remainingMins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+        return `${hours}:${remainingMins.toString().padStart(2, '0')}:${secs
+            .toString()
+            .padStart(2, '0')}`;
     }
     return `${mins}:${secs.toString().padStart(2, '0')}`;
 };
@@ -90,7 +92,7 @@ exports.LAP_METRICS_REGISTRY = {
         label: 'Pace',
         unit: '/100m',
         category: MetricCategory.PERFORMANCE,
-        description: 'Time per 100m for this lap',
+        description: 'Time per 100m per lap',
         decimals: 1,
         availableFrom: { watch: true, manual: false },
         swimTypes: [SwimType.INDOOR],
@@ -101,7 +103,7 @@ exports.LAP_METRICS_REGISTRY = {
         label: 'SR',
         unit: 'SPM',
         category: MetricCategory.TECHNIQUE,
-        description: 'Strokes per minute for this lap',
+        description: 'Strokes per minute per lap',
         icon: 'repeat-outline',
         decimals: 1,
         formula: 'Lap Strokes ÷ (Lap Time in Minutes)',
@@ -113,7 +115,7 @@ exports.LAP_METRICS_REGISTRY = {
         label: 'DPS',
         unit: 'm',
         category: MetricCategory.TECHNIQUE,
-        description: 'Distance per stroke for this lap',
+        description: 'Distance per stroke per lap',
         icon: 'arrow-forward-outline',
         decimals: 2,
         formula: 'Lap Distance ÷ Lap Strokes',
@@ -124,7 +126,7 @@ exports.LAP_METRICS_REGISTRY = {
         key: 'strokeStyle',
         label: 'Stroke',
         category: MetricCategory.TECHNIQUE,
-        description: 'Swimming stroke used in this lap',
+        description: 'Swimming stroke used per lap',
         icon: 'list-outline',
         availableFrom: { watch: true, manual: false },
         swimTypes: [SwimType.INDOOR],
@@ -134,7 +136,7 @@ exports.LAP_METRICS_REGISTRY = {
         label: 'Time',
         unit: 's',
         category: MetricCategory.PERFORMANCE,
-        description: 'Time taken for this lap',
+        description: 'Time taken per lap',
         icon: 'stopwatch-outline',
         source: 'Tracked per lap completion',
         availableFrom: { watch: true, manual: false },
@@ -145,7 +147,7 @@ exports.LAP_METRICS_REGISTRY = {
         key: 'swolfScore',
         label: 'SWOLF',
         category: MetricCategory.TECHNIQUE,
-        description: 'SWOLF score for this lap',
+        description: 'SWOLF score per lap',
         decimals: 0,
         availableFrom: { watch: true, manual: false },
         swimTypes: [SwimType.INDOOR],
@@ -353,7 +355,7 @@ exports.METRICS_REGISTRY = {
         key: 'calories',
         label: 'Calories',
         unit: 'kcal',
-        category: MetricCategory.ENERGY,
+        category: MetricCategory.HEALTH,
         description: 'Total calories burned during the swimming session.',
         icon: 'flame-outline',
         isPerSession: true,
@@ -363,7 +365,7 @@ exports.METRICS_REGISTRY = {
         availableFrom: { watch: true, manual: true },
         swimTypes: [SwimType.INDOOR, SwimType.OPEN_WATER],
         hasChart: true,
-        formatter: (s) => String(s.calories),
+        formatter: (s) => s.calories,
         condition: (s) => !!s.calories,
     },
     totalStrokeCount: {
@@ -524,9 +526,11 @@ exports.METRICS_REGISTRY = {
                 2: 'Easy',
                 3: 'Moderate',
                 4: 'Hard',
-                5: 'Very Hard'
+                5: 'Very Hard',
             };
-            const effortNum = typeof s.perceivedEffort === 'string' ? parseInt(s.perceivedEffort) : s.perceivedEffort;
+            const effortNum = typeof s.perceivedEffort === 'string'
+                ? parseInt(s.perceivedEffort)
+                : s.perceivedEffort;
             return effortMap[effortNum] || 'Unknown';
         },
         condition: (s) => !!s.perceivedEffort,

package/dist/index.spec.js

@@ -14,6 +14,18 @@ describe('Metrics Formatting Functions', () => {
         it('should handle integers', () => {
             expect((0, index_1.formatNumber)(100, 2)).toBe('100.00');
         });
+        it('should handle negative numbers', () => {
+            expect((0, index_1.formatNumber)(-123.456, 2)).toBe('-123.46');
+        });
+        it('should handle zero', () => {
+            expect((0, index_1.formatNumber)(0, 2)).toBe('0.00');
+        });
+        it('should handle very small numbers', () => {
+            expect((0, index_1.formatNumber)(0.001, 3)).toBe('0.001');
+        });
+        it('should handle very large numbers', () => {
+            expect((0, index_1.formatNumber)(999999.99, 2)).toBe('999999.99');
+        });
     });
     describe('formatPace', () => {
         it('should return string pace as-is', () => {
@@ -30,12 +42,21 @@ describe('Metrics Formatting Functions', () => {
         it('should pad seconds with leading zero', () => {
             expect((0, index_1.formatPace)(125)).toBe('2:05');
         });
+        it('should handle large values', () => {
+            expect((0, index_1.formatPace)(3665)).toBe('61:05');
+        });
+        it('should handle single digit seconds', () => {
+            expect((0, index_1.formatPace)(61)).toBe('1:01');
+        });
     });
     describe('formatTime', () => {
         it('should format time in seconds to mm:ss', () => {
             expect((0, index_1.formatTime)(125)).toBe('2:05');
             expect((0, index_1.formatTime)(90)).toBe('1:30');
+        });
+        it('should format time with hours', () => {
             expect((0, index_1.formatTime)(3665)).toBe('1:01:05');
+            expect((0, index_1.formatTime)(7200)).toBe('2:00:00');
         });
         it('should handle zero', () => {
             expect((0, index_1.formatTime)(0)).toBe('0:00');
@@ -44,9 +65,18 @@ describe('Metrics Formatting Functions', () => {
             expect((0, index_1.formatTime)(65)).toBe('1:05');
             expect((0, index_1.formatTime)(5)).toBe('0:05');
         });
+        it('should pad minutes with leading zero in hour format', () => {
+            expect((0, index_1.formatTime)(3605)).toBe('1:00:05');
+        });
         it('should handle fractional seconds by flooring', () => {
             expect((0, index_1.formatTime)(65.7)).toBe('1:05');
         });
+        it('should handle exactly 60 seconds', () => {
+            expect((0, index_1.formatTime)(60)).toBe('1:00');
+        });
+        it('should handle exactly 1 hour', () => {
+            expect((0, index_1.formatTime)(3600)).toBe('1:00:00');
+        });
     });
     describe('formatHeartRate', () => {
         it('should format heart rate with bpm unit', () => {
@@ -57,6 +87,12 @@ describe('Metrics Formatting Functions', () => {
             expect((0, index_1.formatHeartRate)(145.4)).toBe('145 bpm');
             expect((0, index_1.formatHeartRate)(145.6)).toBe('146 bpm');
         });
+        it('should handle zero', () => {
+            expect((0, index_1.formatHeartRate)(0)).toBe('0 bpm');
+        });
+        it('should handle high heart rates', () => {
+            expect((0, index_1.formatHeartRate)(200)).toBe('200 bpm');
+        });
     });
     describe('formatDistance', () => {
         it('should format meters for distances under 1000m', () => {
@@ -71,5 +107,208 @@ describe('Metrics Formatting Functions', () => {
         it('should round meters to nearest integer', () => {
             expect((0, index_1.formatDistance)(500.7)).toBe('501m');
         });
+        it('should handle zero', () => {
+            expect((0, index_1.formatDistance)(0)).toBe('0m');
+        });
+        it('should handle very large distances', () => {
+            expect((0, index_1.formatDistance)(10000)).toBe('10.0km');
+        });
+    });
+    describe('formatSwimType', () => {
+        it('should format indoor pool type', () => {
+            expect((0, index_1.formatSwimType)(index_1.SwimType.INDOOR)).toBe('Indoor Pool');
+            expect((0, index_1.formatSwimType)('indoorPool')).toBe('Indoor Pool');
+        });
+        it('should format open water type', () => {
+            expect((0, index_1.formatSwimType)(index_1.SwimType.OPEN_WATER)).toBe('Open Water');
+            expect((0, index_1.formatSwimType)('openWater')).toBe('Open Water');
+        });
+        it('should handle undefined', () => {
+            expect((0, index_1.formatSwimType)(undefined)).toBe('Unknown');
+        });
+        it('should return unknown type as-is', () => {
+            expect((0, index_1.formatSwimType)('unknown')).toBe('unknown');
+        });
+    });
+});
+describe('MetricsHelper', () => {
+    describe('getMetric', () => {
+        it('should return metric definition by key', () => {
+            const metric = index_1.MetricsHelper.getMetric('distance');
+            expect(metric).toBeDefined();
+            expect(metric?.key).toBe('distance');
+            expect(metric?.label).toBe('Distance');
+        });
+        it('should return undefined for non-existent key', () => {
+            const metric = index_1.MetricsHelper.getMetric('nonexistent');
+            expect(metric).toBeUndefined();
+        });
+    });
+    describe('getSessionMetrics', () => {
+        it('should return all session metrics', () => {
+            const metrics = index_1.MetricsHelper.getSessionMetrics();
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.isPerSession)).toBe(true);
+        });
+    });
+    describe('getChartMetrics', () => {
+        it('should return only chartable metrics', () => {
+            const metrics = index_1.MetricsHelper.getChartMetrics();
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.hasChart && m.isPerSession)).toBe(true);
+        });
+    });
+    describe('getLapMetrics', () => {
+        it('should return all lap metrics', () => {
+            const metrics = index_1.MetricsHelper.getLapMetrics();
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics).toContainEqual(expect.objectContaining({ key: 'pace' }));
+        });
+    });
+    describe('getLapMetric', () => {
+        it('should return lap metric by key', () => {
+            const metric = index_1.MetricsHelper.getLapMetric('pace');
+            expect(metric).toBeDefined();
+            expect(metric.key).toBe('pace');
+            expect(metric.label).toBe('Pace');
+        });
+    });
+    describe('getMetricsByCategory', () => {
+        it('should return metrics by performance category', () => {
+            const metrics = index_1.MetricsHelper.getMetricsByCategory(index_1.MetricCategory.PERFORMANCE);
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.category === index_1.MetricCategory.PERFORMANCE)).toBe(true);
+        });
+        it('should return metrics by health category', () => {
+            const metrics = index_1.MetricsHelper.getMetricsByCategory(index_1.MetricCategory.HEALTH);
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.category === index_1.MetricCategory.HEALTH)).toBe(true);
+        });
+        it('should return metrics by technique category', () => {
+            const metrics = index_1.MetricsHelper.getMetricsByCategory(index_1.MetricCategory.TECHNIQUE);
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.category === index_1.MetricCategory.TECHNIQUE)).toBe(true);
+        });
+    });
+    describe('getMetricsBySwimType', () => {
+        it('should return indoor pool metrics', () => {
+            const metrics = index_1.MetricsHelper.getMetricsBySwimType(index_1.SwimType.INDOOR);
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.swimTypes.includes(index_1.SwimType.INDOOR))).toBe(true);
+        });
+        it('should return open water metrics', () => {
+            const metrics = index_1.MetricsHelper.getMetricsBySwimType(index_1.SwimType.OPEN_WATER);
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m.swimTypes.includes(index_1.SwimType.OPEN_WATER))).toBe(true);
+        });
+    });
+    describe('getIndoorMetrics', () => {
+        it('should return only indoor metrics', () => {
+            const metrics = index_1.MetricsHelper.getIndoorMetrics();
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m?.swimTypes?.includes(index_1.SwimType.INDOOR))).toBe(true);
+        });
+    });
+    describe('getOpenWaterMetrics', () => {
+        it('should return only open water metrics', () => {
+            const metrics = index_1.MetricsHelper.getOpenWaterMetrics();
+            expect(metrics.length).toBeGreaterThan(0);
+            expect(metrics.every(m => m?.swimTypes?.includes(index_1.SwimType.OPEN_WATER))).toBe(true);
+        });
+    });
+    describe('getAllMetricKeys', () => {
+        it('should return all metric keys', () => {
+            const keys = index_1.MetricsHelper.getAllMetricKeys();
+            expect(keys.length).toBeGreaterThan(0);
+            expect(keys).toContain('distance');
+            expect(keys).toContain('time');
+        });
+    });
+    describe('getAllLapMetricKeys', () => {
+        it('should return all lap metric keys', () => {
+            const keys = index_1.MetricsHelper.getAllLapMetricKeys();
+            expect(keys.length).toBeGreaterThan(0);
+            expect(keys).toContain('pace');
+            expect(keys).toContain('strokeCount');
+        });
+    });
+});
+describe('LAP_METRICS_REGISTRY', () => {
+    it('should have all required lap metrics', () => {
+        expect(index_1.LAP_METRICS_REGISTRY.lapNumber).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.strokeCount).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.pace).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.strokeRate).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.distancePerStroke).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.strokeStyle).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.splitTime).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.swolfScore).toBeDefined();
+    });
+    it('should have correct descriptions using "per lap"', () => {
+        expect(index_1.LAP_METRICS_REGISTRY.pace.description).toBe('Time per 100m per lap');
+        expect(index_1.LAP_METRICS_REGISTRY.strokeRate.description).toBe('Strokes per minute per lap');
+        expect(index_1.LAP_METRICS_REGISTRY.distancePerStroke.description).toBe('Distance per stroke per lap');
+        expect(index_1.LAP_METRICS_REGISTRY.splitTime.description).toBe('Time taken per lap');
+        expect(index_1.LAP_METRICS_REGISTRY.swolfScore.description).toBe('SWOLF score per lap');
+    });
+    it('should have correct categories', () => {
+        expect(index_1.LAP_METRICS_REGISTRY.pace.category).toBe(index_1.MetricCategory.PERFORMANCE);
+        expect(index_1.LAP_METRICS_REGISTRY.strokeCount.category).toBe(index_1.MetricCategory.TECHNIQUE);
+        expect(index_1.LAP_METRICS_REGISTRY.strokeRate.category).toBe(index_1.MetricCategory.TECHNIQUE);
+    });
+    it('should have correct swim types', () => {
+        expect(index_1.LAP_METRICS_REGISTRY.pace.swimTypes).toEqual([index_1.SwimType.INDOOR]);
+        expect(index_1.LAP_METRICS_REGISTRY.strokeCount.swimTypes).toEqual([index_1.SwimType.INDOOR]);
+    });
+    it('should have lap formatters where needed', () => {
+        expect(index_1.LAP_METRICS_REGISTRY.pace.lapFormatter).toBeDefined();
+        expect(index_1.LAP_METRICS_REGISTRY.splitTime.lapFormatter).toBeDefined();
+    });
+});
+describe('METRICS_REGISTRY', () => {
+    it('should have all core session metrics', () => {
+        expect(index_1.METRICS_REGISTRY.distance).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.time).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.activeTime).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.restTime).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.laps).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgPace).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.calories).toBeDefined();
+    });
+    it('should have all heart rate metrics', () => {
+        expect(index_1.METRICS_REGISTRY.avgHeartRate).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.maxHeartRate).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.minHeartRate).toBeDefined();
+    });
+    it('should have all stroke metrics', () => {
+        expect(index_1.METRICS_REGISTRY.totalStrokeCount).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgStrokeRate).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgDistancePerStroke).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgSwolfScore).toBeDefined();
+    });
+    it('should have correct HealthKit sources', () => {
+        expect(index_1.METRICS_REGISTRY.distance?.isHealthKit).toBe(true);
+        expect(index_1.METRICS_REGISTRY.avgHeartRate?.isHealthKit).toBe(true);
+        expect(index_1.METRICS_REGISTRY.totalStrokeCount?.isHealthKit).toBe(true);
+    });
+    it('should have correct swim type availability', () => {
+        expect(index_1.METRICS_REGISTRY.laps?.swimTypes).toEqual([index_1.SwimType.INDOOR]);
+        expect(index_1.METRICS_REGISTRY.avgSwolfScore?.swimTypes).toEqual([index_1.SwimType.INDOOR]);
+        expect(index_1.METRICS_REGISTRY.distance?.swimTypes).toEqual([index_1.SwimType.INDOOR, index_1.SwimType.OPEN_WATER]);
+    });
+    it('should have formatters for display metrics', () => {
+        expect(index_1.METRICS_REGISTRY.distance?.formatter).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.time?.formatter).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgHeartRate?.formatter).toBeDefined();
+    });
+    it('should have conditions for optional metrics', () => {
+        expect(index_1.METRICS_REGISTRY.restTime?.condition).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.avgSwolfScore?.condition).toBeDefined();
+        expect(index_1.METRICS_REGISTRY.waterTemp?.condition).toBeDefined();
+    });
+    it('should mark chartable metrics correctly', () => {
+        expect(index_1.METRICS_REGISTRY.distance?.hasChart).toBe(true);
+        expect(index_1.METRICS_REGISTRY.time?.hasChart).toBe(true);
+        expect(index_1.METRICS_REGISTRY.avgPace?.hasChart).toBe(true);
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimedge/metrics",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Shared metrics registry for SwimEdge (frontend, backend, watch)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",