@swimedge/metrics 1.0.5 → 1.0.6

package/dist/index.d.ts

@@ -6,19 +6,17 @@ export declare enum SwimType {
     INDOOR = "indoorPool",
     OPEN_WATER = "openWater"
 }
-export interface SwimSessionLaps {
-    lapSplitTimes?: number[];
-    lapStrokeTypes?: string[];
-    lapHeartRates?: number[];
-    lapStrokeCounts?: number[];
-    lapPaces?: number[];
-    lapCalories?: number[];
-    lapDistances?: number[];
-    lapSwolfScores?: number[];
-    lapStrokeRates?: number[];
-    lapDistancesPerStroke?: number[];
+export interface SwimLap {
+    strokeCount?: number;
+    pace?: number;
+    strokeRate?: number;
+    distancePerStroke?: number;
+    strokeStyle?: string;
+    splitTime?: number;
+    swolfScore?: number;
+    calories?: number;
 }
-export interface SwimSession extends SwimSessionLaps {
+export interface SwimSession {
     id: string;
     watchSessionId?: string;
     date: string;
@@ -57,6 +55,7 @@ export interface SwimSession extends SwimSessionLaps {
     deviceType?: string;
     osVersion?: string;
     healthKitWorkoutId?: string;
+    lapData?: SwimLap[];
 }
 export interface AggregatedSwimMetrics {
     totalDistance: number;
@@ -105,7 +104,6 @@ export interface MetricDefinition {
     description: string;
     icon?: string;
     isPerSession?: boolean;
-    isPerLap?: boolean;
     formula?: string;
     source?: string;
     healthKitSource?: string;
@@ -118,18 +116,39 @@ export interface MetricDefinition {
     swimTypes: SwimType[];
     hasChart?: boolean;
     formatter?: (session: SwimSession) => string | number | null;
-    lapFormatter?: (value: any) => string;
     condition?: (session: SwimSession) => boolean;
 }
-export declare const METRICS_REGISTRY: Record<keyof SwimSession, MetricDefinition>;
+export interface LapMetricDefinition {
+    key: keyof SwimLap;
+    label: string;
+    unit?: string;
+    category: MetricCategory;
+    description: string;
+    icon?: string;
+    formula?: string;
+    source?: string;
+    healthKitSource?: string;
+    isHealthKit?: boolean;
+    decimals?: number;
+    availableFrom: {
+        watch: boolean;
+        manual: boolean;
+    };
+    swimTypes: SwimType[];
+    lapFormatter?: (value: any) => string;
+}
+export declare const LAP_METRICS_REGISTRY: Record<keyof SwimLap, LapMetricDefinition>;
+export declare const METRICS_REGISTRY: Partial<Record<keyof SwimSession, MetricDefinition>>;
 export declare const MetricsHelper: {
-    getMetric: (key: keyof SwimSession) => MetricDefinition;
+    getMetric: (key: keyof SwimSession) => MetricDefinition | undefined;
     getSessionMetrics: () => MetricDefinition[];
     getChartMetrics: () => MetricDefinition[];
-    getLapMetrics: () => MetricDefinition[];
+    getLapMetrics: () => LapMetricDefinition[];
+    getLapMetric: (key: keyof SwimLap) => LapMetricDefinition;
     getMetricsByCategory: (category: MetricCategory) => MetricDefinition[];
     getMetricsBySwimType: (swimType: SwimType) => MetricDefinition[];
     getIndoorMetrics: () => MetricDefinition[];
     getOpenWaterMetrics: () => MetricDefinition[];
     getAllMetricKeys: () => string[];
+    getAllLapMetricKeys: () => string[];
 };

package/dist/index.js

@@ -4,7 +4,7 @@
  * Shared metrics registry for frontend, backend, and watch app
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetricsHelper = exports.METRICS_REGISTRY = exports.formatSwimType = exports.formatDistance = exports.formatHeartRate = exports.formatTime = exports.formatPace = exports.formatNumber = exports.MetricCategory = exports.SwimType = void 0;
+exports.MetricsHelper = exports.METRICS_REGISTRY = exports.LAP_METRICS_REGISTRY = exports.formatSwimType = exports.formatDistance = exports.formatHeartRate = exports.formatTime = exports.formatPace = exports.formatNumber = exports.MetricCategory = exports.SwimType = void 0;
 var SwimType;
 (function (SwimType) {
     SwimType["INDOOR"] = "indoorPool";
@@ -31,12 +31,13 @@ const formatPace = (pace) => {
 };
 exports.formatPace = formatPace;
 const formatTime = (seconds) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
+    const totalSeconds = Math.floor(seconds);
+    const mins = Math.floor(totalSeconds / 60);
+    const secs = totalSeconds % 60;
     if (mins >= 60) {
         const hours = Math.floor(mins / 60);
         const remainingMins = mins % 60;
-        return `${hours}:${remainingMins.toString().padStart(2, '0')}`;
+        return `${hours}:${remainingMins.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
     }
     return `${mins}:${secs.toString().padStart(2, '0')}`;
 };
@@ -60,6 +61,97 @@ const formatSwimType = (swimType) => {
     }[swimType] || swimType);
 };
 exports.formatSwimType = formatSwimType;
+exports.LAP_METRICS_REGISTRY = {
+    strokeCount: {
+        key: 'strokeCount',
+        label: 'Strokes',
+        unit: '',
+        category: MetricCategory.TECHNIQUE,
+        description: 'Number of strokes in this lap',
+        icon: 'hand-left-outline',
+        decimals: 0,
+        source: 'HealthKit: HKQuantityTypeIdentifierSwimmingStrokeCount per lap',
+        healthKitSource: 'HKQuantityTypeIdentifierSwimmingStrokeCount',
+        isHealthKit: true,
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+    pace: {
+        key: 'pace',
+        label: 'Pace',
+        unit: '/100m',
+        category: MetricCategory.PERFORMANCE,
+        description: 'Time per 100m for this lap',
+        decimals: 1,
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+        lapFormatter: (v) => (0, exports.formatPace)(v),
+    },
+    strokeRate: {
+        key: 'strokeRate',
+        label: 'SR',
+        unit: 'SPM',
+        category: MetricCategory.TECHNIQUE,
+        description: 'Strokes per minute for this lap',
+        icon: 'repeat-outline',
+        decimals: 1,
+        formula: 'Lap Strokes ÷ (Lap Time in Minutes)',
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+    distancePerStroke: {
+        key: 'distancePerStroke',
+        label: 'DPS',
+        unit: 'm',
+        category: MetricCategory.TECHNIQUE,
+        description: 'Distance per stroke for this lap',
+        icon: 'arrow-forward-outline',
+        decimals: 2,
+        formula: 'Lap Distance ÷ Lap Strokes',
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+    strokeStyle: {
+        key: 'strokeStyle',
+        label: 'Stroke',
+        category: MetricCategory.TECHNIQUE,
+        description: 'Swimming stroke used in this lap',
+        icon: 'list-outline',
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+    splitTime: {
+        key: 'splitTime',
+        label: 'Time',
+        unit: 's',
+        category: MetricCategory.PERFORMANCE,
+        description: 'Time taken for this lap',
+        icon: 'stopwatch-outline',
+        source: 'Tracked per lap completion',
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+        lapFormatter: (v) => (0, exports.formatTime)(v),
+    },
+    swolfScore: {
+        key: 'swolfScore',
+        label: 'SWOLF',
+        category: MetricCategory.TECHNIQUE,
+        description: 'SWOLF score for this lap',
+        decimals: 0,
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+    calories: {
+        key: 'calories',
+        label: 'Cal',
+        unit: 'kcal',
+        category: MetricCategory.ENERGY,
+        description: 'Calories burned in this lap',
+        decimals: 0,
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+    },
+};
 exports.METRICS_REGISTRY = {
     distance: {
         key: 'distance',
@@ -135,7 +227,6 @@ exports.METRICS_REGISTRY = {
         availableFrom: { watch: true, manual: true },
         swimTypes: [SwimType.INDOOR],
         hasChart: true,
-        formatter: (s) => String(s.laps),
         condition: (s) => !!s.laps,
     },
     avgPace: {
@@ -343,51 +434,6 @@ exports.METRICS_REGISTRY = {
         formatter: (s) => s.primaryStrokeType,
         condition: (s) => !!s.primaryStrokeType,
     },
-    lapSplitTimes: {
-        key: 'lapSplitTimes',
-        label: 'Time',
-        unit: 's',
-        category: MetricCategory.PERFORMANCE,
-        description: 'Individual lap times recorded during the session.',
-        icon: 'stopwatch-outline',
-        isPerLap: true,
-        source: 'Tracked per lap completion',
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-        formatter: (s) => `${s.lapSplitTimes.length} splits`,
-        lapFormatter: (v) => (0, exports.formatTime)(v),
-        condition: (s) => !!s.lapSplitTimes?.length,
-    },
-    lapHeartRates: {
-        key: 'lapHeartRates',
-        label: 'HR',
-        unit: 'bpm',
-        category: MetricCategory.HEALTH,
-        description: 'HR per lap',
-        icon: 'heart-outline',
-        isPerLap: true,
-        decimals: 0,
-        source: 'HealthKit: HKQuantityTypeIdentifierHeartRate sampled at lap completion',
-        healthKitSource: 'HKQuantityTypeIdentifierHeartRate',
-        isHealthKit: true,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapStrokeCounts: {
-        key: 'lapStrokeCounts',
-        label: 'Strokes',
-        unit: '',
-        category: MetricCategory.TECHNIQUE,
-        description: 'Strokes per lap',
-        icon: 'hand-left-outline',
-        isPerLap: true,
-        decimals: 0,
-        source: 'HealthKit: HKQuantityTypeIdentifierSwimmingStrokeCount per lap',
-        healthKitSource: 'HKQuantityTypeIdentifierSwimmingStrokeCount',
-        isHealthKit: true,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
     id: {
         key: 'id',
         label: 'ID',
@@ -424,101 +470,6 @@ exports.METRICS_REGISTRY = {
         availableFrom: { watch: false, manual: false },
         swimTypes: [SwimType.INDOOR, SwimType.OPEN_WATER],
     },
-    // HealthKit doesn't track turn times
-    /*lapTurnTimes: {
-      key: 'lapTurnTimes',
-      label: 'Turn',
-      unit: 's',
-      category: MetricCategory.TECHNIQUE,
-      description: 'Time spent turning at pool wall per lap',
-      icon: 'refresh-circle-outline',
-      isPerLap: true,
-      decimals: 2,
-      availableFrom: { watch: true, manual: false },
-      swimTypes: [SwimType.INDOOR],
-      formatter: formatAverageTurnTime,
-      condition: (s) => !!s.lapTurnTimes?.length,
-    },*/
-    lapStrokeTypes: {
-        key: 'lapStrokeTypes',
-        label: 'Stroke',
-        category: MetricCategory.TECHNIQUE,
-        description: 'Swimming stroke used per lap',
-        icon: 'list-outline',
-        isPerLap: true,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-        formatter: (s) => `${s.lapStrokeTypes.length} types`,
-        condition: (s) => !!s.lapStrokeTypes?.length,
-    },
-    lapPaces: {
-        key: 'lapPaces',
-        label: 'Pace',
-        unit: '/100m',
-        category: MetricCategory.PERFORMANCE,
-        description: 'Pace per lap',
-        isPerLap: true,
-        decimals: 1,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapCalories: {
-        key: 'lapCalories',
-        label: 'Cal',
-        unit: 'kcal',
-        category: MetricCategory.ENERGY,
-        description: 'Calories per lap',
-        isPerLap: true,
-        decimals: 0,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapDistances: {
-        key: 'lapDistances',
-        label: 'Lap Distances',
-        unit: 'm',
-        category: MetricCategory.PERFORMANCE,
-        description: 'Distance per lap',
-        isPerLap: true,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapSwolfScores: {
-        key: 'lapSwolfScores',
-        label: 'SWOLF',
-        category: MetricCategory.TECHNIQUE,
-        description: 'SWOLF per lap',
-        isPerLap: true,
-        decimals: 0,
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapStrokeRates: {
-        key: 'lapStrokeRates',
-        label: 'SR',
-        unit: 'SPM',
-        category: MetricCategory.TECHNIQUE,
-        description: 'Strokes per minute per lap',
-        icon: 'repeat-outline',
-        isPerLap: true,
-        decimals: 1,
-        formula: 'Lap Strokes ÷ (Lap Time in Minutes)',
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
-    lapDistancesPerStroke: {
-        key: 'lapDistancesPerStroke',
-        label: 'DPS',
-        unit: 'm',
-        category: MetricCategory.TECHNIQUE,
-        description: 'Distance covered per stroke per lap',
-        icon: 'arrow-forward-outline',
-        isPerLap: true,
-        decimals: 2,
-        formula: 'Lap Distance ÷ Lap Strokes',
-        availableFrom: { watch: true, manual: false },
-        swimTypes: [SwimType.INDOOR],
-    },
     poolLocation: {
         key: 'poolLocation',
         label: 'Pool Location',
@@ -612,15 +563,27 @@ exports.METRICS_REGISTRY = {
         availableFrom: { watch: true, manual: false },
         swimTypes: [SwimType.INDOOR, SwimType.OPEN_WATER],
     },
+    lapData: {
+        key: 'lapData',
+        label: 'Lap Data',
+        category: MetricCategory.PERFORMANCE,
+        description: 'Detailed data for each lap',
+        isPerSession: true,
+        availableFrom: { watch: true, manual: false },
+        swimTypes: [SwimType.INDOOR],
+        condition: (s) => !!s.lapData?.length,
+    },
 };
 exports.MetricsHelper = {
     getMetric: (key) => exports.METRICS_REGISTRY[key],
-    getSessionMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m.isPerSession),
-    getChartMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m.isPerSession && m.hasChart),
-    getLapMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m.isPerLap),
-    getMetricsByCategory: (category) => Object.values(exports.METRICS_REGISTRY).filter((m) => m.category === category),
-    getMetricsBySwimType: (swimType) => Object.values(exports.METRICS_REGISTRY).filter((m) => m.swimTypes?.includes(swimType)),
-    getIndoorMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m.swimTypes?.includes(SwimType.INDOOR)),
-    getOpenWaterMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m.swimTypes?.includes(SwimType.OPEN_WATER)),
+    getSessionMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.isPerSession),
+    getChartMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.isPerSession && m?.hasChart),
+    getLapMetrics: () => Object.values(exports.LAP_METRICS_REGISTRY),
+    getLapMetric: (key) => exports.LAP_METRICS_REGISTRY[key],
+    getMetricsByCategory: (category) => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.category === category),
+    getMetricsBySwimType: (swimType) => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.swimTypes?.includes(swimType)),
+    getIndoorMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.swimTypes?.includes(SwimType.INDOOR)),
+    getOpenWaterMetrics: () => Object.values(exports.METRICS_REGISTRY).filter((m) => m?.swimTypes?.includes(SwimType.OPEN_WATER)),
     getAllMetricKeys: () => Object.keys(exports.METRICS_REGISTRY),
+    getAllLapMetricKeys: () => Object.keys(exports.LAP_METRICS_REGISTRY),
 };

package/dist/index.spec.js

@@ -35,7 +35,7 @@ describe('Metrics Formatting Functions', () => {
         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');
-            expect((0, index_1.formatTime)(3665)).toBe('61:05');
+            expect((0, index_1.formatTime)(3665)).toBe('1:01:05');
         });
         it('should handle zero', () => {
             expect((0, index_1.formatTime)(0)).toBe('0:00');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swimedge/metrics",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "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"
   }
-}
+}