@openlifelog/sdk 1.0.0

package/utils/units.ts

@@ -0,0 +1,279 @@
+import type { MeasurementSystem } from '../types/common';
+
+/**
+ * Unit conversion utilities for metric/imperial conversions
+ */
+
+// Conversion constants
+const KG_TO_LBS = 2.20462;
+const LBS_TO_KG = 1 / KG_TO_LBS;
+const METERS_TO_MILES = 0.000621371;
+const MILES_TO_METERS = 1 / METERS_TO_MILES;
+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;
+
+/**
+ * Weight conversion
+ */
+export class WeightConverter {
+  /**
+   * Convert kilograms to pounds
+   */
+  static kgToLbs(kg: number): number {
+    return kg * KG_TO_LBS;
+  }
+
+  /**
+   * Convert pounds to kilograms
+   */
+  static lbsToKg(lbs: number): number {
+    return lbs * LBS_TO_KG;
+  }
+
+  /**
+   * Convert weight from metric to the target measurement system
+   */
+  static fromMetric(kg: number, targetSystem: MeasurementSystem): number {
+    if (targetSystem === 'imperial') {
+      return this.kgToLbs(kg);
+    }
+    return kg;
+  }
+
+  /**
+   * Convert weight to metric from the source measurement system
+   */
+  static toMetric(value: number, sourceSystem: MeasurementSystem): number {
+    if (sourceSystem === 'imperial') {
+      return this.lbsToKg(value);
+    }
+    return value;
+  }
+}
+
+/**
+ * Distance conversion
+ */
+export class DistanceConverter {
+  /**
+   * Convert meters to miles
+   */
+  static metersToMiles(meters: number): number {
+    return meters * METERS_TO_MILES;
+  }
+
+  /**
+   * Convert miles to meters
+   */
+  static milesToMeters(miles: number): number {
+    return miles * MILES_TO_METERS;
+  }
+
+  /**
+   * Convert meters to feet
+   */
+  static metersToFeet(meters: number): number {
+    return meters * METERS_TO_FEET;
+  }
+
+  /**
+   * Convert feet to meters
+   */
+  static feetToMeters(feet: number): number {
+    return feet * FEET_TO_METERS;
+  }
+
+  /**
+   * Convert distance from metric to the target measurement system
+   * For larger distances (> 1000m), converts to miles, otherwise to feet
+   */
+  static fromMetric(meters: number, targetSystem: MeasurementSystem, preferMiles: boolean = false): number {
+    if (targetSystem === 'imperial') {
+      if (preferMiles || meters >= 1000) {
+        return this.metersToMiles(meters);
+      }
+      return this.metersToFeet(meters);
+    }
+    return meters;
+  }
+
+  /**
+   * Convert distance to metric from the source measurement system
+   */
+  static toMetric(value: number, sourceSystem: MeasurementSystem, isMiles: boolean = false): number {
+    if (sourceSystem === 'imperial') {
+      return isMiles ? this.milesToMeters(value) : this.feetToMeters(value);
+    }
+    return value;
+  }
+}
+
+/**
+ * Height conversion
+ */
+export class HeightConverter {
+  /**
+   * Convert centimeters to inches
+   */
+  static cmToInches(cm: number): number {
+    return cm * CM_TO_INCHES;
+  }
+
+  /**
+   * Convert inches to centimeters
+   */
+  static inchesToCm(inches: number): number {
+    return inches * INCHES_TO_CM;
+  }
+
+  /**
+   * Convert centimeters to feet and inches
+   */
+  static cmToFeetInches(cm: number): { feet: number; inches: number } {
+    const totalInches = this.cmToInches(cm);
+    const feet = Math.floor(totalInches / 12);
+    const inches = Math.round(totalInches % 12);
+    return { feet, inches };
+  }
+
+  /**
+   * Convert feet and inches to centimeters
+   */
+  static feetInchesToCm(feet: number, inches: number): number {
+    const totalInches = feet * 12 + inches;
+    return this.inchesToCm(totalInches);
+  }
+
+  /**
+   * Convert height from metric to the target measurement system
+   */
+  static fromMetric(cm: number, targetSystem: MeasurementSystem): number {
+    if (targetSystem === 'imperial') {
+      return this.cmToInches(cm);
+    }
+    return cm;
+  }
+
+  /**
+   * Convert height to metric from the source measurement system
+   */
+  static toMetric(value: number, sourceSystem: MeasurementSystem): number {
+    if (sourceSystem === 'imperial') {
+      return this.inchesToCm(value);
+    }
+    return value;
+  }
+}
+
+/**
+ * Generic unit converter that handles all conversions
+ */
+export class UnitConverter {
+  private measurementSystem: MeasurementSystem;
+
+  constructor(measurementSystem: MeasurementSystem = 'metric') {
+    this.measurementSystem = measurementSystem;
+  }
+
+  /**
+   * Update the measurement system
+   */
+  setMeasurementSystem(system: MeasurementSystem): void {
+    this.measurementSystem = system;
+  }
+
+  /**
+   * Get the current measurement system
+   */
+  getMeasurementSystem(): MeasurementSystem {
+    return this.measurementSystem;
+  }
+
+  /**
+   * Convert weight from metric (API storage format) to user preference
+   */
+  weightFromMetric(kg: number | null | undefined): number | null {
+    if (kg === null || kg === undefined) return null;
+    return WeightConverter.fromMetric(kg, this.measurementSystem);
+  }
+
+  /**
+   * Convert weight to metric (API storage format) from user preference
+   */
+  weightToMetric(value: number | null | undefined): number | null {
+    if (value === null || value === undefined) return null;
+    return WeightConverter.toMetric(value, this.measurementSystem);
+  }
+
+  /**
+   * Convert distance from metric to user preference
+   */
+  distanceFromMetric(meters: number | null | undefined, preferMiles: boolean = false): number | null {
+    if (meters === null || meters === undefined) return null;
+    return DistanceConverter.fromMetric(meters, this.measurementSystem, preferMiles);
+  }
+
+  /**
+   * Convert distance to metric from user preference
+   */
+  distanceToMetric(value: number | null | undefined, isMiles: boolean = false): number | null {
+    if (value === null || value === undefined) return null;
+    return DistanceConverter.toMetric(value, this.measurementSystem, isMiles);
+  }
+
+  /**
+   * Convert height from metric to user preference
+   */
+  heightFromMetric(cm: number | null | undefined): number | null {
+    if (cm === null || cm === undefined) return null;
+    return HeightConverter.fromMetric(cm, this.measurementSystem);
+  }
+
+  /**
+   * Convert height to metric from user preference
+   */
+  heightToMetric(value: number | null | undefined): number | null {
+    if (value === null || value === undefined) return null;
+    return HeightConverter.toMetric(value, this.measurementSystem);
+  }
+
+  /**
+   * Round number to specified decimal places
+   */
+  static round(value: number, decimals: number = 2): number {
+    return Math.round(value * Math.pow(10, decimals)) / Math.pow(10, decimals);
+  }
+
+  /**
+   * Get the appropriate unit label for weight
+   */
+  getWeightUnit(): string {
+    return this.measurementSystem === 'imperial' ? 'lbs' : 'kg';
+  }
+
+  /**
+   * Get the appropriate unit label for distance
+   */
+  getDistanceUnit(preferMiles: boolean = false): string {
+    if (this.measurementSystem === 'imperial') {
+      return preferMiles ? 'mi' : 'ft';
+    }
+    return 'm';
+  }
+
+  /**
+   * Get the appropriate unit label for height
+   */
+  getHeightUnit(): string {
+    return this.measurementSystem === 'imperial' ? 'in' : 'cm';
+  }
+}
+
+/**
+ * Helper function to create a unit converter
+ */
+export function createUnitConverter(measurementSystem: MeasurementSystem = 'metric'): UnitConverter {
+  return new UnitConverter(measurementSystem);
+}