expo-font 12.0.4 → 12.0.6

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 12.0.6 — 2024-05-29
+
+### 🐛 Bug fixes
+
+- [iOS] Fix font registration failing when font was in use. ([#28989](https://github.com/expo/expo/pull/28989) by [@aleqsio](https://github.com/aleqsio))
+
+## 12.0.5 — 2024-05-10
+
+### 🐛 Bug fixes
+
+- Fixed some vector icons not rendering correctly. ([#28747](https://github.com/expo/expo/pull/28747) by [@tsapeta](https://github.com/tsapeta))
+
 ## 12.0.4 — 2024-04-24
 
 _This version does not introduce any user-facing changes._

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '12.0.4'
+version = '12.0.6'
 
 def expoModulesCorePlugin = new File(project(":expo-modules-core").projectDir.absolutePath, "ExpoModulesCorePlugin.gradle")
 apply from: expoModulesCorePlugin
@@ -14,6 +14,6 @@ android {
   namespace "expo.modules.font"
   defaultConfig {
     versionCode 29
-    versionName "12.0.4"
+    versionName "12.0.6"
   }
 }

package/ios/FontFamilyAliasManager.swift

@@ -39,15 +39,9 @@ internal struct FontFamilyAliasManager {
 }
 
 /**
- Swizzles ``UIFont.fontNames(forFamilyName:)`` and ``UIFont(name:size:)`` to support font family aliases.
+ Swizzles ``UIFont.fontNames(forFamilyName:)`` to support font family aliases.
  This is necessary because the user provides a custom family name that is then used in stylesheets,
  however the font usually has a different name encoded in the binary, thus the system may use a different name.
-
- ``UIFont(name:size:)`` covers cases where there the font family has variants. For example, the ``CGFont fullName``
- value for "Helvetica-Light-Oblique.ttf" would be something like "Helvetica Light Oblique", which
- ``UIFont.fullNames`` won't recognize, because that is a font name rather than a font family name. We have to use
- ``UIFont(name:size:)`` instead, because it accepts a font name. React Native does this looking up / falling back
- for us, we just need to ensure both methods are swizzled so they both support aliasing.
  */
 private func maybeSwizzleUIFont() {
   if hasSwizzled {
@@ -61,13 +55,5 @@ private func maybeSwizzleUIFont() {
   } else {
     log.error("expo-font is unable to swizzle `UIFont.fontNames(forFamilyName:)`")
   }
-  let originalInitMethod = class_getClassMethod(UIFont.self, #selector(UIFont.init(name:size:)))
-  let newInitMethod = class_getClassMethod(UIFont.self, #selector(UIFont._expo_init(name:size:)))
-
-  if let originalInitMethod, let newInitMethod {
-    method_exchangeImplementations(originalInitMethod, newInitMethod)
-  } else {
-    log.error("expo-font is unable to swizzle `UIFont.init(name:size:)`")
-  }
   hasSwizzled = true
 }

package/ios/FontLoaderModule.swift

@@ -12,7 +12,9 @@ public final class FontLoaderModule: Module {
       // If the font was already registered, unregister it first. Otherwise CTFontManagerRegisterGraphicsFont
       // would fail because of a duplicated font name when the app reloads or someone wants to override a font.
       if let familyName = FontFamilyAliasManager.familyName(forAlias: fontFamilyAlias) {
-        try unregisterFont(named: familyName)
+        guard try unregisterFont(named: familyName) else {
+          return
+        }
       }
 
       // Create a font object from the given file

package/ios/FontUtils.swift

@@ -66,20 +66,33 @@ internal func registerFont(_ font: CGFont) throws {
 
 /**
  Unregisters the given font, so the app will no longer be able to render it.
+ Returns a boolean indicating if the font is successfully unregistered after this function completes.
  */
-internal func unregisterFont(_ font: CGFont) throws {
+internal func unregisterFont(_ font: CGFont) throws -> Bool {
   var error: Unmanaged<CFError>?
 
   if !CTFontManagerUnregisterGraphicsFont(font, &error), let error = error?.takeRetainedValue() {
-    throw FontRegistrationFailedException(error)
+    if let ctFontManagerError = CTFontManagerError(rawValue: CFErrorGetCode(error as CFError)) {
+      switch ctFontManagerError {
+      case .systemRequired, .inUse:
+        return false
+      case .notRegistered:
+        return true
+      default:
+        throw FontRegistrationFailedException(error)
+      }
+    }
   }
+  return true
 }
 
 /**
  Unregisters a font with the given name, so the app will no longer be able to render it.
+ Returns a boolean indicating if the font is successfully unregistered after this function completes.
  */
-internal func unregisterFont(named fontName: String) throws {
+internal func unregisterFont(named fontName: String) throws -> Bool {
   if let font = CGFont(fontName as CFString) {
-    try unregisterFont(font)
+    return try unregisterFont(font)
   }
+  return true
 }

package/ios/UIFont+FontFamilyAlias.swift

@@ -7,21 +7,20 @@ public extension UIFont {
    */
   @objc
   static dynamic func _expo_fontNames(forFamilyName familyName: String) -> [String] {
+    // Get font names from the original function.
     let fontNames = UIFont._expo_fontNames(forFamilyName: familyName)
 
+    // If no font names were found, let's try with the alias.
     if fontNames.isEmpty, let aliasedFamilyName = FontFamilyAliasManager.familyName(forAlias: familyName) {
-      // Note that this actually calls the original method implementation (if swizzled).
-      return UIFont._expo_fontNames(forFamilyName: aliasedFamilyName)
-    }
-    return fontNames
-  }
-  @objc
-  static dynamic func _expo_init(name fontName: String, size fontSize: CGFloat) -> UIFont? {
-    let font = UIFont._expo_init(name: fontName, size: fontSize)
+      let fontNames = UIFont._expo_fontNames(forFamilyName: aliasedFamilyName)
 
-    if let aliasedFamilyName = FontFamilyAliasManager.familyName(forAlias: fontName) {
-      return UIFont._expo_init(name: aliasedFamilyName, size: fontSize)
+      // If we still don't find any font names, we can assume it was not a family name but a font name.
+      // In that case we can safely return the original font name.
+      if fontNames.isEmpty {
+        return [aliasedFamilyName]
+      }
+      return fontNames
     }
-    return font
+    return fontNames
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-font",
-  "version": "12.0.4",
+  "version": "12.0.6",
   "description": "Load fonts at runtime and use them in React Native components.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -42,5 +42,5 @@
   "peerDependencies": {
     "expo": "*"
   },
-  "gitHead": "8b4cb45563b85c2ec91b1b249d136661bf6e8981"
+  "gitHead": "979e9f1fc3cfa9c827700dcf99992e671cfdf63e"
 }