@openlifelog/sdk 1.0.1 → 1.0.3

package/utils/units.ts

@@ -13,6 +13,8 @@ const METERS_TO_FEET = 3.28084;
 const FEET_TO_METERS = 1 / METERS_TO_FEET;
 const CM_TO_INCHES = 0.393701;
 const INCHES_TO_CM = 1 / CM_TO_INCHES;
+const ML_TO_FL_OZ = 0.033814;
+const FL_OZ_TO_ML = 1 / ML_TO_FL_OZ;
 
 /**
  * Weight conversion
@@ -167,6 +169,45 @@ export class HeightConverter {
   }
 }
 
+/**
+ * Volume conversion
+ */
+export class VolumeConverter {
+  /**
+   * Convert milliliters to fluid ounces
+   */
+  static mlToFlOz(ml: number): number {
+    return ml * ML_TO_FL_OZ;
+  }
+
+  /**
+   * Convert fluid ounces to milliliters
+   */
+  static flOzToMl(flOz: number): number {
+    return flOz * FL_OZ_TO_ML;
+  }
+
+  /**
+   * Convert volume from metric to the target measurement system
+   */
+  static fromMetric(ml: number, targetSystem: MeasurementSystem): number {
+    if (targetSystem === 'imperial') {
+      return this.mlToFlOz(ml);
+    }
+    return ml;
+  }
+
+  /**
+   * Convert volume to metric from the source measurement system
+   */
+  static toMetric(value: number, sourceSystem: MeasurementSystem): number {
+    if (sourceSystem === 'imperial') {
+      return this.flOzToMl(value);
+    }
+    return value;
+  }
+}
+
 /**
  * Generic unit converter that handles all conversions
  */
@@ -277,3 +318,319 @@ export class UnitConverter {
 export function createUnitConverter(measurementSystem: MeasurementSystem = 'metric'): UnitConverter {
   return new UnitConverter(measurementSystem);
 }
+
+/**
+ * Deep conversion utilities for nested workout data structures
+ */
+
+/**
+ * Convert a single SetData object from user units to metric (for API requests)
+ */
+export function convertSetDataToMetric(
+  setData: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!setData || typeof setData !== 'object') {
+    return setData;
+  }
+
+  const converted = { ...setData };
+
+  // Convert weight (lbs → kg)
+  if (converted.weight !== null && converted.weight !== undefined) {
+    converted.weight = WeightConverter.toMetric(converted.weight, measurementSystem);
+  }
+
+  // Convert distance (feet/miles → meters)
+  if (converted.distance !== null && converted.distance !== undefined) {
+    // Determine if this is miles (cardio, longer distances) or feet based on value
+    // This is a heuristic: distances > 200 are likely in feet (for imperial), so treat as feet
+    // Distances <= 200 could be miles for cardio workouts
+    const isMiles = measurementSystem === 'imperial' && converted.distance <= 200;
+    converted.distance = DistanceConverter.toMetric(converted.distance, measurementSystem, isMiles);
+  }
+
+  return converted;
+}
+
+/**
+ * Convert a single SetData object from metric to user units (for API responses)
+ */
+export function convertSetDataFromMetric(
+  setData: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!setData || typeof setData !== 'object') {
+    return setData;
+  }
+
+  const converted = { ...setData };
+
+  // Convert weight (kg → lbs)
+  if (converted.weight !== null && converted.weight !== undefined) {
+    converted.weight = WeightConverter.fromMetric(converted.weight, measurementSystem);
+  }
+
+  // Convert distance (meters → feet/miles)
+  if (converted.distance !== null && converted.distance !== undefined) {
+    // For imperial: convert to miles if > 1609 meters (1 mile), otherwise feet
+    const preferMiles = measurementSystem === 'imperial' && converted.distance > 1609;
+    converted.distance = DistanceConverter.fromMetric(converted.distance, measurementSystem, preferMiles);
+  }
+
+  return converted;
+}
+
+/**
+ * Convert an array of SetData objects to metric (for API requests)
+ */
+export function convertSetsDataToMetric(
+  setsData: any[] | null | undefined,
+  measurementSystem: MeasurementSystem
+): any[] {
+  if (!setsData || !Array.isArray(setsData)) {
+    return setsData || [];
+  }
+
+  return setsData.map(setData => convertSetDataToMetric(setData, measurementSystem));
+}
+
+/**
+ * Convert an array of SetData objects from metric (for API responses)
+ */
+export function convertSetsDataFromMetric(
+  setsData: any[] | null | undefined,
+  measurementSystem: MeasurementSystem
+): any[] {
+  if (!setsData || !Array.isArray(setsData)) {
+    return setsData || [];
+  }
+
+  return setsData.map(setData => convertSetDataFromMetric(setData, measurementSystem));
+}
+
+/**
+ * Deep convert workout data structure to metric (for API requests)
+ * Handles nested setsData arrays in various structures
+ */
+export function convertWorkoutDataToMetric(
+  data: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    return data.map(item => convertWorkoutDataToMetric(item, measurementSystem));
+  }
+
+  const converted = { ...data };
+
+  // Convert setsData arrays
+  if (converted.setsData && Array.isArray(converted.setsData)) {
+    converted.setsData = convertSetsDataToMetric(converted.setsData, measurementSystem);
+  }
+
+  // Convert sets arrays (used in program schedules)
+  if (converted.sets && Array.isArray(converted.sets)) {
+    converted.sets = convertSetsDataToMetric(converted.sets, measurementSystem);
+  }
+
+  // Convert exercises arrays (nested structures)
+  if (converted.exercises && Array.isArray(converted.exercises)) {
+    converted.exercises = converted.exercises.map((exercise: any) =>
+      convertWorkoutDataToMetric(exercise, measurementSystem)
+    );
+  }
+
+  // Convert schedule arrays (for programs)
+  if (converted.schedule && Array.isArray(converted.schedule)) {
+    converted.schedule = converted.schedule.map((day: any) =>
+      convertWorkoutDataToMetric(day, measurementSystem)
+    );
+  }
+
+  // Convert individual numeric fields at top level
+  if (converted.userBodyweight !== null && converted.userBodyweight !== undefined) {
+    converted.userBodyweight = WeightConverter.toMetric(converted.userBodyweight, measurementSystem);
+  }
+
+  if (converted.totalVolume !== null && converted.totalVolume !== undefined) {
+    converted.totalVolume = WeightConverter.toMetric(converted.totalVolume, measurementSystem);
+  }
+
+  if (converted.totalDistance !== null && converted.totalDistance !== undefined) {
+    const preferMiles = measurementSystem === 'imperial' && converted.totalDistance <= 200;
+    converted.totalDistance = DistanceConverter.toMetric(converted.totalDistance, measurementSystem, preferMiles);
+  }
+
+  return converted;
+}
+
+/**
+ * Deep convert workout data structure from metric (for API responses)
+ * Handles nested setsData arrays in various structures
+ */
+export function convertWorkoutDataFromMetric(
+  data: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    return data.map(item => convertWorkoutDataFromMetric(item, measurementSystem));
+  }
+
+  const converted = { ...data };
+
+  // Convert setsData arrays
+  if (converted.setsData && Array.isArray(converted.setsData)) {
+    converted.setsData = convertSetsDataFromMetric(converted.setsData, measurementSystem);
+  }
+
+  // Convert sets arrays (used in program schedules)
+  if (converted.sets && Array.isArray(converted.sets)) {
+    converted.sets = convertSetsDataFromMetric(converted.sets, measurementSystem);
+  }
+
+  // Convert exercises arrays (nested structures)
+  if (converted.exercises && Array.isArray(converted.exercises)) {
+    converted.exercises = converted.exercises.map((exercise: any) =>
+      convertWorkoutDataFromMetric(exercise, measurementSystem)
+    );
+  }
+
+  // Convert schedule arrays (for programs)
+  if (converted.schedule && Array.isArray(converted.schedule)) {
+    converted.schedule = converted.schedule.map((day: any) =>
+      convertWorkoutDataFromMetric(day, measurementSystem)
+    );
+  }
+
+  // Convert data arrays (for response lists)
+  if (converted.data && Array.isArray(converted.data)) {
+    converted.data = converted.data.map((item: any) =>
+      convertWorkoutDataFromMetric(item, measurementSystem)
+    );
+  }
+
+  // Convert individual numeric fields at top level
+  if (converted.userBodyweight !== null && converted.userBodyweight !== undefined) {
+    converted.userBodyweight = WeightConverter.fromMetric(converted.userBodyweight, measurementSystem);
+  }
+
+  if (converted.totalVolume !== null && converted.totalVolume !== undefined) {
+    converted.totalVolume = WeightConverter.fromMetric(converted.totalVolume, measurementSystem);
+  }
+
+  if (converted.totalDistance !== null && converted.totalDistance !== undefined) {
+    const preferMiles = measurementSystem === 'imperial' && converted.totalDistance > 1609;
+    converted.totalDistance = DistanceConverter.fromMetric(converted.totalDistance, measurementSystem, preferMiles);
+  }
+
+  // Convert value field (for personal records)
+  if (converted.value !== null && converted.value !== undefined && converted.unit) {
+    // Detect unit type and convert accordingly
+    if (converted.unit === 'kg' || converted.unit === 'lbs') {
+      converted.value = WeightConverter.fromMetric(converted.value, measurementSystem);
+      converted.unit = measurementSystem === 'imperial' ? 'lbs' : 'kg';
+    }
+  }
+
+  return converted;
+}
+
+/**
+ * Convert nutrition goals data structure to metric (for API requests)
+ * Handles water goals: ml ↔ fl oz
+ */
+export function convertNutritionGoalsToMetric(
+  data: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  const converted = { ...data };
+
+  // Convert goals object (contains water, protein, etc.)
+  if (converted.goals && typeof converted.goals === 'object') {
+    converted.goals = { ...converted.goals };
+
+    // Convert water goal values from fl oz → ml
+    if (converted.goals.water && typeof converted.goals.water === 'object') {
+      const waterGoal = { ...converted.goals.water };
+
+      if (waterGoal.value !== null && waterGoal.value !== undefined) {
+        waterGoal.value = VolumeConverter.toMetric(waterGoal.value, measurementSystem);
+      }
+      if (waterGoal.min !== null && waterGoal.min !== undefined) {
+        waterGoal.min = VolumeConverter.toMetric(waterGoal.min, measurementSystem);
+      }
+      if (waterGoal.max !== null && waterGoal.max !== undefined) {
+        waterGoal.max = VolumeConverter.toMetric(waterGoal.max, measurementSystem);
+      }
+
+      converted.goals.water = waterGoal;
+    }
+  }
+
+  return converted;
+}
+
+/**
+ * Convert nutrition goals data structure from metric (for API responses)
+ * Handles water goals: ml ↔ fl oz
+ */
+export function convertNutritionGoalsFromMetric(
+  data: any,
+  measurementSystem: MeasurementSystem
+): any {
+  if (!data || typeof data !== 'object') {
+    return data;
+  }
+
+  // Handle arrays
+  if (Array.isArray(data)) {
+    return data.map(item => convertNutritionGoalsFromMetric(item, measurementSystem));
+  }
+
+  const converted = { ...data };
+
+  // Convert data array (for list responses)
+  if (converted.data && Array.isArray(converted.data)) {
+    converted.data = converted.data.map((item: any) =>
+      convertNutritionGoalsFromMetric(item, measurementSystem)
+    );
+  }
+
+  // Convert goals object (contains water, protein, etc.)
+  if (converted.goals && typeof converted.goals === 'object') {
+    converted.goals = { ...converted.goals };
+
+    // Convert water goal values from ml → fl oz
+    if (converted.goals.water && typeof converted.goals.water === 'object') {
+      const waterGoal = { ...converted.goals.water };
+
+      if (waterGoal.value !== null && waterGoal.value !== undefined) {
+        waterGoal.value = VolumeConverter.fromMetric(waterGoal.value, measurementSystem);
+      }
+      if (waterGoal.min !== null && waterGoal.min !== undefined) {
+        waterGoal.min = VolumeConverter.fromMetric(waterGoal.min, measurementSystem);
+      }
+      if (waterGoal.max !== null && waterGoal.max !== undefined) {
+        waterGoal.max = VolumeConverter.fromMetric(waterGoal.max, measurementSystem);
+      }
+
+      converted.goals.water = waterGoal;
+    }
+  }
+
+  return converted;
+}