@swimedge/metrics 1.1.2 → 1.1.4

package/dist/index.d.ts

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

package/dist/index.js

@@ -19,7 +19,7 @@ var MetricCategory;
 })(MetricCategory || (exports.MetricCategory = MetricCategory = {}));
 // Formatting helpers
 const formatNumber = (value, decimals = 2) => {
-    return Number(value).toFixed(decimals);
+    return decimals > 0 ? Number(value).toFixed(decimals) : Math.round(value).toString();
 };
 exports.formatNumber = formatNumber;
 const formatPace = (pace) => {
@@ -92,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],
@@ -103,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)',
@@ -115,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',
@@ -126,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],
@@ -136,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 },
@@ -147,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],
@@ -202,7 +202,7 @@ exports.METRICS_REGISTRY = {
         unit: 's',
         category: MetricCategory.PERFORMANCE,
         description: 'Time actively swimming',
-        icon: 'play-outline',
+        icon: 'fitness-outline',
         isPerSession: true,
         source: 'HealthKit: HKWorkoutBuilder elapsedTime (excludes rest periods)',
         healthKitSource: 'HKWorkoutBuilder.elapsedTime',
@@ -232,7 +232,7 @@ exports.METRICS_REGISTRY = {
         unit: '',
         category: MetricCategory.PERFORMANCE,
         description: 'Number of pool lengths completed during the swimming session.',
-        icon: 'layers-outline',
+        icon: 'swap-horizontal-outline',
         isPerSession: true,
         formula: 'Distance ÷ Pool Length',
         availableFrom: { watch: true, manual: true },
@@ -262,7 +262,7 @@ exports.METRICS_REGISTRY = {
         unit: 'm',
         category: MetricCategory.PERFORMANCE,
         description: 'Length of the swimming pool used for this session.',
-        icon: 'resize-outline',
+        icon: 'ruler-outline',
         isPerSession: true,
         source: 'User configuration setting',
         availableFrom: { watch: true, manual: true },
@@ -357,7 +357,7 @@ exports.METRICS_REGISTRY = {
         unit: 'kcal',
         category: MetricCategory.HEALTH,
         description: 'Total calories burned during the swimming session.',
-        icon: 'flame-outline',
+        icon: 'flash-outline',
         isPerSession: true,
         source: 'HealthKit: HKQuantityTypeIdentifierActiveEnergyBurned',
         healthKitSource: 'HKQuantityTypeIdentifierActiveEnergyBurned',
@@ -374,7 +374,7 @@ exports.METRICS_REGISTRY = {
         unit: '',
         category: MetricCategory.TECHNIQUE,
         description: 'Total number of arm strokes taken during the session.',
-        icon: 'hand-left-outline',
+        icon: 'hand-right-outline',
         isPerSession: true,
         source: 'HealthKit: HKQuantityTypeIdentifierSwimmingStrokeCount',
         healthKitSource: 'HKQuantityTypeIdentifierSwimmingStrokeCount',
@@ -421,7 +421,7 @@ exports.METRICS_REGISTRY = {
         unit: '',
         category: MetricCategory.TECHNIQUE,
         description: 'Swimming efficiency score combining time and stroke count per length.',
-        icon: 'trophy-outline',
+        icon: 'star-outline',
         isPerSession: true,
         formula: 'Average of (Lap Time in Seconds + Lap Stroke Count) for each lap',
         availableFrom: { watch: true, manual: true },
@@ -436,7 +436,7 @@ exports.METRICS_REGISTRY = {
         unit: '',
         category: MetricCategory.TECHNIQUE,
         description: 'Main swimming stroke used during this session.',
-        icon: 'hand-right-outline',
+        icon: 'hand-left-outline',
         isPerSession: true,
         source: 'HealthKit: HKWorkoutEvent with HKMetadataKeySwimmingStrokeStyle',
         healthKitSource: 'HKWorkoutEvent.metadata[HKMetadataKeySwimmingStrokeStyle]',

package/dist/index.spec.js

@@ -11,9 +11,26 @@ describe('Metrics Formatting Functions', () => {
             expect((0, index_1.formatNumber)(123.456, 0)).toBe('123');
             expect((0, index_1.formatNumber)(123.456, 3)).toBe('123.456');
         });
+        it('should round up for 0 decimals', () => {
+            expect((0, index_1.formatNumber)(19.88, 0)).toBe('20');
+            expect((0, index_1.formatNumber)(19.5, 0)).toBe('20');
+            expect((0, index_1.formatNumber)(19.4, 0)).toBe('19');
+        });
         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 +47,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 +70,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 +92,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 +112,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.2",
+  "version": "1.1.4",
   "description": "Shared metrics registry for SwimEdge (frontend, backend, watch)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,4 +52,4 @@
     "ts-jest": "^29.1.0",
     "typescript": "^5.0.0"
   }
-}
+}