feat: Begin using Tagged types

Sources/ManualDClient/Helpers.swift

@@ -97,16 +97,16 @@ func roundSize(_ size: Double) throws -> Int {
   }
 }
 
-func velocity(cfm: Int, roundSize: Int) -> Int {
-  let cfm = Double(cfm)
+func velocity(cfm: CFM, roundSize: Int) -> Int {
+  let cfm = Double(cfm.rawValue)
   let roundSize = Double(roundSize)
   let velocity = cfm / (pow(roundSize / 24, 2) * 3.14)
   return Int(round(velocity))
 }
 
-func flexSize(_ request: ManualDClient.DuctSizeRequest) throws -> Int {
-  let cfm = pow(Double(request.designCFM), 0.4)
-  let fr = pow(request.frictionRate / 1.76, 0.2)
+func flexSize(_ cfm: CFM, _ frictionRate: DesignFrictionRate) throws -> Int {
+  let cfm = pow(Double(cfm.rawValue), 0.4)
+  let fr = pow(frictionRate.rawValue / 1.76, 0.2)
   let size = 0.55 * (cfm / fr)
   return try roundSize(size)
 }

Sources/ManualDClient/Interface.swift

@@ -4,6 +4,7 @@ import Logging
 import ManualDCore
 
 extension DependencyValues {
+  /// Dependency that performs manual-d duct sizing calculations.
   public var manualD: ManualDClient {
     get { self[ManualDClient.self] }
     set { self[ManualDClient.self] = newValue }
@@ -15,12 +16,24 @@ extension DependencyValues {
 ///
 @DependencyClient
 public struct ManualDClient: Sendable {
-  public var ductSize: @Sendable (DuctSizeRequest) async throws -> DuctSizeResponse
+  public var ductSize: @Sendable (CFM, DesignFrictionRate) async throws -> DuctSizeResponse
   public var frictionRate: @Sendable (FrictionRateRequest) async throws -> FrictionRate
-  public var totalEquivalentLength: @Sendable (TotalEquivalentLengthRequest) async throws -> Int
   public var rectangularSize:
     @Sendable (RectangularSizeRequest) async throws -> RectangularSizeResponse
 
+  public func ductSize(
+    cfm designCFM: Int,
+    frictionRate designFrictionRate: Double
+  ) async throws -> DuctSizeResponse {
+    try await ductSize(.init(rawValue: designCFM), .init(rawValue: designFrictionRate))
+  }
+
+  public func ductSize(
+    cfm designCFM: Double,
+    frictionRate designFrictionRate: Double
+  ) async throws -> DuctSizeResponse {
+    try await ductSize(.init(rawValue: Int(designCFM)), .init(rawValue: designFrictionRate))
+  }
 }
 
 extension ManualDClient: TestDependencyKey {
@@ -29,19 +42,6 @@ extension ManualDClient: TestDependencyKey {
 
 extension ManualDClient {
 
-  public struct DuctSizeRequest: Codable, Equatable, Sendable {
-    public let designCFM: Int
-    public let frictionRate: Double
-
-    public init(
-      designCFM: Int,
-      frictionRate: Double
-    ) {
-      self.designCFM = designCFM
-      self.frictionRate = frictionRate
-    }
-  }
-
   public struct DuctSizeResponse: Codable, Equatable, Sendable {
 
     public let calculatedSize: Double
@@ -82,31 +82,14 @@ extension ManualDClient {
   public struct FrictionRateResponse: Codable, Equatable, Sendable {
 
     public let availableStaticPressure: Double
-    public let frictionRate: Double
+    public let frictionRate: DesignFrictionRate
 
-    public init(availableStaticPressure: Double, frictionRate: Double) {
+    public init(availableStaticPressure: Double, frictionRate: DesignFrictionRate) {
       self.availableStaticPressure = availableStaticPressure
       self.frictionRate = frictionRate
     }
   }
 
-  public struct TotalEquivalentLengthRequest: Codable, Equatable, Sendable {
-
-    public let trunkLengths: [Int]
-    public let runoutLengths: [Int]
-    public let effectiveLengthGroups: [EffectiveLengthGroup]
-
-    public init(
-      trunkLengths: [Int],
-      runoutLengths: [Int],
-      effectiveLengthGroups: [EffectiveLengthGroup]
-    ) {
-      self.trunkLengths = trunkLengths
-      self.runoutLengths = runoutLengths
-      self.effectiveLengthGroups = effectiveLengthGroups
-    }
-  }
-
   public struct RectangularSizeRequest: Codable, Equatable, Sendable {
     public let roundSize: Int
     public let height: Int

Sources/ManualDClient/Live.swift

@@ -4,19 +4,19 @@ import ManualDCore
 
 extension ManualDClient: DependencyKey {
   public static let liveValue: Self = .init(
-    ductSize: { request in
-      guard request.designCFM > 0 else {
+    ductSize: { cfm, frictionRate in
+      guard cfm > 0 else {
         throw ManualDError(message: "Design CFM should be greater than 0.")
       }
-      let fr = pow(request.frictionRate, 0.5)
-      let ductulatorSize = pow(Double(request.designCFM) / (3.12 * fr), 0.38)
+      let fr = pow(frictionRate.rawValue, 0.5)
+      let ductulatorSize = pow(Double(cfm.rawValue) / (3.12 * fr), 0.38)
       let finalSize = try roundSize(ductulatorSize)
-      let flexSize = try flexSize(request)
+      let flexSize = try flexSize(cfm, frictionRate)
       return .init(
         calculatedSize: ductulatorSize,
         finalSize: finalSize,
         flexSize: flexSize,
-        velocity: velocity(cfm: request.designCFM, roundSize: finalSize)
+        velocity: velocity(cfm: cfm, roundSize: finalSize)
       )
     },
     frictionRate: { request in
@@ -28,14 +28,17 @@ extension ManualDClient: DependencyKey {
       let totalComponentLosses = request.componentPressureLosses.total
       let availableStaticPressure = request.externalStaticPressure - totalComponentLosses
       let frictionRate = availableStaticPressure * 100.0 / Double(request.totalEffectiveLength)
-      return .init(availableStaticPressure: availableStaticPressure, value: frictionRate)
-    },
-    totalEquivalentLength: { request in
-      let trunkLengths = request.trunkLengths.reduce(0) { $0 + $1 }
-      let runoutLengths = request.runoutLengths.reduce(0) { $0 + $1 }
-      let groupLengths = request.effectiveLengthGroups.totalEffectiveLength
-      return trunkLengths + runoutLengths + groupLengths
+      return .init(
+        availableStaticPressure: availableStaticPressure,
+        value: .init(rawValue: frictionRate)
+      )
     },
+    // totalEquivalentLength: { request in
+    //   let trunkLengths = request.trunkLengths.reduce(0) { $0 + $1 }
+    //   let runoutLengths = request.runoutLengths.reduce(0) { $0 + $1 }
+    //   let groupLengths = request.effectiveLengthGroups.totalEffectiveLength
+    //   return trunkLengths + runoutLengths + groupLengths
+    // },
     rectangularSize: { request in
       let width = (Double.pi * (pow(Double(request.roundSize) / 2.0, 2.0))) / Double(request.height)
       return .init(height: request.height, width: Int(width.rounded(.toNearestOrEven)))