expo-font 12.0.8 → 12.0.10

package/CHANGELOG.md

@@ -10,6 +10,18 @@
 
 ### 💡 Others
 
+## 12.0.10 — 2024-09-03
+
+### 🐛 Bug fixes
+
+- Fix support for macOS. ([#31307](https://github.com/expo/expo/pull/31307) by [@gabrieldonadel](https://github.com/gabrieldonadel))
+
+## 12.0.9 — 2024-07-16
+
+### 🐛 Bug fixes
+
+- On `iOS`, fix issues where fonts were removed when the app is backgrounded. ([#30400](https://github.com/expo/expo/pull/30400) by [@alanjhughes](https://github.com/alanjhughes))
+
 ## 12.0.8 — 2024-07-11
 
 ### 🎉 New features

package/android/build.gradle

@@ -1,7 +1,7 @@
 apply plugin: 'com.android.library'
 
 group = 'host.exp.exponent'
-version = '12.0.8'
+version = '12.0.10'
 
 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.8"
+    versionName "12.0.10"
   }
 }

package/ios/FontExceptions.swift

@@ -17,3 +17,9 @@ internal final class FontRegistrationFailedException: GenericException<CFError>
     "Registering '\(param)' font failed with message: '\(param.localizedDescription)'"
   }
 }
+
+internal final class UnregisteringFontFailedException: GenericException<CFError> {
+  override var reason: String {
+    "Unregistering '\(param)' font failed with message: '\(param.localizedDescription)'"
+  }
+}

package/ios/FontFamilyAliasManager.swift

@@ -25,9 +25,9 @@ internal struct FontFamilyAliasManager {
    Sets the alias for the given family name.
    If the alias has already been set, its family name will be overriden.
    */
-  internal static func setAlias(_ familyNameAlias: String, forFamilyName familyName: String) {
+  internal static func setAlias(_ familyNameAlias: String, forFont font: String) {
     maybeSwizzleUIFont()
-    fontFamilyAliases[familyNameAlias] = familyName
+    fontFamilyAliases[familyNameAlias] = font
   }
 
   /**
@@ -47,6 +47,7 @@ private func maybeSwizzleUIFont() {
   if hasSwizzled {
     return
   }
+#if !os(macOS)
   let originalFontNamesMethod = class_getClassMethod(UIFont.self, #selector(UIFont.fontNames(forFamilyName:)))
   let newFontNamesMethod = class_getClassMethod(UIFont.self, #selector(UIFont._expo_fontNames(forFamilyName:)))
 
@@ -55,5 +56,6 @@ private func maybeSwizzleUIFont() {
   } else {
     log.error("expo-font is unable to swizzle `UIFont.fontNames(forFamilyName:)`")
   }
+#endif
   hasSwizzled = true
 }

package/ios/FontLoaderModule.swift

@@ -9,24 +9,23 @@ public final class FontLoaderModule: Module {
     }
 
     AsyncFunction("loadAsync") { (fontFamilyAlias: String, localUri: URL) in
-      // If the font was already registered, unregister it first. Otherwise CTFontManagerRegisterGraphicsFont
+      let fontUrl = localUri as CFURL
+      // If the font was already registered, unregister it first. Otherwise CTFontManagerRegisterFontsForURL
       // 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) {
-        guard try unregisterFont(named: familyName) else {
+      if FontFamilyAliasManager.familyName(forAlias: fontFamilyAlias) != nil {
+        guard try unregisterFont(url: fontUrl) else {
           return
         }
       }
 
-      // Create a font object from the given file
-      let font = try loadFont(fromPath: localUri.path, alias: fontFamilyAlias)
-
       // Register the font
-      try registerFont(font)
+      try registerFont(fontUrl)
+
+      // Create a font object from the given URL
+      let font = try loadFont(fromUrl: fontUrl, alias: fontFamilyAlias)
 
-      // The real font name might be different than it's been requested by the user,
-      // so we save the provided name as an alias.
       if let postScriptName = font.postScriptName as? String {
-        FontFamilyAliasManager.setAlias(fontFamilyAlias, forFamilyName: postScriptName)
+        FontFamilyAliasManager.setAlias(fontFamilyAlias, forFont: postScriptName)
       }
     }
   }

package/ios/FontUtils.swift

@@ -25,31 +25,34 @@ internal func queryCustomNativeFonts() -> [String] {
   // [2] Retrieve font names by family names
   return fontFamilies.flatMap { fontFamilyNames in
     return fontFamilyNames.flatMap { fontFamilyName in
+    #if os(iOS) || os(tvOS)
       return UIFont.fontNames(forFamilyName: fontFamilyName)
+    #elseif os(macOS)
+      return NSFontManager.shared.availableMembers(ofFontFamily: fontFamilyName)?.compactMap { $0[0] as? String } ?? []
+    #endif
     }
   }
 }
 
 /**
- Loads the font from the given path and returns it as ``CGFont``.
+ Loads the font from the given url and returns it as ``CGFont``.
  */
-internal func loadFont(fromPath path: String, alias: String) throws -> CGFont {
-  guard let data = FileManager.default.contents(atPath: path) else {
-    throw FontFileNotFoundException(path)
-  }
-  guard let provider = CGDataProvider(data: data as CFData), let font = CGFont(provider) else {
+internal func loadFont(fromUrl url: CFURL, alias: String) throws -> CGFont {
+  guard let provider = CGDataProvider(url: url),
+    let cgFont = CGFont(provider) else {
     throw FontCreationFailedException(alias)
   }
-  return font
+
+  return cgFont
 }
 
 /**
  Registers the given font to make it discoverable through font descriptor matching.
  */
-internal func registerFont(_ font: CGFont) throws {
+internal func registerFont(_ fontUrl: CFURL) throws {
   var error: Unmanaged<CFError>?
 
-  if !CTFontManagerRegisterGraphicsFont(font, &error), let error = error?.takeRetainedValue() {
+  if !CTFontManagerRegisterFontsForURL(fontUrl, .process, &error), let error = error?.takeRetainedValue() {
     let fontError = CTFontManagerError(rawValue: CFErrorGetCode(error))
 
     switch fontError {
@@ -68,10 +71,10 @@ 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 -> Bool {
+internal func unregisterFont(url: CFURL) throws -> Bool {
   var error: Unmanaged<CFError>?
 
-  if !CTFontManagerUnregisterGraphicsFont(font, &error), let error = error?.takeRetainedValue() {
+  if !CTFontManagerUnregisterFontsForURL(url, .process, &error), let error = error?.takeRetainedValue() {
     if let ctFontManagerError = CTFontManagerError(rawValue: CFErrorGetCode(error as CFError)) {
       switch ctFontManagerError {
       case .systemRequired, .inUse:
@@ -79,20 +82,9 @@ internal func unregisterFont(_ font: CGFont) throws -> Bool {
       case .notRegistered:
         return true
       default:
-        throw FontRegistrationFailedException(error)
+        throw UnregisteringFontFailedException(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 -> Bool {
-  if let font = CGFont(fontName as CFString) {
-    return try unregisterFont(font)
-  }
-  return true
-}

package/ios/UIFont+FontFamilyAlias.swift

@@ -1,3 +1,4 @@
+#if !os(macOS)
 /**
  An extension to ``UIFont`` that adds a custom implementation of `fontNames(forFamilyName:)` that supports aliasing font families.
  */
@@ -11,16 +12,18 @@ public extension UIFont {
     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) {
-      let fontNames = UIFont._expo_fontNames(forFamilyName: aliasedFamilyName)
+    if fontNames.isEmpty, let postScriptName = FontFamilyAliasManager.familyName(forAlias: familyName) {
+      let fontNames = UIFont._expo_fontNames(forFamilyName: postScriptName)
 
       // 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 [postScriptName]
       }
       return fontNames
     }
+
     return fontNames
   }
 }
+#endif

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-font",
-  "version": "12.0.8",
+  "version": "12.0.10",
   "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": "48f1ec9d91c5c38c7684cb98a314e443cbeb2185"
+  "gitHead": "de377512cb1707aee70e78cc8fd875d2ba9c3ab4"
 }