Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
import SwiftUI
struct ChangelogView: View {
@Environment(\.theme) private var theme
@State private var releases: [SimpleUpdater.ReleaseNote] = []
@State private var isRefreshing = false
@State private var errorMessage: String?
private let owner = "altic-dev"
private let repo = "Fluid-oss"
private let releaseLimit = 3
var body: some View {
ScrollView(.vertical, showsIndicators: true) {
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.xl) {
if let errorMessage {
Label(errorMessage, systemImage: "wifi.exclamationmark")
.font(self.theme.typography.caption)
.foregroundStyle(self.theme.palette.warning)
}
if self.releases.isEmpty, self.isRefreshing {
self.loadingCard
} else if self.releases.isEmpty {
self.emptyCard
} else {
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {
ForEach(Array(self.releases.enumerated()), id: \.element) { index, release in
ChangelogReleaseCard(
release: release,
isLatest: index == 0,
theme: self.theme
)
}
}
}
self.footer
}
.fluidPageContent(width: .reading)
}
.fluidPageActions {
Button {
Task { await self.refreshReleases(force: true) }
} label: {
ZStack {
Image(systemName: "arrow.clockwise")
.fluidToolbarIcon()
.opacity(self.isRefreshing ? 0 : 1)
if self.isRefreshing { ProgressView().controlSize(.small) }
}
.frame(width: 22, height: 22)
}
.disabled(self.isRefreshing)
.help("Refresh changelog")
.accessibilityLabel("Refresh changelog")
}
.task {
self.loadCachedReleases()
await self.refreshReleases()
}
}
private var loadingCard: some View {
ThemedCard(style: .standard, hoverEffect: false) {
HStack(spacing: self.theme.metrics.spacing.md) {
ProgressView()
.controlSize(.small)
Text("Loading release notes...")
.font(self.theme.typography.body)
.foregroundStyle(self.theme.palette.secondaryText)
}
}
}
private var emptyCard: some View {
ThemedCard(style: .standard, hoverEffect: false) {
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.sm) {
Text("No changelog available")
.font(self.theme.typography.sectionTitle)
.foregroundStyle(self.theme.palette.primaryText)
Text("FluidVoice could not load GitHub release notes right now.")
.font(self.theme.typography.bodySmall)
.foregroundStyle(self.theme.palette.secondaryText)
}
}
}
private var footer: some View {
HStack {
if let url = URL(string: "https://github.com/\(self.owner)/\(self.repo)/releases") {
Link(destination: url) {
Label("View older release notes on GitHub", systemImage: "arrow.up.right.square")
.font(self.theme.typography.bodySmallStrong)
.padding(.horizontal, 14)
.padding(.vertical, 9)
}
.fluidButton(.glass, size: .medium)
.buttonHoverEffect()
}
Spacer()
}
}
private func loadCachedReleases() {
let cacheKey = self.cacheKey
guard
let data = UserDefaults.standard.data(forKey: cacheKey),
let cache = try? JSONDecoder().decode(ChangelogCache.self, from: data)
else { return }
self.releases = Array(cache.releases.prefix(self.releaseLimit))
}
private func refreshReleases(force _: Bool = false) async {
guard !self.isRefreshing else { return }
self.isRefreshing = true
self.errorMessage = nil
do {
let includePrerelease = SettingsStore.shared.betaReleasesEnabled
let fetched = try await SimpleUpdater.shared.fetchRecentReleaseNotes(
owner: self.owner,
repo: self.repo,
limit: self.releaseLimit,
includePrerelease: includePrerelease
)
let limitedReleases = Array(fetched.prefix(self.releaseLimit))
self.releases = limitedReleases
self.saveCachedReleases(limitedReleases)
} catch {
if self.releases.isEmpty {
self.errorMessage = "Unable to load release notes."
} else {
self.errorMessage = "Showing saved release notes. Refresh failed."
}
}
self.isRefreshing = false
}
private func saveCachedReleases(_ releases: [SimpleUpdater.ReleaseNote]) {
let cache = ChangelogCache(releases: releases, savedAt: Date())
guard let data = try? JSONEncoder().encode(cache) else { return }
UserDefaults.standard.set(data, forKey: self.cacheKey)
}
private var cacheKey: String {
let channel = SettingsStore.shared.betaReleasesEnabled ? "beta" : "stable"
return "FluidVoiceChangelogCache.\(channel)"
}
}
private struct ChangelogCache: Codable {
let releases: [SimpleUpdater.ReleaseNote]
let savedAt: Date
}
private struct ChangelogReleaseCard: View {
let release: SimpleUpdater.ReleaseNote
let isLatest: Bool
let theme: AppTheme
var body: some View {
ThemedCard(style: self.isLatest ? .prominent : .standard, hoverEffect: false) {
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.md) {
HStack(alignment: .firstTextBaseline, spacing: self.theme.metrics.spacing.sm) {
VStack(alignment: .leading, spacing: 4) {
HStack(spacing: self.theme.metrics.spacing.sm) {
Text(self.release.title)
.font(self.theme.typography.sectionTitle)
.foregroundStyle(self.theme.palette.primaryText)
.lineLimit(2)
if self.isLatest {
Text("Latest")
.font(self.theme.typography.badge)
.foregroundStyle(self.theme.palette.accent)
.padding(.horizontal, 8)
.padding(.vertical, 3)
.background(
Capsule()
.fill(self.theme.palette.accent.opacity(0.12))
)
}
if self.release.isPrerelease {
Text("Beta")
.font(self.theme.typography.badge)
.foregroundStyle(self.theme.palette.warning)
.padding(.horizontal, 8)
.padding(.vertical, 3)
.background(
Capsule()
.fill(self.theme.palette.warning.opacity(0.12))
)
}
}
Text(self.metadataText)
.font(self.theme.typography.caption)
.foregroundStyle(self.theme.palette.tertiaryText)
}
Spacer()
if let url = self.release.url {
Link(destination: url) {
Image(systemName: "arrow.up.right")
.font(self.theme.typography.captionStrong)
.padding(7)
}
.buttonStyle(.borderless)
.help("Open this release on GitHub")
}
}
VStack(alignment: .leading, spacing: self.theme.metrics.spacing.sm) {
ForEach(self.noteBlocks, id: \.self) { block in
ChangelogNoteBlock(block: block, theme: self.theme)
}
}
}
}
}
private var metadataText: String {
if let publishedAt = self.release.publishedAt {
return "\(self.release.version) - \(publishedAt.formatted(date: .abbreviated, time: .omitted))"
}
return self.release.version
}
private var noteBlocks: [ChangelogNoteBlock.Model] {
ChangelogNoteBlock.Model.make(
from: self.release.notes,
releaseTitle: self.release.title,
version: self.release.version
)
}
}
private struct ChangelogNoteBlock: View {
enum Kind: Hashable {
case heading
case bullet
case paragraph
}
struct Model: Hashable {
let kind: Kind
let text: String
static func make(from notes: String, releaseTitle: String, version: String) -> [Model] {
var blocks: [Model] = []
for rawLine in notes.components(separatedBy: .newlines) {
let line = rawLine.trimmingCharacters(in: .whitespacesAndNewlines)
guard !line.isEmpty else { continue }
if line.hasPrefix("#") {
let heading = String(line.drop { $0 == "#" })
.trimmingCharacters(in: .whitespacesAndNewlines)
guard !self.shouldStop(atHeading: heading) else { break }
guard heading != releaseTitle, heading != version else { continue }
blocks.append(Model(kind: .heading, text: heading))
continue
}
guard !self.isBoilerplateLine(line) else { continue }
if line.hasPrefix("- ") || line.hasPrefix("* ") {
blocks.append(Model(kind: .bullet, text: String(line.dropFirst(2))))
continue
}
blocks.append(Model(kind: .paragraph, text: line))
}
return blocks
}
private static func shouldStop(atHeading heading: String) -> Bool {
heading.localizedCaseInsensitiveContains("contributors") ||
heading.localizedCaseInsensitiveContains("need help")
}
private static func isBoilerplateLine(_ line: String) -> Bool {
let lowercased = line.lowercased()
return lowercased.contains("report issues:") ||
lowercased.contains("github.com/altic-dev/fluidvoice/issues") ||
lowercased.contains("github.com/altic-dev/fluid-oss/issues")
}
}
let block: Model
let theme: AppTheme
var body: some View {
switch self.block.kind {
case .heading:
Text(self.block.text)
.font(self.theme.typography.bodySmallStrong)
.foregroundStyle(self.theme.palette.primaryText)
.padding(.top, 2)
case .bullet:
HStack(alignment: .firstTextBaseline, spacing: self.theme.metrics.spacing.sm) {
Circle()
.fill(self.theme.palette.accent.opacity(0.75))
.frame(width: 4, height: 4)
Text(self.markdownAttributedString(from: self.block.text))
.font(self.theme.typography.bodySmall)
.foregroundStyle(self.theme.palette.secondaryText)
.fixedSize(horizontal: false, vertical: true)
}
case .paragraph:
Text(self.markdownAttributedString(from: self.block.text))
.font(self.theme.typography.bodySmall)
.foregroundStyle(self.theme.palette.secondaryText)
.fixedSize(horizontal: false, vertical: true)
}
}
private func markdownAttributedString(from text: String) -> AttributedString {
do {
return try AttributedString(
markdown: text,
options: AttributedString.MarkdownParsingOptions(interpretedSyntax: .inlineOnlyPreservingWhitespace)
)
} catch {
return AttributedString(text)
}
}
}
#Preview {
ChangelogView()
.environment(\.theme, AppTheme.dark)
}