[Issue 63] Don’t manually increase weight of scaled system fonts

Author: Mark Pospesel

Sources/YMatterType/Typography/FontFamily/SystemFontFamily.swift

@@ -64,11 +64,40 @@ public struct SystemFontFamily: FontFamily {
         pointSize: CGFloat,
         compatibleWith traitCollection: UITraitCollection?
     ) -> UIFont {
-        // The system font cannot be retrieved using UIFont.font(name:size:), but
-        // instead must be created using UIFont.systemFont(ofSize:weight:)
-        let useBoldFont = isBoldTextEnabled(compatibleWith: traitCollection)
+        // When UIAccessibility.isBoldTextEnabled == true, then we don't need to manually
+        // adjust the weight because the system will do it for us.
+        let useBoldFont = isBoldTextEnabled(compatibleWith: traitCollection) && !UIAccessibility.isBoldTextEnabled
         let actualWeight = useBoldFont ? accessibilityBoldWeight(for: weight) : weight
 
+        // The system font cannot be retrieved using UIFont.font(name:size:), but
+        // instead must be created using UIFont.systemFont(ofSize:weight:)
         return UIFont.systemFont(ofSize: pointSize, weight: actualWeight.systemWeight)
     }
+
+    /// Returns the next heavier supported weight (if any), otherwise the heaviest supported weight
+    public func accessibilityBoldWeight(for weight: Typography.FontWeight) -> Typography.FontWeight {
+        var boldWeight: Typography.FontWeight
+
+        switch weight {
+        // For 3 lightest weights, move up 1 weight
+        case .ultralight:
+            boldWeight = .thin
+        case .thin:
+            boldWeight = .light
+        case .light:
+            boldWeight = .regular
+
+        // For all remaining weights, move up 2 weights
+        case .regular:
+            boldWeight = .semibold
+        case .medium:
+            boldWeight = .bold
+        case .semibold:
+            boldWeight = .heavy
+        case .bold, .heavy, .black:
+            boldWeight = .black
+        }
+
+        return boldWeight
+    }
 }

Sources/YMatterType/Typography/Typography+Font.swift

@@ -127,6 +127,14 @@ extension Typography {
 
 private extension Typography {
     func generateFixedFont(compatibleWith traitCollection: UITraitCollection?) -> UIFont {
-        fontFamily.font(for: fontWeight, pointSize: fontSize, compatibleWith: traitCollection)
+        var traits = traitCollection
+        if !isFixed && fontFamily is SystemFontFamily {
+            // System font already considers accessibility BoldText when
+            // we get the scaled font via `UIFontMetrics.scaledFont(for:compatibleWith:)`,
+            // so we pass a non-bold trait collection when generating the fixed font, so
+            // as not to increase the font weight twice.
+            traits = UITraitCollection(legibilityWeight: .regular)
+        }
+        return fontFamily.font(for: fontWeight, pointSize: fontSize, compatibleWith: traits)
     }
 }

Tests/YMatterTypeTests/Typography/FontFamily/SystemFontFamilyTests.swift

@@ -29,6 +29,60 @@ final class SystemFontFamilyTests: XCTestCase {
         let (sut, _, _) = makeSUT()
         XCTAssertTrue(sut.familyName.isEmpty)
     }
+
+    func test_accessibilityWeight_deliversCorrectWeight() {
+        let (sut, _, _) = makeSUT()
+        let lightWeights: [Typography.FontWeight] = [.ultralight, .thin, .light]
+        let midWeights: [Typography.FontWeight] = [.regular, .medium, .semibold]
+        let heavyWeights: [Typography.FontWeight] = [.bold, .heavy, .black]
+
+        for weight in lightWeights {
+            XCTAssertEqual(sut.accessibilityBoldWeight(for: weight).rawValue, weight.rawValue + 100)
+        }
+
+        for weight in midWeights {
+            XCTAssertEqual(sut.accessibilityBoldWeight(for: weight).rawValue, weight.rawValue + 200)
+        }
+
+        for weight in heavyWeights {
+            XCTAssertEqual(sut.accessibilityBoldWeight(for: weight), .black)
+        }
+    }
+
+    func test_layout_deliversCorrectFont() throws {
+        let (sut, _, traitCollections) = makeSUT()
+
+        for weight in Typography.systemFamily.supportedWeights {
+            for traitCollection in traitCollections {
+                let typography = Typography(fontFamily: sut, fontWeight: weight, fontSize: 16, lineHeight: 24)
+                let layoutDynamic = typography.generateLayout(compatibleWith: traitCollection)
+                let layoutFixed = typography.fixed.generateLayout(compatibleWith: traitCollection)
+                XCTAssertEqual(layoutDynamic.font.fontName, layoutFixed.font.fontName)
+            }
+        }
+    }
+
+    func test_layoutWithLegibilityWeightBold_deliversHeavierFont() throws {
+        // Given
+        let (sut, _, _) = makeSUT()
+        let traitRegular = UITraitCollection(legibilityWeight: .regular)
+        let traitBold = UITraitCollection(legibilityWeight: .bold)
+        var weights = Typography.systemFamily.supportedWeights
+        weights.removeLast() // don't consider .black because we cannot go heavier
+
+        for weight in weights {
+            // When
+            let typography = Typography(fontFamily: sut, fontWeight: weight, fontSize: 16, lineHeight: 24)
+            let layoutRegular = typography.generateLayout(compatibleWith: traitRegular)
+            let layoutBold = typography.generateLayout(compatibleWith: traitBold)
+
+            let weightRegular = try XCTUnwrap(self.weight(from: layoutRegular.font))
+            let weightBold = try XCTUnwrap(self.weight(from: layoutBold.font))
+
+            // Then
+            XCTAssertGreaterThan(weightBold.rawValue, weightRegular.rawValue)
+        }
+    }
 }
 
 // We use large tuples in makeSUT()
@@ -46,4 +100,33 @@ private extension SystemFontFamilyTests {
         ]
         return (sut, pointSizes, traitCollections)
     }
+
+    func weight(from font: UIFont) -> Typography.FontWeight? {
+        guard let weightString = font.fontName.components(separatedBy: "-").last else {
+            return nil
+        }
+
+        switch weightString.lowercased(with: Locale(identifier: "en_US")) {
+        case "ultralight", "extralight":
+            return .ultralight
+        case "thin":
+            return .thin
+        case "light":
+            return .light
+        case "regular":
+            return .regular
+        case "medium":
+            return .medium
+        case "semibold", "demibold":
+            return .semibold
+        case "bold":
+            return .bold
+        case "heavy", "extrabold":
+            return .heavy
+        case "black":
+            return .black
+        default:
+            return nil
+        }
+    }
 }