@sriinnu/runic 1.2.0 → 2.11.1

package/Sources/Runic/Views/Menu/MenuContent.swift

@@ -1,150 +0,0 @@
-import AppKit
-import RunicCore
-import SwiftUI
-
-enum MenuContentMetrics {
-    /// Horizontal padding for menu content
-    static let horizontalPadding: CGFloat = RunicSpacing.sm  // 12
-
-    /// Vertical padding for menu content
-    static let verticalPadding: CGFloat = RunicSpacing.xs  // 8
-
-    /// Spacing between menu sections
-    static let sectionSpacing: CGFloat = RunicSpacing.xs  // 8
-
-    /// Spacing between menu entries
-    static let entrySpacing: CGFloat = RunicSpacing.xxs  // 4
-
-    /// Minimum menu width
-    static let minWidth: CGFloat = 260
-}
-
-@MainActor
-struct MenuContent: View {
-    @Bindable var store: UsageStore
-    @Bindable var settings: SettingsStore
-    let account: AccountInfo
-    let updater: UpdaterProviding
-    let provider: UsageProvider?
-    let actions: MenuActions
-
-    var body: some View {
-        let descriptor = MenuDescriptor.build(
-            provider: self.provider,
-            store: self.store,
-            settings: self.settings,
-            account: self.account,
-            updateReady: self.updater.updateStatus.isUpdateReady)
-
-        VStack(alignment: .leading, spacing: MenuContentMetrics.sectionSpacing) {
-            ForEach(Array(descriptor.sections.enumerated()), id: \.offset) { index, section in
-                VStack(alignment: .leading, spacing: MenuContentMetrics.entrySpacing) {
-                    ForEach(Array(section.entries.enumerated()), id: \.offset) { _, entry in
-                        self.row(for: entry)
-                    }
-                }
-                if index < descriptor.sections.count - 1 {
-                    Divider()
-                        .padding(.vertical, RunicSpacing.xxs)
-                }
-            }
-        }
-        .padding(.horizontal, MenuContentMetrics.horizontalPadding)
-        .padding(.vertical, MenuContentMetrics.verticalPadding)
-        .frame(minWidth: MenuContentMetrics.minWidth, alignment: .leading)
-    }
-
-    @ViewBuilder
-    private func row(for entry: MenuDescriptor.Entry) -> some View {
-        switch entry {
-        case let .text(text, style):
-            switch style {
-            case .headline:
-                Text(text).font(.headline)
-            case .primary:
-                Text(text)
-            case .secondary:
-                Text(text).foregroundStyle(.secondary).font(.footnote)
-            }
-        case let .action(title, action):
-            Button {
-                self.perform(action)
-            } label: {
-                if let icon = self.iconName(for: action) {
-                    HStack(spacing: 8) {
-                        Image(systemName: icon)
-                            .imageScale(.medium)
-                            .frame(width: 18, alignment: .center)
-                        Text(title)
-                    }
-                    .foregroundStyle(.primary)
-                } else {
-                    Text(title)
-                }
-            }
-            .buttonStyle(.plain)
-        case .divider:
-            Divider()
-                .padding(.vertical, RunicSpacing.xxs)
-        }
-    }
-
-    private func iconName(for action: MenuDescriptor.MenuAction) -> String? { action.systemImageName }
-
-    private func perform(_ action: MenuDescriptor.MenuAction) {
-        switch action {
-        case .refresh:
-            self.actions.refresh()
-        case .installUpdate:
-            self.actions.installUpdate()
-        case .dashboard:
-            self.actions.openDashboard()
-        case .statusPage:
-            self.actions.openStatusPage()
-        case let .switchAccount(provider):
-            self.actions.switchAccount(provider)
-        case .settings:
-            self.actions.openSettings()
-        case .about:
-            self.actions.openAbout()
-        case .quit:
-            self.actions.quit()
-        case let .copyError(message):
-            self.actions.copyError(message)
-        }
-    }
-}
-
-struct MenuActions {
-    let installUpdate: () -> Void
-    let refresh: () -> Void
-    let openDashboard: () -> Void
-    let openStatusPage: () -> Void
-    let switchAccount: (UsageProvider) -> Void
-    let openSettings: () -> Void
-    let openAbout: () -> Void
-    let quit: () -> Void
-    let copyError: (String) -> Void
-}
-
-@MainActor
-struct StatusIconView: View {
-    @Bindable var store: UsageStore
-    let provider: UsageProvider
-
-    var body: some View {
-        Image(nsImage: self.icon)
-            .renderingMode(.template)
-            .interpolation(.none)
-    }
-
-    private var icon: NSImage {
-        IconRenderer.makeIcon(
-            primaryRemaining: self.store.snapshot(for: self.provider)?.primary.remainingPercent,
-            weeklyRemaining: self.store.snapshot(for: self.provider)?.secondary?.remainingPercent,
-            creditsRemaining: self.provider == .codex ? self.store.credits?.remaining : nil,
-            stale: self.store.isStale(provider: self.provider),
-            style: self.store.style(for: self.provider),
-            statusIndicator: self.store.statusIndicator(for: self.provider))
-    }
-}

package/Sources/Runic/Views/Menu/MenuDescriptor.swift

@@ -1,369 +0,0 @@
-import RunicCore
-import Foundation
-
-@MainActor
-struct MenuDescriptor {
-    struct Section {
-        var entries: [Entry]
-    }
-
-    enum Entry {
-        case text(String, TextStyle)
-        case action(String, MenuAction)
-        case divider
-    }
-
-    enum MenuActionSystemImage: String {
-        case refresh = "arrow.clockwise"
-        case dashboard = "chart.bar"
-        case statusPage = "waveform.path.ecg"
-        case switchAccount = "key"
-        case settings = "gearshape"
-        case about = "info.circle"
-        case quit = "xmark.rectangle"
-        case copyError = "doc.on.doc"
-    }
-
-    enum TextStyle {
-        case headline
-        case primary
-        case secondary
-    }
-
-    enum MenuAction {
-        case installUpdate
-        case refresh
-        case dashboard
-        case statusPage
-        case switchAccount(UsageProvider)
-        case settings
-        case about
-        case quit
-        case copyError(String)
-    }
-
-    var sections: [Section]
-
-    static func build(
-        provider: UsageProvider?,
-        store: UsageStore,
-        settings: SettingsStore,
-        account: AccountInfo,
-        updateReady: Bool) -> MenuDescriptor
-    {
-        var sections: [Section] = []
-
-        switch provider {
-        case .codex?:
-            sections.append(Self.usageSection(for: .codex, store: store, settings: settings))
-            if let accountSection = Self.accountSection(for: .codex, store: store, account: account) {
-                sections.append(accountSection)
-            }
-        case .claude?:
-            sections.append(Self.usageSection(for: .claude, store: store, settings: settings))
-            if let accountSection = Self.accountSection(for: .claude, store: store, account: account) {
-                sections.append(accountSection)
-            }
-        case let provider?:
-            sections.append(Self.usageSection(for: provider, store: store, settings: settings))
-            if let accountSection = Self.accountSection(for: provider, store: store, account: account) {
-                sections.append(accountSection)
-            }
-        case nil:
-            var addedUsage = false
-
-            for enabledProvider in store.enabledProviders() {
-                sections.append(Self.usageSection(for: enabledProvider, store: store, settings: settings))
-                addedUsage = true
-            }
-            if addedUsage {
-                if let accountProvider = Self.accountProviderForCombined(store: store),
-                   let accountSection = Self.accountSection(for: accountProvider, store: store, account: account)
-                {
-                    sections.append(accountSection)
-                }
-            } else {
-                sections.append(Section(entries: [.text("No usage configured.", .secondary)]))
-            }
-        }
-
-        let actions = Self.actionsSection(for: provider, store: store, settings: settings, account: account)
-        if !actions.entries.isEmpty {
-            sections.append(actions)
-        }
-        sections.append(Self.metaSection(updateReady: updateReady))
-
-        return MenuDescriptor(sections: sections)
-    }
-
-    private static func usageSection(
-        for provider: UsageProvider,
-        store: UsageStore,
-        settings: SettingsStore) -> Section
-    {
-        let meta = store.metadata(for: provider)
-        var entries: [Entry] = []
-        let headlineText: String = {
-            if let ver = Self.versionNumber(for: provider, store: store) { return "\(meta.displayName) \(ver)" }
-            return meta.displayName
-        }()
-        entries.append(.text(headlineText, .headline))
-
-        if let snap = store.snapshot(for: provider) {
-            Self.appendRateWindow(entries: &entries, title: meta.sessionLabel, window: snap.primary)
-            if let weekly = snap.secondary {
-                Self.appendRateWindow(entries: &entries, title: meta.weeklyLabel, window: weekly)
-                if let paceText = UsagePaceText.weekly(provider: provider, window: weekly) {
-                    entries.append(.text(paceText, .secondary))
-                }
-            } else if provider == .claude {
-                entries.append(.text("Weekly usage unavailable for this account.", .secondary))
-            }
-            if meta.supportsOpus, let opus = snap.tertiary {
-                Self.appendRateWindow(entries: &entries, title: meta.opusLabel ?? "Sonnet", window: opus)
-            }
-
-            if settings.showOptionalCreditsAndExtraUsage,
-               provider == .claude,
-               let cost = snap.providerCost
-            {
-                let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
-                let limit = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
-                entries.append(.text("Extra usage: \(used) / \(limit)", .primary))
-            }
-
-            if provider == .cursor, let cost = snap.providerCost {
-                let used = UsageFormatter.currencyString(cost.used, currencyCode: cost.currencyCode)
-                if cost.limit > 0 {
-                    let limitStr = UsageFormatter.currencyString(cost.limit, currencyCode: cost.currencyCode)
-                    entries.append(.text("On-Demand: \(used) / \(limitStr)", .primary))
-                } else {
-                    entries.append(.text("On-Demand: \(used)", .primary))
-                }
-            }
-        } else {
-            entries.append(.text("No usage yet", .secondary))
-        }
-
-        if settings.showOptionalCreditsAndExtraUsage,
-           meta.supportsCredits,
-           provider == .codex
-        {
-            if let credits = store.credits {
-                entries.append(.text("Credits: \(UsageFormatter.creditsString(from: credits.remaining))", .primary))
-                if let latest = credits.events.first {
-                    entries.append(.text("Last spend: \(UsageFormatter.creditEventSummary(latest))", .secondary))
-                }
-            } else {
-                let hint = store.lastCreditsError ?? meta.creditsHint
-                entries.append(.text(hint, .secondary))
-            }
-        }
-
-        return Section(entries: entries)
-    }
-
-    private static func accountSection(
-        for provider: UsageProvider,
-        store: UsageStore,
-        account: AccountInfo) -> Section?
-    {
-        let snapshot = store.snapshot(for: provider)
-        let metadata = store.metadata(for: provider)
-        let entries = Self.accountEntries(
-            provider: provider,
-            snapshot: snapshot,
-            metadata: metadata,
-            fallback: account)
-        guard !entries.isEmpty else { return nil }
-        return Section(entries: entries)
-    }
-
-    private static func accountEntries(
-        provider: UsageProvider,
-        snapshot: UsageSnapshot?,
-        metadata: ProviderMetadata,
-        fallback: AccountInfo) -> [Entry]
-    {
-        var entries: [Entry] = []
-        let emailText = snapshot?.accountEmail(for: provider)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-        let planText = snapshot?.loginMethod(for: provider)?
-            .trimmingCharacters(in: .whitespacesAndNewlines)
-
-        if let emailText, !emailText.isEmpty {
-            entries.append(.text("Account: \(emailText)", .secondary))
-        }
-        if let planText, !planText.isEmpty {
-            entries.append(.text("Plan: \(AccountFormatter.plan(planText))", .secondary))
-        }
-
-        if metadata.usesAccountFallback {
-            if emailText?.isEmpty ?? true, let fallbackEmail = fallback.email, !fallbackEmail.isEmpty {
-                entries.append(.text("Account: \(fallbackEmail)", .secondary))
-            }
-            if planText?.isEmpty ?? true, let fallbackPlan = fallback.plan, !fallbackPlan.isEmpty {
-                entries.append(.text("Plan: \(AccountFormatter.plan(fallbackPlan))", .secondary))
-            }
-        }
-
-        return entries
-    }
-
-    private static func accountProviderForCombined(store: UsageStore) -> UsageProvider? {
-        for provider in store.enabledProviders() {
-            let metadata = store.metadata(for: provider)
-            if store.snapshot(for: provider)?.identity(for: provider) != nil {
-                return provider
-            }
-            if metadata.usesAccountFallback {
-                return provider
-            }
-        }
-        return nil
-    }
-
-    private static func actionsSection(
-        for provider: UsageProvider?,
-        store: UsageStore,
-        settings: SettingsStore,
-        account: AccountInfo) -> Section
-    {
-        var entries: [Entry] = []
-        let targetProvider = provider ?? store.enabledProviders().first
-        let metadata = targetProvider.map { store.metadata(for: $0) }
-
-        // Show "Add Account" if no account, "Switch Account" if logged in
-        if let targetProvider,
-           ProviderCatalog.implementation(for: targetProvider)?.supportsLoginFlow == true
-        {
-            let loginAction = self.switchAccountTarget(for: provider, store: store)
-            let hasAccount = self.hasAccount(for: provider, store: store, account: account)
-            let accountLabel = hasAccount ? "Switch Account..." : "Add Account..."
-            entries.append(.action(accountLabel, loginAction))
-        }
-
-        entries.append(.action("Ping now", .refresh))
-        if let refreshLine = store.autoRefreshStatusLine() {
-            entries.append(.text(refreshLine, .secondary))
-        }
-        if let lastRefreshLine = store.lastRefreshStatusLine() {
-            entries.append(.text(lastRefreshLine, .secondary))
-        }
-
-        if metadata?.dashboardURL != nil {
-            entries.append(.action("Usage Dashboard", .dashboard))
-        }
-        if metadata?.statusPageURL != nil || metadata?.statusLinkURL != nil {
-            entries.append(.action("Status Page", .statusPage))
-        }
-
-        if let statusLine = self.statusLine(for: provider, store: store) {
-            entries.append(.text(statusLine, .secondary))
-        }
-
-        return Section(entries: entries)
-    }
-
-    private static func metaSection(updateReady: Bool) -> Section {
-        var entries: [Entry] = []
-        if updateReady {
-            entries.append(.action("Update ready, restart now?", .installUpdate))
-        }
-        entries.append(contentsOf: [
-            .action("Settings...", .settings),
-            .action("About Runic", .about),
-            .action("Quit", .quit),
-        ])
-        return Section(entries: entries)
-    }
-
-    private static func statusLine(for provider: UsageProvider?, store: UsageStore) -> String? {
-        let target = provider ?? store.enabledProviders().first
-        guard let target,
-              let status = store.status(for: target),
-              status.indicator != .none else { return nil }
-
-        let description = status.description?.trimmingCharacters(in: .whitespacesAndNewlines)
-        let label = description?.isEmpty == false ? description! : status.indicator.label
-        if let updated = status.updatedAt {
-            let freshness = UsageFormatter.updatedString(from: updated)
-            return "\(label) — \(freshness)"
-        }
-        return label
-    }
-
-    private static func switchAccountTarget(for provider: UsageProvider?, store: UsageStore) -> MenuAction {
-        if let provider { return .switchAccount(provider) }
-        if let enabled = store.enabledProviders().first { return .switchAccount(enabled) }
-        return .switchAccount(.codex)
-    }
-
-    private static func hasAccount(for provider: UsageProvider?, store: UsageStore, account: AccountInfo) -> Bool {
-        let target = provider ?? store.enabledProviders().first ?? .codex
-        if let email = store.snapshot(for: target)?.accountEmail(for: target),
-           !email.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty
-        {
-            return true
-        }
-        let metadata = store.metadata(for: target)
-        if metadata.usesAccountFallback,
-           let fallback = account.email?.trimmingCharacters(in: .whitespacesAndNewlines),
-           !fallback.isEmpty
-        {
-            return true
-        }
-        return false
-    }
-
-    private static func appendRateWindow(entries: inout [Entry], title: String, window: RateWindow) {
-        let line = UsageFormatter
-            .usageLine(remaining: window.remainingPercent, used: window.usedPercent)
-        entries.append(.text("\(title): \(line)", .primary))
-        if let date = window.resetsAt {
-            let countdown = UsageFormatter.resetCountdownDescription(from: date)
-            entries.append(.text("Resets \(countdown)", .secondary))
-        } else if let reset = window.resetDescription {
-            entries.append(.text(Self.resetLine(reset), .secondary))
-        }
-    }
-
-    private static func resetLine(_ reset: String) -> String {
-        let trimmed = reset.trimmingCharacters(in: .whitespacesAndNewlines)
-        if trimmed.lowercased().hasPrefix("resets") { return trimmed }
-        return "Resets \(trimmed)"
-    }
-
-    private static func versionNumber(for provider: UsageProvider, store: UsageStore) -> String? {
-        guard let raw = store.version(for: provider) else { return nil }
-        let pattern = #"[0-9]+(?:\.[0-9]+)*"#
-        guard let regex = try? NSRegularExpression(pattern: pattern) else { return nil }
-        let range = NSRange(raw.startIndex..<raw.endIndex, in: raw)
-        guard let match = regex.firstMatch(in: raw, options: [], range: range),
-              let r = Range(match.range, in: raw) else { return nil }
-        return String(raw[r])
-    }
-}
-
-private enum AccountFormatter {
-    static func plan(_ text: String) -> String {
-        let cleaned = UsageFormatter.cleanPlanName(text)
-        return cleaned.isEmpty ? text : cleaned
-    }
-
-    static func email(_ text: String) -> String { text }
-}
-
-extension MenuDescriptor.MenuAction {
-    var systemImageName: String? {
-        switch self {
-        case .installUpdate, .settings, .about, .quit:
-            nil
-        case .refresh: MenuDescriptor.MenuActionSystemImage.refresh.rawValue
-        case .dashboard: MenuDescriptor.MenuActionSystemImage.dashboard.rawValue
-        case .statusPage: MenuDescriptor.MenuActionSystemImage.statusPage.rawValue
-        case .switchAccount: MenuDescriptor.MenuActionSystemImage.switchAccount.rawValue
-        case .copyError: MenuDescriptor.MenuActionSystemImage.copyError.rawValue
-        }
-    }
-}

package/Sources/Runic/Views/Menu/MenuHighlightStyle.swift

@@ -1,42 +0,0 @@
-import SwiftUI
-
-private struct MenuItemHighlightedKey: EnvironmentKey {
-    static let defaultValue = false
-}
-
-extension EnvironmentValues {
-    var menuItemHighlighted: Bool {
-        get { self[MenuItemHighlightedKey.self] }
-        set { self[MenuItemHighlightedKey.self] = newValue }
-    }
-}
-
-enum MenuHighlightStyle {
-    static let selectionText = Color(nsColor: .selectedMenuItemTextColor)
-    static let normalPrimaryText = Color(nsColor: .controlTextColor)
-    static let normalSecondaryText = Color(nsColor: .secondaryLabelColor)
-
-    static func primary(_ highlighted: Bool) -> Color {
-        highlighted ? self.selectionText : self.normalPrimaryText
-    }
-
-    static func secondary(_ highlighted: Bool) -> Color {
-        highlighted ? self.selectionText : self.normalSecondaryText
-    }
-
-    static func error(_ highlighted: Bool) -> Color {
-        highlighted ? self.selectionText : Color(nsColor: .systemRed)
-    }
-
-    static func progressTrack(_ highlighted: Bool) -> Color {
-        highlighted ? self.selectionText.opacity(0.22) : Color(nsColor: .tertiaryLabelColor).opacity(0.22)
-    }
-
-    static func progressTint(_ highlighted: Bool, fallback: Color) -> Color {
-        highlighted ? self.selectionText : fallback
-    }
-
-    static func selectionBackground(_ highlighted: Bool) -> Color {
-        highlighted ? Color(nsColor: .selectedContentBackgroundColor) : .clear
-    }
-}