Merge pull request #647 from nexxai/add-more-fonts

datlechin · web-flow · commit 721e3788f48e · 2026-04-09T12:00:15.000+07:00
feat: support all monospaced fonts installed on the local system
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -19,6 +19,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fix idle ping spin loop caused by exhausted AsyncStream iterator (#618)
 - Skip exact row count for large tables — use database statistics estimate (#519)
 
+### Changed
+
+- Theme font pickers now list installed monospaced fonts dynamically instead of a fixed built-in list
+
 ## [0.28.0] - 2026-04-07
 
 ### Added
diff --git a/TablePro/Models/Settings/EditorSettings.swift b/TablePro/Models/Settings/EditorSettings.swift
@@ -6,52 +6,58 @@
 import AppKit
 import Foundation
 
-/// Available monospace fonts for the SQL editor
-enum EditorFont: String, Codable, CaseIterable, Identifiable {
-    case systemMono = "System Mono"
-    case sfMono = "SF Mono"
-    case menlo = "Menlo"
-    case monaco = "Monaco"
-    case courierNew = "Courier New"
-
-    var id: String { rawValue }
-
-    var displayName: String { rawValue }
-
-    /// Get the actual NSFont for this option
-    func font(size: CGFloat) -> NSFont {
-        switch self {
-        case .systemMono:
+internal struct FontFamilyOption: Equatable, Identifiable, Sendable {
+    let id: String
+    let displayName: String
+}
+
+internal enum EditorFontResolver {
+    static let systemMonoId = "System Mono"
+
+    static let availableMonospacedFamilies: [FontFamilyOption] = {
+        var options: [FontFamilyOption] = [
+            FontFamilyOption(id: systemMonoId, displayName: systemMonoId)
+        ]
+
+        let familyNames = NSFontManager.shared.availableFontFamilies
+            .filter { $0 != systemMonoId }
+            .filter(isMonospacedFamily)
+            .sorted { lhs, rhs in
+                lhs.localizedCaseInsensitiveCompare(rhs) == .orderedAscending
+            }
+
+        var seen: Set<String> = [systemMonoId]
+        for family in familyNames where !seen.contains(family) {
+            seen.insert(family)
+            options.append(FontFamilyOption(id: family, displayName: family))
+        }
+
+        return options
+    }()
+
+    static func resolve(familyId: String, size: CGFloat) -> NSFont {
+        guard familyId != systemMonoId else {
             return NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
-        case .sfMono:
-            return NSFont(name: "SFMono-Regular", size: size)
-                ?? NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
-        case .menlo:
-            return NSFont(name: "Menlo", size: size)
-                ?? NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
-        case .monaco:
-            return NSFont(name: "Monaco", size: size)
-                ?? NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
-        case .courierNew:
-            return NSFont(name: "Courier New", size: size)
-                ?? NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
         }
-    }
 
-    /// Check if this font is available on the system
-    var isAvailable: Bool {
-        switch self {
-        case .systemMono:
-            return true
-        case .sfMono:
-            return NSFont(name: "SFMono-Regular", size: 12) != nil
-        case .menlo:
-            return NSFont(name: "Menlo", size: 12) != nil
-        case .monaco:
-            return NSFont(name: "Monaco", size: 12) != nil
-        case .courierNew:
-            return NSFont(name: "Courier New", size: 12) != nil
+        let descriptor = NSFontDescriptor(fontAttributes: [.family: familyId])
+        if let font = NSFont(descriptor: descriptor, size: size),
+           font.fontDescriptor.symbolicTraits.contains(.monoSpace) {
+            return font
         }
+
+        return NSFont.monospacedSystemFont(ofSize: size, weight: .regular)
+    }
+
+    static func isAvailable(familyId: String) -> Bool {
+        guard familyId != systemMonoId else { return true }
+        return isMonospacedFamily(familyId)
+    }
+
+    private static func isMonospacedFamily(_ familyId: String) -> Bool {
+        let descriptor = NSFontDescriptor(fontAttributes: [.family: familyId])
+        guard let font = NSFont(descriptor: descriptor, size: 12) else { return false }
+        return font.fontDescriptor.symbolicTraits.contains(.monoSpace)
     }
 }
 
diff --git a/TablePro/Theme/ThemeEngine.swift b/TablePro/Theme/ThemeEngine.swift
@@ -32,8 +32,7 @@ internal struct EditorFontCache {
         let scale = Self.computeAccessibilityScale()
         scaleFactor = scale
         let scaledSize = round(CGFloat(min(max(fonts.editorFontSize, 11), 18)) * scale)
-        font = EditorFont(rawValue: fonts.editorFontFamily)?.font(size: scaledSize)
-            ?? NSFont.monospacedSystemFont(ofSize: scaledSize, weight: .regular)
+        font = EditorFontResolver.resolve(familyId: fonts.editorFontFamily, size: scaledSize)
         let lineNumSize = max(round((scaledSize - 2)), 9)
         lineNumberFont = NSFont.monospacedSystemFont(ofSize: lineNumSize, weight: .regular)
     }
@@ -55,8 +54,7 @@ internal struct DataGridFontCacheResolved {
     init(from fonts: ThemeFonts) {
         let scale = EditorFontCache.computeAccessibilityScale()
         let scaledSize = round(CGFloat(min(max(fonts.dataGridFontSize, 10), 18)) * scale)
-        regular = EditorFont(rawValue: fonts.dataGridFontFamily)?.font(size: scaledSize)
-            ?? NSFont.monospacedSystemFont(ofSize: scaledSize, weight: .regular)
+        regular = EditorFontResolver.resolve(familyId: fonts.dataGridFontFamily, size: scaledSize)
         italic = regular.withTraits(.italic)
         medium = NSFontManager.shared.convert(regular, toHaveTrait: .boldFontMask)
         let rowNumSize = max(round(scaledSize - 1), 9)
diff --git a/TablePro/Views/Settings/Appearance/ThemeEditorFontsSection.swift b/TablePro/Views/Settings/Appearance/ThemeEditorFontsSection.swift
@@ -76,9 +76,10 @@ struct ThemeEditorFontsSection: View {
     private var previewSection: some View {
         Section(String(localized: "Preview")) {
             let fonts = currentThemeFonts
-            let editorFont = EditorFont(rawValue: fonts.editorFontFamily)?
-                .font(size: CGFloat(fonts.editorFontSize))
-                ?? NSFont.monospacedSystemFont(ofSize: CGFloat(fonts.editorFontSize), weight: .regular)
+            let editorFont = EditorFontResolver.resolve(
+                familyId: fonts.editorFontFamily,
+                size: CGFloat(fonts.editorFontSize)
+            )
 
             Text("SELECT * FROM users WHERE id = 42;")
                 .font(Font(editorFont))
@@ -97,8 +98,8 @@ struct ThemeEditorFontsSection: View {
             get: { selection },
             set: { onChange($0) }
         )) {
-            ForEach(EditorFont.allCases.filter(\.isAvailable)) { font in
-                Text(font.displayName).tag(font.rawValue)
+            ForEach(EditorFontResolver.availableMonospacedFamilies) { font in
+                Text(font.displayName).tag(font.id)
             }
         }
     }
diff --git a/TableProTests/Theme/ThemeDefinitionTests.swift b/TableProTests/Theme/ThemeDefinitionTests.swift
@@ -6,13 +6,13 @@
 //  currentStatementHighlight field and Codable backward compatibility.
 //
 
+import AppKit
 import Foundation
 import Testing
 @testable import TablePro
 
 @Suite("Theme Definition")
 struct ThemeDefinitionTests {
-
     // MARK: - Default light theme
 
     @Test("Default light editor colors include currentStatementHighlight")
@@ -134,4 +134,71 @@ struct ThemeDefinitionTests {
 
         #expect(decoded.currentStatementHighlight == "#AABBCC")
     }
+
+    // MARK: - Editor font resolver
+
+    @Test("Font resolver always exposes System Mono")
+    func resolverExposesSystemMono() {
+        let families = EditorFontResolver.availableMonospacedFamilies
+        #expect(families.contains { $0.id == EditorFontResolver.systemMonoId })
+    }
+
+    @Test("System Mono is first in picker list")
+    func systemMonoFirst() {
+        let families = EditorFontResolver.availableMonospacedFamilies
+        #expect(families.first?.id == EditorFontResolver.systemMonoId)
+    }
+
+    @Test("Editor font cache falls back for unknown font family")
+    func editorCacheFallsBackForUnknownFamily() {
+        let fonts = ThemeFonts(
+            editorFontFamily: "NoSuchFamily-XYZ",
+            editorFontSize: 13,
+            dataGridFontFamily: "System Mono",
+            dataGridFontSize: 13
+        )
+        let cache = EditorFontCache(from: fonts)
+        #expect(cache.font.pointSize > 0)
+    }
+
+    @Test("Data grid cache falls back for unknown font family")
+    func dataGridCacheFallsBackForUnknownFamily() {
+        let fonts = ThemeFonts(
+            editorFontFamily: "System Mono",
+            editorFontSize: 13,
+            dataGridFontFamily: "NoSuchFamily-XYZ",
+            dataGridFontSize: 13
+        )
+        let cache = DataGridFontCacheResolved(from: fonts)
+        #expect(cache.regular.pointSize > 0)
+        #expect(cache.monoCharWidth > 0)
+    }
+
+    @Test("Resolver list has unique IDs")
+    func resolverListHasUniqueIds() {
+        let ids = EditorFontResolver.availableMonospacedFamilies.map(\.id)
+        #expect(Set(ids).count == ids.count)
+    }
+
+    @Test("Unknown family reports unavailable")
+    func unknownFamilyUnavailable() {
+        #expect(EditorFontResolver.isAvailable(familyId: "NoSuchFamily-XYZ") == false)
+    }
+
+    @Test("ThemeFonts decode keeps legacy family strings")
+    func themeFontsDecodeKeepsLegacyStrings() throws {
+        let json = #"{"editorFontFamily":"Menlo","editorFontSize":13,"dataGridFontFamily":"Monaco","dataGridFontSize":13}"#
+        let decoded = try JSONDecoder().decode(ThemeFonts.self, from: Data(json.utf8))
+        #expect(decoded.editorFontFamily == "Menlo")
+        #expect(decoded.dataGridFontFamily == "Monaco")
+    }
+
+    @Test("All resolver font families are monospaced")
+    func allResolverFamiliesAreMonospaced() {
+        let families = EditorFontResolver.availableMonospacedFamilies
+        for family in families where family.id != EditorFontResolver.systemMonoId {
+            let font = EditorFontResolver.resolve(familyId: family.id, size: 12)
+            #expect(font.fontDescriptor.symbolicTraits.contains(.monoSpace))
+        }
+    }
 }
diff --git a/docs/customization/appearance.mdx b/docs/customization/appearance.mdx
@@ -76,7 +76,7 @@ When you select a theme from the list, it becomes the preferred theme for that t
 
 ## Customizing Themes
 
-Select a theme and edit directly. Built-in themes auto-duplicate when you change colors or layout, preserving the original. Font changes apply without duplication.
+Select a theme and edit directly. Built-in themes auto-duplicate when you change colors or layout, preserving the original. Font changes apply without duplication, and font family pickers list installed monospaced fonts from your Mac.
 
 ## Import, Export & Registry
 
@@ -175,4 +175,3 @@ These appear on:
     alt="Database type colors"
   />
 </Frame>
-
diff --git a/docs/customization/editor-settings.mdx b/docs/customization/editor-settings.mdx
@@ -25,7 +25,7 @@ Configure the SQL editor in **Settings** > **Editor**.
 
 ### Font Family
 
-Available monospace fonts:
+The font picker shows installed monospaced families on your Mac.
 
 | Font | Description |
 |------|-------------|
@@ -39,7 +39,7 @@ Available monospace fonts:
 **System Mono** automatically uses the best available system monospace font.
 </Tip>
 
-If a selected font isn't available, TablePro falls back to System Mono.
+If a saved font is no longer available, TablePro falls back to System Mono.
 
 {/* Screenshot: Font family selector */}
 <Frame caption="Font family selector with available fonts">
diff --git a/docs/customization/settings.mdx b/docs/customization/settings.mdx
@@ -155,7 +155,7 @@ No personal information, queries, or database content is transmitted. Toggle off
 
 | Setting | Default | Range | Description |
 |---------|---------|-------|-------------|
-| **Font family** | System Mono | System Mono, SF Mono, Menlo, Monaco, Courier New | Monospace font for data grid cells |
+| **Font family** | System Mono | Installed monospaced fonts (dynamic list) | Monospace font for data grid cells |
 | **Font size** | 13 pt | 10-18 pt | Text size in data grid cells |
 
 Affects all data grid cells, including NULL placeholders and cell editing overlays. A live preview is shown in the settings panel.
