@sriinnu/runic 2.0.0 → 2.11.2

package/Sources/Runic/Core/Rendering/IconView.swift

@@ -1,122 +0,0 @@
-import RunicCore
-import SwiftUI
-
-@MainActor
-struct IconView: View {
-    let snapshot: UsageSnapshot?
-    let creditsRemaining: Double?
-    let isStale: Bool
-    let showLoadingAnimation: Bool
-    let style: IconStyle
-    @State private var phase: CGFloat = 0
-    @State private var displayLink = DisplayLinkDriver()
-    @State private var pattern: LoadingPattern = .knightRider
-    @State private var debugCycle = false
-    @State private var cycleIndex = 0
-    @State private var cycleCounter = 0
-    private let loadingFPS: Double = 12
-    // Advance to next pattern every N ticks when debug cycling.
-    private let cycleIntervalTicks = 20
-    private let patterns = LoadingPattern.allCases
-
-    private var isLoading: Bool {
-        self.showLoadingAnimation && self.snapshot == nil
-    }
-
-    var body: some View {
-        Group {
-            if let snapshot {
-                Image(nsImage: IconRenderer.makeIcon(
-                    primaryRemaining: snapshot.primary.remainingPercent,
-                    weeklyRemaining: snapshot.secondary?.remainingPercent,
-                    creditsRemaining: self.creditsRemaining,
-                    stale: self.isStale,
-                    style: self.style))
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, RunicSpacing.xxxs)
-            } else if self.showLoadingAnimation {
-                // Loading: animate bars with the current pattern until data arrives.
-                Image(nsImage: self.loadingImage)
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, RunicSpacing.xxxs)
-                    .onChange(of: self.displayLink.tick) { _, _ in
-                        self.phase += 0.09 // half-speed animation
-                        if self.debugCycle {
-                            self.cycleCounter += 1
-                            if self.cycleCounter >= self.cycleIntervalTicks {
-                                self.cycleCounter = 0
-                                self.cycleIndex = (self.cycleIndex + 1) % self.patterns.count
-                                self.pattern = self.patterns[self.cycleIndex]
-                            }
-                        }
-                    }
-            } else {
-                // No animation when usage/account is unavailable; show empty tracks.
-                Image(nsImage: IconRenderer.makeIcon(
-                    primaryRemaining: nil,
-                    weeklyRemaining: nil,
-                    creditsRemaining: self.creditsRemaining,
-                    stale: self.isStale,
-                    style: self.style))
-                    .renderingMode(.original)
-                    .interpolation(.none)
-                    .frame(width: 20, height: 18, alignment: .center)
-                    .padding(.horizontal, RunicSpacing.xxxs)
-            }
-        }
-        .onChange(of: self.isLoading, initial: true) { _, isLoading in
-            if isLoading {
-                self.displayLink.start(fps: self.loadingFPS)
-                if !self.debugCycle {
-                    self.pattern = self.patterns.randomElement() ?? .knightRider
-                }
-            } else {
-                self.displayLink.stop()
-                self.debugCycle = false
-                self.phase = 0
-            }
-        }
-        .onDisappear { self.displayLink.stop() }
-        .onReceive(NotificationCenter.default.publisher(for: .runicDebugReplayAllAnimations)) { notification in
-            if let raw = notification.userInfo?["pattern"] as? String,
-               let selected = LoadingPattern(rawValue: raw)
-            {
-                self.debugCycle = false
-                self.pattern = selected
-                self.cycleIndex = self.patterns.firstIndex(of: selected) ?? 0
-            } else {
-                self.debugCycle = true
-                self.cycleIndex = 0
-                self.pattern = self.patterns.first ?? .knightRider
-            }
-            self.cycleCounter = 0
-            self.phase = 0
-        }
-    }
-
-    private var loadingPrimary: Double {
-        self.pattern.value(phase: Double(self.phase))
-    }
-
-    private var loadingSecondary: Double {
-        self.pattern.value(phase: Double(self.phase + self.pattern.secondaryOffset))
-    }
-
-    private var loadingImage: NSImage {
-        if self.pattern == .unbraid {
-            let progress = self.loadingPrimary / 100
-            return IconRenderer.makeMorphIcon(progress: progress, style: self.style)
-        } else {
-            return IconRenderer.makeIcon(
-                primaryRemaining: self.loadingPrimary,
-                weeklyRemaining: self.loadingSecondary,
-                creditsRemaining: nil,
-                stale: false,
-                style: self.style)
-        }
-    }
-}

package/Sources/Runic/Core/Rendering/ProviderBrandIcon.swift

@@ -1,71 +0,0 @@
-import AppKit
-import RunicCore
-
-@MainActor
-enum ProviderBrandIcon {
-    private static let cache = NSCache<NSString, NSImage>()
-
-    static func image(for provider: UsageProvider, size: CGFloat = 16) -> NSImage? {
-        let cacheSize = Int(size.rounded())
-        let key = "\(provider.rawValue)-\(cacheSize)" as NSString
-        if let cached = self.cache.object(forKey: key) {
-            return cached
-        }
-
-        let baseName = ProviderDescriptorRegistry.descriptor(for: provider).branding.iconResourceName
-        guard let url = Bundle.main.url(forResource: baseName, withExtension: "svg"),
-              let image = NSImage(contentsOf: url)
-        else {
-            return nil
-        }
-
-        let targetSize = NSSize(width: size, height: size)
-        image.size = targetSize
-        image.isTemplate = true
-        let tinted = self.tintedImage(image, color: self.brandColor(for: provider), size: targetSize)
-        self.cache.setObject(tinted, forKey: key)
-        return tinted
-    }
-
-    static func templateImage(for provider: UsageProvider, size: CGFloat = 16) -> NSImage? {
-        let cacheSize = Int(size.rounded())
-        let key = "\(provider.rawValue)-\(cacheSize)-template" as NSString
-        if let cached = self.cache.object(forKey: key) {
-            return cached
-        }
-
-        let baseName = ProviderDescriptorRegistry.descriptor(for: provider).branding.iconResourceName
-        guard let url = Bundle.main.url(forResource: baseName, withExtension: "svg"),
-              let image = NSImage(contentsOf: url)
-        else {
-            return nil
-        }
-
-        image.size = NSSize(width: size, height: size)
-        image.isTemplate = true
-        self.cache.setObject(image, forKey: key)
-        return image
-    }
-
-    private static func brandColor(for provider: UsageProvider) -> NSColor {
-        let color = ProviderDescriptorRegistry.descriptor(for: provider).branding.color
-        return NSColor(
-            calibratedRed: CGFloat(color.red),
-            green: CGFloat(color.green),
-            blue: CGFloat(color.blue),
-            alpha: 1)
-    }
-
-    private static func tintedImage(_ image: NSImage, color: NSColor, size: NSSize) -> NSImage {
-        let rect = NSRect(origin: .zero, size: size)
-        // Use drawingHandler instead of deprecated lockFocus/unlockFocus.
-        let tinted = NSImage(size: size, flipped: false) { _ in
-            color.setFill()
-            rect.fill()
-            image.draw(in: rect, from: .zero, operation: .destinationIn, fraction: 1.0)
-            return true
-        }
-        tinted.isTemplate = false
-        return tinted
-    }
-}

package/Sources/Runic/Core/RunicAnimation.swift

@@ -1,53 +0,0 @@
-import SwiftUI
-
-/// Animation presets used across the Runic UI.
-enum RunicAnimation {
-    // MARK: - Spring Presets
-
-    /// Standard appear animation for progress bars and chart elements.
-    static let barAppear: Animation = .spring(response: 0.6, dampingFraction: 0.75)
-
-    /// Value-change animation for progress bars.
-    static let barUpdate: Animation = .spring(response: 0.5, dampingFraction: 0.8)
-
-    /// Menu content fade when switching providers.
-    static let providerSwitch: Animation = .easeInOut(duration: 0.25)
-
-    /// Highlight state transitions on menu items.
-    static let highlight: Animation = .easeOut(duration: 0.12)
-
-    // MARK: - Transition Durations
-
-    /// Duration for sheen / gloss sweeps on progress bars.
-    static let sheenDuration: Double = 0.9
-
-    /// Delay before sheen resets after sweeping.
-    static let sheenResetDelay: Duration = .seconds(1.1)
-
-    /// Duration for copy-confirmation checkmark display.
-    static let copyFeedbackDuration: Duration = .seconds(0.9)
-
-    /// Fade-out duration for copy confirmation revert.
-    static let copyFeedbackFadeOut: Animation = .easeOut(duration: 0.2)
-
-    // MARK: - Skeleton / Loading
-
-    /// Continuous shimmer animation for loading skeletons.
-    static let shimmer: Animation = .easeInOut(duration: 1.5).repeatForever(autoreverses: false)
-
-    /// Subtle hover feedback on interactive elements.
-    static let hoverFeedback: Animation = .easeInOut(duration: 0.15)
-
-    // MARK: - Chart Interaction
-
-    /// Fade animation for chart interaction hints.
-    static let chartHintFade: Animation = .easeOut(duration: 0.4)
-
-    // MARK: - Menu Card Entrance
-
-    /// Staggered spring entrance for menu card sections.
-    static let cardEntrance: Animation = .spring(response: 0.45, dampingFraction: 0.82)
-
-    /// Base delay between staggered card section entrances.
-    static let cardEntranceStagger: Double = 0.06
-}

package/Sources/Runic/Core/RunicColors.swift

@@ -1,73 +0,0 @@
-import SwiftUI
-
-/// Semantic color tokens for consistent theming across the Runic UI.
-enum RunicColors {
-    // MARK: - Status Colors
-
-    static let success = Color(nsColor: .systemGreen)
-    static let warning = Color(nsColor: .systemOrange)
-    static let error = Color(nsColor: .systemRed)
-    static let info = Color(nsColor: .systemBlue)
-
-    // MARK: - Chart Palette (6 accessible colors)
-
-    /// Ordered palette for chart series. Colors chosen for distinguishability in
-    /// both light and dark mode and for common color-vision deficiencies.
-    static let chartPalette: [Color] = [
-        Color(red: 0.26, green: 0.55, blue: 0.96), // blue
-        Color(red: 0.94, green: 0.53, blue: 0.18), // orange
-        Color(red: 0.46, green: 0.75, blue: 0.36), // green
-        Color(red: 0.80, green: 0.45, blue: 0.92), // purple
-        Color(red: 0.26, green: 0.78, blue: 0.86), // teal
-        Color(red: 0.94, green: 0.74, blue: 0.26), // yellow
-    ]
-
-    /// Returns a chart color for the given index, wrapping around if needed.
-    static func chartColor(at index: Int) -> Color {
-        self.chartPalette[index % self.chartPalette.count]
-    }
-
-    // MARK: - Model Family Colors
-
-    /// Color for Claude/Anthropic model family.
-    static let modelFamilyClaude = Color(red: 0.80, green: 0.45, blue: 0.30)
-    /// Color for GPT/OpenAI model family.
-    static let modelFamilyGPT = Color(red: 0.30, green: 0.70, blue: 0.40)
-    /// Color for Gemini/Google model family.
-    static let modelFamilyGemini = Color(red: 0.26, green: 0.55, blue: 0.96)
-    /// Default color for unknown model families.
-    static let modelFamilyDefault = Color(red: 0.55, green: 0.55, blue: 0.60)
-
-    /// Returns a color appropriate for the given model name based on its family.
-    static func colorForModel(_ model: String) -> Color {
-        let lower = model.lowercased()
-        if lower.contains("claude") || lower.contains("sonnet") || lower.contains("opus") || lower.contains("haiku") {
-            return self.modelFamilyClaude
-        }
-        if lower.contains("gpt") || lower.contains("o1") || lower.contains("o3") || lower.contains("o4") {
-            return self.modelFamilyGPT
-        }
-        if lower.contains("gemini") {
-            return self.modelFamilyGemini
-        }
-        return self.modelFamilyDefault
-    }
-
-    // MARK: - Named Chart Colors
-
-    /// Credits history chart bar color
-    static let creditsChartBar = Color(red: 73 / 255, green: 163 / 255, blue: 176 / 255)
-
-    // MARK: - Opacity Tokens
-
-    enum Opacity {
-        static let nano: Double = 0.045
-        static let subtle: Double = 0.08
-        static let light: Double = 0.12
-        static let medium: Double = 0.22
-        static let strong: Double = 0.35
-        static let emphasis: Double = 0.55
-        static let prominent: Double = 0.70
-        static let vivid: Double = 0.90
-    }
-}

package/Sources/Runic/Core/RunicCornerRadius.swift

@@ -1,15 +0,0 @@
-import Foundation
-
-/// Corner radius tokens replacing scattered literal values throughout the UI.
-enum RunicCornerRadius {
-    /// 4pt — badges, small tags, inline controls
-    static let xs: CGFloat = 4
-    /// 6pt — list rows, compact cards, buttons
-    static let sm: CGFloat = 6
-    /// 8pt — standard cards, menu sections
-    static let md: CGFloat = 8
-    /// 12pt — prominent panels, avatar frames, provider cards
-    static let lg: CGFloat = 12
-    /// 16pt — large icons, about pane, hero elements
-    static let xl: CGFloat = 16
-}

package/Sources/Runic/Core/RunicSpacing.swift

@@ -1,68 +0,0 @@
-import Foundation
-
-/// **Runic Spacing System**
-/// Defines global spacing constants following a 4pt grid system.
-/// All spacing values are multiples of 4 for consistent visual rhythm.
-enum RunicSpacing {
-    // MARK: - Base Spacing Scale
-
-    /// Extra extra extra small spacing (2pt)
-    static let xxxs: CGFloat = 2
-
-    /// Extra extra small spacing (4pt)
-    static let xxs: CGFloat = 4
-
-    /// Extra small spacing (8pt)
-    static let xs: CGFloat = 8
-
-    /// Small spacing (12pt)
-    static let sm: CGFloat = 12
-
-    /// Medium spacing (16pt)
-    static let md: CGFloat = 16
-
-    /// Large spacing (24pt)
-    static let lg: CGFloat = 24
-
-    /// Extra large spacing (32pt)
-    static let xl: CGFloat = 32
-
-    /// Extra extra large spacing (48pt)
-    static let xxl: CGFloat = 48
-
-    // MARK: - Semantic Spacing
-
-    /// Horizontal padding for menu content
-    static let menuHorizontalPadding: CGFloat = sm // 12pt
-
-    /// Vertical padding for menu content
-    static let menuVerticalPadding: CGFloat = xs // 8pt
-
-    /// Spacing between cards in menu
-    static let cardSpacing: CGFloat = xs // 8pt
-
-    /// Spacing between major sections
-    static let sectionSpacing: CGFloat = lg // 24pt
-
-    // MARK: - Preferences Spacing
-
-    /// Compact spacing (6pt) - Used between sm and xs, common in preference toggles
-    static let compact: CGFloat = 6
-
-    /// Standardized spacing for toggle rows
-    static let toggleRowSpacing: CGFloat = xs // 8pt
-
-    /// Spacing after section headers
-    static let sectionHeaderSpacing: CGFloat = md // 16pt
-
-    /// Spacing within stepper controls
-    static let stepperControlSpacing: CGFloat = xs // 8pt
-
-    // MARK: - Chart Metrics
-
-    /// Standard height for chart views in menus
-    static let chartHeight: CGFloat = 130
-
-    /// Diameter for legend dot indicators
-    static let chartLegendDot: CGFloat = 7
-}

package/Sources/Runic/Core/RunicTypography.swift

@@ -1,206 +0,0 @@
-import CoreText
-import SwiftUI
-
-// MARK: - Typography tokens
-
-/// App-wide font design token.
-enum RunicTypography {
-    static let typeSize: DynamicTypeSize = .xLarge
-
-    /// Register all TTF/OTF fonts found in the app bundle's Fonts directory.
-    /// Call once at launch before any UI is created.
-    static func registerFonts() {
-        guard let fontsURL = Bundle.main.url(forResource: "Fonts", withExtension: nil)
-            ?? Bundle.main.resourceURL?.appendingPathComponent("Fonts")
-        else { return }
-        guard let enumerator = FileManager.default.enumerator(
-            at: fontsURL,
-            includingPropertiesForKeys: nil,
-            options: [.skipsHiddenFiles])
-        else { return }
-        for case let fileURL as URL in enumerator
-            where fileURL.pathExtension.lowercased() == "ttf" || fileURL.pathExtension.lowercased() == "otf"
-        {
-            CTFontManagerRegisterFontsForURL(fileURL as CFURL, .process, nil)
-        }
-    }
-
-    /// Discover bundled font family names from the Fonts directory.
-    static func discoverBundledFontFamilies() -> [String] {
-        guard let fontsURL = Bundle.main.url(forResource: "Fonts", withExtension: nil)
-            ?? Bundle.main.resourceURL?.appendingPathComponent("Fonts")
-        else { return [] }
-        guard let enumerator = FileManager.default.enumerator(
-            at: fontsURL,
-            includingPropertiesForKeys: nil,
-            options: [.skipsHiddenFiles])
-        else { return [] }
-        var families = Set<String>()
-        for case let fileURL as URL in enumerator
-            where fileURL.pathExtension.lowercased() == "ttf" || fileURL.pathExtension.lowercased() == "otf"
-        {
-            if let descriptors = CTFontManagerCreateFontDescriptorsFromURL(fileURL as CFURL) as? [CTFontDescriptor] {
-                for desc in descriptors {
-                    if let name = CTFontDescriptorCopyAttribute(desc, kCTFontFamilyNameAttribute) as? String {
-                        families.insert(name)
-                    }
-                }
-            }
-        }
-        return families.sorted()
-    }
-}
-
-// MARK: - Available font choices
-
-/// A selectable font option shown in preferences.
-struct RunicFontChoice: Identifiable, Hashable {
-    let id: String
-    let displayName: String
-
-    /// System fonts — always available, no bundling.
-    static let sfPro = RunicFontChoice(id: "__sf_pro__", displayName: "SF Pro")
-    static let sfMono = RunicFontChoice(id: "__sf_mono__", displayName: "SF Mono")
-
-    /// Font used to render this choice's name in the picker (preview in its own typeface).
-    var previewFont: Font {
-        switch self.id {
-        case Self.sfPro.id: .system(.body)
-        case Self.sfMono.id: .system(.body, design: .monospaced)
-        default: Font.custom(self.id, fixedSize: 13)
-        }
-    }
-
-    /// Build the full list: system fonts first, then bundled custom fonts.
-    static func availableChoices() -> [RunicFontChoice] {
-        var choices: [RunicFontChoice] = [.sfPro, .sfMono]
-        for family in RunicTypography.discoverBundledFontFamilies() {
-            choices.append(RunicFontChoice(id: family, displayName: family))
-        }
-        return choices
-    }
-}
-
-// MARK: - Dynamic SwiftUI Font Scale
-
-@MainActor
-enum RunicFont {
-    /// The active font family identifier. Updated from SettingsStore.
-    static var family: String = "Fira Code"
-
-    private static var isSystemFont: Bool {
-        family.hasPrefix("__")
-    }
-
-    /// Font design used by `.runicTypography()` for system-font fallback.
-    static var systemFallbackDesign: Font.Design {
-        family == RunicFontChoice.sfPro.id ? .default : .monospaced
-    }
-
-    // MARK: Semantic sizes
-
-    static var caption2: Font {
-        makeFont(size: 10, relativeTo: .caption2)
-    }
-
-    static var caption: Font {
-        makeFont(size: 11, relativeTo: .caption)
-    }
-
-    static var footnote: Font {
-        makeFont(size: 12, relativeTo: .footnote)
-    }
-
-    static var callout: Font {
-        makeFont(size: 13, relativeTo: .callout)
-    }
-
-    static var body: Font {
-        makeFont(size: 13, relativeTo: .body)
-    }
-
-    static var subheadline: Font {
-        makeFont(size: 12, relativeTo: .subheadline)
-    }
-
-    static var headline: Font {
-        makeFont(size: 13, relativeTo: .headline).weight(.bold)
-    }
-
-    static var title3: Font {
-        makeFont(size: 15, relativeTo: .title3)
-    }
-
-    static var title2: Font {
-        makeFont(size: 17, relativeTo: .title2)
-    }
-
-    static var title: Font {
-        makeFont(size: 22, relativeTo: .title)
-    }
-
-    static var largeTitle: Font {
-        makeFont(size: 26, relativeTo: .largeTitle)
-    }
-
-    /// Custom fixed size.
-    static func system(size: CGFloat) -> Font {
-        switch self.family {
-        case RunicFontChoice.sfPro.id: .system(size: size)
-        case RunicFontChoice.sfMono.id: .system(size: size, design: .monospaced)
-        default: Font.custom(self.family, fixedSize: size)
-        }
-    }
-
-    /// Custom fixed size with weight.
-    static func system(size: CGFloat, weight: Font.Weight) -> Font {
-        switch self.family {
-        case RunicFontChoice.sfPro.id: .system(size: size, weight: weight)
-        case RunicFontChoice.sfMono.id: .system(size: size, weight: weight, design: .monospaced)
-        default: Font.custom(self.family, fixedSize: size).weight(weight)
-        }
-    }
-
-    // MARK: Private
-
-    private static func makeFont(size: CGFloat, relativeTo style: Font.TextStyle) -> Font {
-        switch self.family {
-        case RunicFontChoice.sfPro.id: .system(style)
-        case RunicFontChoice.sfMono.id: .system(style, design: .monospaced)
-        default: Font.custom(self.family, size: size, relativeTo: style)
-        }
-    }
-}
-
-// MARK: - AppKit NSFont
-
-extension RunicFont {
-    static func nsFont(size: CGFloat, weight: NSFont.Weight = .regular) -> NSFont {
-        switch self.family {
-        case RunicFontChoice.sfPro.id:
-            return .systemFont(ofSize: size, weight: weight)
-        case RunicFontChoice.sfMono.id:
-            return .monospacedSystemFont(ofSize: size, weight: weight)
-        default:
-            let traits: [NSFontDescriptor.TraitKey: Any] = [.weight: weight]
-            let descriptor = NSFontDescriptor(fontAttributes: [
-                .family: family,
-                .traits: traits,
-            ])
-            return NSFont(descriptor: descriptor, size: size)
-                ?? .monospacedSystemFont(ofSize: size, weight: weight)
-        }
-    }
-}
-
-// MARK: - View modifier
-
-extension View {
-    /// Apply the selected font as the default, with system fallback design and xLarge dynamic type.
-    func runicTypography() -> some View {
-        self
-            .font(RunicFont.body)
-            .fontDesign(RunicFont.systemFallbackDesign)
-            .dynamicTypeSize(RunicTypography.typeSize)
-    }
-}