@sriinnu/runic 1.0.0 → 2.0.0

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

@@ -11,10 +11,10 @@ struct EfficiencyMetricsMenuView: View {
 
         var label: String {
             switch self {
-            case .model: return "Model"
-            case .tokensPerRequest: return "Tokens/Req"
-            case .costPerRequest: return "Cost/Req"
-            case .cacheHitRate: return "Cache Hit %"
+            case .model: "Model"
+            case .tokensPerRequest: "Tokens/Req"
+            case .costPerRequest: "Cost/Req"
+            case .cacheHitRate: "Cache Hit %"
             }
         }
     }
@@ -65,12 +65,12 @@ struct EfficiencyMetricsMenuView: View {
 
         VStack(alignment: .leading, spacing: RunicSpacing.sm) {
             Text("Efficiency Metrics")
-                .font(.headline)
+                .font(RunicFont.headline)
                 .fontWeight(.semibold)
 
             if model.isEmpty {
                 Text("No efficiency metrics available.")
-                    .font(.footnote)
+                    .font(RunicFont.footnote)
                     .foregroundStyle(.secondary)
             } else {
                 VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
@@ -134,27 +134,27 @@ struct EfficiencyMetricsMenuView: View {
                 HStack(spacing: RunicSpacing.lg) {
                     VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                         Text("Total Requests")
-                            .font(.caption2)
+                            .font(RunicFont.caption2)
                             .foregroundStyle(.secondary)
                         Text("\(Self.totalRequests(model))")
-                            .font(.caption)
+                            .font(RunicFont.caption)
                             .fontWeight(.medium)
                     }
                     VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                         Text("Avg Tokens/Req")
-                            .font(.caption2)
+                            .font(RunicFont.caption2)
                             .foregroundStyle(.secondary)
                         Text(UsageFormatter.tokenCountString(Self.averageTokensPerRequest(model)))
-                            .font(.caption)
+                            .font(RunicFont.caption)
                             .fontWeight(.medium)
                     }
                     if Self.hasAnyCost(model) {
                         VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                             Text("Avg Cost/Req")
-                                .font(.caption2)
+                                .font(RunicFont.caption2)
                                 .foregroundStyle(.secondary)
                             Text(UsageFormatter.usdString(Self.averageCostPerRequest(model)))
-                                .font(.caption)
+                                .font(RunicFont.caption)
                                 .fontWeight(.medium)
                         }
                     }
@@ -181,7 +181,7 @@ struct EfficiencyMetricsMenuView: View {
         ascending: Bool) -> [ModelMetrics]
     {
         let metrics = summaries.map { ModelMetrics(summary: $0) }
-        let sorted = metrics.sorted { lhs, rhs in
+        return metrics.sorted { lhs, rhs in
             let result: Bool
             switch sortBy {
             case .model:
@@ -197,7 +197,6 @@ struct EfficiencyMetricsMenuView: View {
             }
             return ascending ? result : !result
         }
-        return sorted
     }
 
     private static func totalRequests(_ metrics: [ModelMetrics]) -> Int {
@@ -237,12 +236,12 @@ private struct SortableColumnHeader: View {
         } label: {
             HStack(spacing: RunicSpacing.xxs) {
                 Text(self.title)
-                    .font(.caption)
+                    .font(RunicFont.caption)
                     .foregroundStyle(.secondary)
                     .fontWeight(.medium)
                 if self.currentSort == self.column {
                     Image(systemName: self.ascending ? "chevron.up" : "chevron.down")
-                        .font(.caption2)
+                        .font(RunicFont.caption2)
                         .foregroundStyle(.secondary)
                 }
             }
@@ -259,34 +258,34 @@ private struct MetricsRow: View {
     var body: some View {
         HStack(spacing: 0) {
             VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
-                Text(UsageFormatter.modelDisplayName(metrics.modelName))
-                    .font(.caption)
+                Text(UsageFormatter.modelDisplayName(self.metrics.modelName))
+                    .font(RunicFont.caption)
                     .lineLimit(1)
                     .truncationMode(.tail)
                 if let context = UsageFormatter.modelContextLabel(for: metrics.modelName) {
                     Text(context)
-                        .font(.caption2)
+                        .font(RunicFont.caption2)
                         .foregroundStyle(.secondary)
                         .lineLimit(1)
                         .truncationMode(.tail)
                 }
             }
             .frame(width: 140, alignment: .leading)
-            Text(UsageFormatter.tokenCountString(Int(metrics.tokensPerRequest)))
-                .font(.caption)
+            Text(UsageFormatter.tokenCountString(Int(self.metrics.tokensPerRequest)))
+                .font(RunicFont.caption)
                 .frame(width: 90, alignment: .leading)
             if let cost = metrics.costPerRequest {
                 Text(UsageFormatter.usdString(cost))
-                    .font(.caption)
+                    .font(RunicFont.caption)
                     .frame(width: 80, alignment: .leading)
             } else {
                 Text("—")
-                    .font(.caption)
+                    .font(RunicFont.caption)
                     .foregroundStyle(.secondary)
                     .frame(width: 80, alignment: .leading)
             }
-            Text(String(format: "%.1f%%", metrics.cacheHitRate * 100))
-                .font(.caption)
+            Text(String(format: "%.1f%%", self.metrics.cacheHitRate * 100))
+                .font(RunicFont.caption)
                 .foregroundStyle(self.cacheHitColor)
                 .frame(width: 80, alignment: .leading)
         }
@@ -301,12 +300,12 @@ private struct MetricsRow: View {
     }
 
     private var cacheHitColor: Color {
-        if metrics.cacheHitRate > 0.5 {
-            return Color(red: 0.46, green: 0.75, blue: 0.36)
-        } else if metrics.cacheHitRate > 0.2 {
-            return Color(red: 0.94, green: 0.74, blue: 0.26)
+        if self.metrics.cacheHitRate > 0.5 {
+            Color(red: 0.46, green: 0.75, blue: 0.36)
+        } else if self.metrics.cacheHitRate > 0.2 {
+            Color(red: 0.94, green: 0.74, blue: 0.26)
         } else {
-            return .secondary
+            .secondary
         }
     }
 }

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

@@ -26,32 +26,32 @@ struct HeroTodayStatView: View {
             VStack(alignment: .leading, spacing: 0) {
                 HStack(alignment: .firstTextBaseline, spacing: RunicSpacing.xxs) {
                     Text(UsageFormatter.tokenCountString(self.tokenCount))
-                        .font(.system(size: 26, weight: .bold, design: .rounded))
+                        .font(RunicFont.system(size: 26, weight: .bold))
                         .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
                     Text("today")
-                        .font(.system(.subheadline, design: .rounded))
+                        .font(RunicFont.subheadline)
                         .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                 }
             }
             Spacer()
             if let cost = self.costUSD, cost > 0 {
                 Text(UsageFormatter.usdString(cost))
-                    .font(.system(.subheadline, design: .rounded))
+                    .font(RunicFont.subheadline)
                     .fontWeight(.medium)
                     .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
                     .padding(.horizontal, RunicSpacing.xs)
                     .padding(.vertical, RunicSpacing.xxxs)
                     .background(
                         Capsule(style: .continuous)
-                            .fill(Color(nsColor: .controlBackgroundColor).opacity(RunicColors.Opacity.light))
-                    )
+                            .fill(Color(nsColor: .controlBackgroundColor).opacity(RunicColors.Opacity.light)))
             }
         }
         .padding(.horizontal, MenuCardMetrics.horizontalPadding)
         .padding(.vertical, RunicSpacing.xxs)
         .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
         .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Today usage: \(UsageFormatter.tokenCountString(self.tokenCount)) tokens\(self.costUSD.map { ", \(UsageFormatter.usdString($0))" } ?? "")")
+        .accessibilityLabel(
+            "Today usage: \(UsageFormatter.tokenCountString(self.tokenCount)) tokens\(self.costUSD.map { ", \(UsageFormatter.usdString($0))" } ?? "")")
     }
 }
 
@@ -89,7 +89,8 @@ struct GlassmorphismStatCardsView: View {
         .padding(.vertical, RunicSpacing.xxs)
         .frame(minWidth: self.width, maxWidth: .infinity, alignment: .leading)
         .accessibilityElement(children: .ignore)
-        .accessibilityLabel("Peak hour \(self.peakHourLabel), \(self.peakHourTokens). This week \(self.weekTotalTokens)")
+        .accessibilityLabel(
+            "Peak hour \(self.peakHourLabel), \(self.peakHourTokens). This week \(self.weekTotalTokens)")
     }
 }
 
@@ -104,18 +105,18 @@ private struct GlassStatCard: View {
     var body: some View {
         VStack(alignment: .leading, spacing: RunicSpacing.xxs) {
             Text(self.title)
-                .font(.system(.caption2, design: .rounded))
+                .font(RunicFont.caption2)
                 .fontWeight(.medium)
                 .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
             MiniSparklineView(data: self.sparkline, color: self.sparkColor)
                 .frame(height: 24)
             Text(self.value)
-                .font(.system(.title3, design: .rounded))
+                .font(RunicFont.title3)
                 .fontWeight(.bold)
                 .foregroundStyle(MenuHighlightStyle.primary(self.isHighlighted))
             if let detail {
                 Text(detail)
-                    .font(.system(.caption2, design: .rounded))
+                    .font(RunicFont.caption2)
                     .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted))
             }
         }
@@ -123,12 +124,10 @@ private struct GlassStatCard: View {
         .frame(maxWidth: .infinity, alignment: .leading)
         .background(
             RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)
-                .fill(.ultraThinMaterial)
-        )
+                .fill(.ultraThinMaterial))
         .overlay(
             RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)
-                .stroke(Color(nsColor: .separatorColor).opacity(RunicColors.Opacity.medium), lineWidth: 0.5)
-        )
+                .stroke(Color(nsColor: .separatorColor).opacity(RunicColors.Opacity.medium), lineWidth: 0.5))
         .shadow(color: .black.opacity(0.08), radius: 4, y: 2)
         .glassShimmer()
     }
@@ -147,7 +146,9 @@ private struct MiniSparklineView: View {
                 // Filled gradient area under the line
                 Path { path in
                     path.move(to: CGPoint(x: points[0].x, y: geo.size.height))
-                    for point in points { path.addLine(to: point) }
+                    for point in points {
+                        path.addLine(to: point)
+                    }
                     path.addLine(to: CGPoint(x: points.last!.x, y: geo.size.height))
                     path.closeSubpath()
                 }
@@ -159,7 +160,9 @@ private struct MiniSparklineView: View {
                 // Line stroke
                 Path { path in
                     path.move(to: points[0])
-                    for point in points.dropFirst() { path.addLine(to: point) }
+                    for point in points.dropFirst() {
+                        path.addLine(to: point)
+                    }
                 }
                 .stroke(self.color, style: StrokeStyle(lineWidth: 1.5, lineCap: .round, lineJoin: .round))
             } else if self.data.count == 1, maxVal > 0 {
@@ -199,7 +202,7 @@ struct UpdatedTimestampView: View {
         TimelineView(.periodic(from: .now, by: 5)) { context in
             let text = Self.relativeString(from: self.updatedAt, to: context.date)
             Text(text)
-                .font(.system(.caption2, design: .rounded))
+                .font(RunicFont.caption2)
                 .foregroundStyle(MenuHighlightStyle.secondary(self.isHighlighted).opacity(0.7))
         }
         .padding(.horizontal, MenuCardMetrics.horizontalPadding)

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

@@ -38,19 +38,19 @@ struct HourlyActivityChartMenuView: View {
             // Header
             HStack(alignment: .firstTextBaseline) {
                 Text("Today by Hour")
-                    .font(.system(.subheadline, design: .rounded))
+                    .font(RunicFont.subheadline)
                     .fontWeight(.semibold)
                 Spacer()
                 if let peak = model.peakHour {
                     Text("Peak \(peak.label)")
-                        .font(.system(.caption, design: .rounded))
+                        .font(RunicFont.caption)
                         .foregroundStyle(.secondary)
                 }
             }
 
             if model.bars.allSatisfy({ $0.totalTokens == 0 }) {
                 Text("No usage recorded today.")
-                    .font(.system(.footnote, design: .rounded))
+                    .font(RunicFont.footnote)
                     .foregroundStyle(.secondary)
                     .frame(height: 80)
             } else {
@@ -70,7 +70,7 @@ struct HourlyActivityChartMenuView: View {
                             .foregroundStyle(Color(nsColor: .labelColor).opacity(0.3))
                             .annotation(position: .top, spacing: 4) {
                                 Text(UsageFormatter.tokenCountString(bar.totalTokens))
-                                    .font(.system(.caption2, design: .rounded))
+                                    .font(RunicFont.caption2)
                                     .fontWeight(.medium)
                                     .padding(.horizontal, 6)
                                     .padding(.vertical, 2)
@@ -85,7 +85,7 @@ struct HourlyActivityChartMenuView: View {
                         AxisValueLabel {
                             if let hour = value.as(Int.self) {
                                 Text(Self.hourAxisLabel(hour))
-                                    .font(.system(.caption2, design: .rounded))
+                                    .font(RunicFont.caption2)
                                     .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
                             }
                         }
@@ -98,7 +98,7 @@ struct HourlyActivityChartMenuView: View {
                         AxisValueLabel {
                             if let tokens = value.as(Int.self) {
                                 Text(UsageFormatter.tokenCountString(tokens))
-                                    .font(.system(.caption2, design: .rounded))
+                                    .font(RunicFont.caption2)
                                     .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
                             }
                         }
@@ -120,27 +120,27 @@ struct HourlyActivityChartMenuView: View {
                 HStack(spacing: RunicSpacing.md) {
                     VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                         Text("Today")
-                            .font(.system(.caption2, design: .rounded))
+                            .font(RunicFont.caption2)
                             .foregroundStyle(.tertiary)
                         Text(UsageFormatter.tokenCountString(model.totalTokens))
-                            .font(.system(.caption, design: .rounded))
+                            .font(RunicFont.caption)
                             .fontWeight(.medium)
                     }
                     VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                         Text("Active hours")
-                            .font(.system(.caption2, design: .rounded))
+                            .font(RunicFont.caption2)
                             .foregroundStyle(.tertiary)
                         Text("\(model.activeHours)")
-                            .font(.system(.caption, design: .rounded))
+                            .font(RunicFont.caption)
                             .fontWeight(.medium)
                     }
                     if model.totalRequests > 0 {
                         VStack(alignment: .leading, spacing: RunicSpacing.xxxs) {
                             Text("Requests")
-                                .font(.system(.caption2, design: .rounded))
+                                .font(RunicFont.caption2)
                                 .foregroundStyle(.tertiary)
                             Text("\(model.totalRequests)")
-                                .font(.system(.caption, design: .rounded))
+                                .font(RunicFont.caption)
                                 .fontWeight(.medium)
                         }
                     }
@@ -182,12 +182,12 @@ struct HourlyActivityChartMenuView: View {
             let tokens = tokensByHour[hour] ?? 0
             let isPeak = tokens > 0 && tokens == maxTokens
             let bar = HourBar(id: hour, hour: hour, totalTokens: tokens, isPeak: isPeak)
-            if isPeak && tokens > 0 { peakHour = bar }
+            if isPeak, tokens > 0 { peakHour = bar }
             return bar
         }
 
         let totalTokens = tokensByHour.values.reduce(0, +)
-        let activeHours = tokensByHour.values.filter { $0 > 0 }.count
+        let activeHours = tokensByHour.values.count(where: { $0 > 0 })
         let totalRequests = requestsByHour.values.reduce(0, +)
 
         return HourlyModel(

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

@@ -7,27 +7,24 @@ import SwiftUI
 @MainActor
 struct InlineUsageChartView: View {
     enum TimeRange: String, CaseIterable {
-        case oneHour = "1h"
-        case sixHours = "6h"
-        case oneDay = "1d"
+        case threeDays = "3d"
         case sevenDays = "7d"
         case thirtyDays = "30d"
+        case quarter = "90d"
+        case year = "1y"
 
         var cutoffInterval: TimeInterval {
             switch self {
-            case .oneHour: return -3600
-            case .sixHours: return -21600
-            case .oneDay: return -86400
-            case .sevenDays: return -604800
-            case .thirtyDays: return -2592000
+            case .threeDays: -259_200
+            case .sevenDays: -604_800
+            case .thirtyDays: -2_592_000
+            case .quarter: -7_776_000
+            case .year: -31_536_000
             }
         }
 
         var usesHourlyData: Bool {
-            switch self {
-            case .oneHour, .sixHours, .oneDay: return true
-            default: return false
-            }
+            false
         }
     }
 
@@ -40,15 +37,13 @@ struct InlineUsageChartView: View {
     let dailySummaries: [UsageLedgerDailySummary]
     let hourlySummaries: [UsageLedgerHourlySummary]
     let width: CGFloat
-    @State private var selectedRange: TimeRange = .oneDay
+    @State private var selectedRange: TimeRange = .sevenDays
     @Environment(\.menuItemHighlighted) private var isHighlighted
 
     private static let lineColor = RunicColors.chartColor(at: 0)
 
     var body: some View {
-        let points = self.selectedRange.usesHourlyData
-            ? Self.hourlyPoints(from: self.hourlySummaries, range: self.selectedRange)
-            : Self.dailyPoints(from: self.dailySummaries, range: self.selectedRange)
+        let points = Self.dailyPoints(from: self.dailySummaries, range: self.selectedRange)
 
         VStack(alignment: .leading, spacing: RunicSpacing.xs) {
             // Time range picker
@@ -65,7 +60,7 @@ struct InlineUsageChartView: View {
                 HStack {
                     Spacer()
                     Text("No data")
-                        .font(.system(.caption2, design: .rounded))
+                        .font(RunicFont.caption2)
                         .foregroundStyle(.tertiary)
                     Spacer()
                 }
@@ -101,7 +96,7 @@ struct InlineUsageChartView: View {
                             AxisValueLabel {
                                 if let tokens = value.as(Int.self) {
                                     Text(UsageFormatter.tokenCountString(tokens))
-                                        .font(.system(size: 8, design: .rounded))
+                                        .font(RunicFont.system(size: 8))
                                         .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
                                 }
                             }
@@ -110,7 +105,7 @@ struct InlineUsageChartView: View {
                     .chartXAxis {
                         AxisMarks(values: .automatic(desiredCount: 4)) { _ in
                             AxisValueLabel(format: self.xAxisFormat)
-                                .font(.system(size: 8, design: .rounded))
+                                .font(RunicFont.system(size: 8))
                                 .foregroundStyle(Color(nsColor: .tertiaryLabelColor))
                         }
                     }
@@ -120,7 +115,7 @@ struct InlineUsageChartView: View {
                     // Peak badge
                     if let peak = points.max(by: { $0.tokens < $1.tokens }), peak.tokens > 0 {
                         Text("Peak \(UsageFormatter.tokenCountString(peak.tokens))")
-                            .font(.system(size: 8, weight: .medium, design: .rounded))
+                            .font(RunicFont.system(size: 8, weight: .medium))
                             .foregroundStyle(.secondary)
                             .padding(.horizontal, 4)
                             .padding(.vertical, 1)

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

@@ -14,8 +14,8 @@ struct MenuCardEntranceModifier: ViewModifier {
             .scaleEffect(self.appeared ? 1 : 0.97, anchor: .top)
             .onAppear {
                 withAnimation(
-                    RunicAnimation.cardEntrance.delay(Double(self.index) * RunicAnimation.cardEntranceStagger)
-                ) {
+                    RunicAnimation.cardEntrance.delay(Double(self.index) * RunicAnimation.cardEntranceStagger))
+                {
                     self.appeared = true
                 }
             }
@@ -41,8 +41,7 @@ struct GlassShimmerModifier: ViewModifier {
                         .frame(width: geo.size.width, height: geo.size.height)
                         .allowsHitTesting(false)
                 }
-                .clipShape(RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous))
-            )
+                .clipShape(RoundedRectangle(cornerRadius: RunicCornerRadius.lg, style: .continuous)))
             .onAppear {
                 withAnimation(.easeInOut(duration: 2.0).delay(0.5)) {
                     self.shimmerPhase = 1.2

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

@@ -61,29 +61,7 @@ struct ProviderSidebarMenuCardView<Content: View>: View {
     let iconProvider: (UsageProvider, CGFloat) -> NSImage
     let weeklyRemainingProvider: (UsageProvider) -> Double?
     let onSelect: (UsageProvider) -> Void
-    let content: (CGFloat) -> Content
-
-    init(
-        providers: [UsageProvider],
-        selected: UsageProvider?,
-        totalWidth: CGFloat,
-        showIcons: Bool,
-        iconSize: ProviderSwitcherIconSize,
-        iconProvider: @escaping (UsageProvider, CGFloat) -> NSImage,
-        weeklyRemainingProvider: @escaping (UsageProvider) -> Double?,
-        onSelect: @escaping (UsageProvider) -> Void,
-        @ViewBuilder content: @escaping (CGFloat) -> Content)
-    {
-        self.providers = providers
-        self.selected = selected
-        self.totalWidth = totalWidth
-        self.showIcons = showIcons
-        self.iconSize = iconSize
-        self.iconProvider = iconProvider
-        self.weeklyRemainingProvider = weeklyRemainingProvider
-        self.onSelect = onSelect
-        self.content = content
-    }
+    @ViewBuilder let content: (CGFloat) -> Content
 
     var body: some View {
         let style = MenuCardSidebarMetrics.style(for: self.providers.count, iconSize: self.iconSize)
@@ -124,7 +102,8 @@ private struct ProviderSidebarRailView: View {
     @Environment(\.menuItemHighlighted) private var isHighlighted
 
     private var railBackground: LinearGradient {
-        let base = Color(nsColor: .controlTextColor).opacity(self.isHighlighted ? RunicColors.Opacity.subtle : RunicColors.Opacity.nano)
+        let base = Color(nsColor: .controlTextColor)
+            .opacity(self.isHighlighted ? RunicColors.Opacity.subtle : RunicColors.Opacity.nano)
         return LinearGradient(
             colors: [base, base.opacity(0.6)],
             startPoint: .top,
@@ -164,7 +143,8 @@ private struct ProviderSidebarRailView: View {
             }
 
             Rectangle()
-                .fill(Color(nsColor: .separatorColor).opacity(self.isHighlighted ? RunicColors.Opacity.emphasis : RunicColors.Opacity.strong))
+                .fill(Color(nsColor: .separatorColor)
+                    .opacity(self.isHighlighted ? RunicColors.Opacity.emphasis : RunicColors.Opacity.strong))
                 .frame(width: 1)
                 .padding(.top, MenuCardMetrics.headerTopPadding + 4)
                 .padding(.bottom, MenuCardMetrics.tailPadding)

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

@@ -80,7 +80,7 @@ struct MenuCardSkeletonView: View {
     /// Computes a repeating phase (0...1) from the timeline date for the sliding gradient.
     private func shimmerPhase(date: Date) -> Double {
         let seconds = date.timeIntervalSinceReferenceDate
-        let period: Double = 1.5
+        let period = 1.5
         return (seconds.truncatingRemainder(dividingBy: period)) / period
     }