till/mana-swift-ui
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(webshell): neues Library-Product ManaWebShell (v0.6.0)

Browse source 
WKWebView-Huelle fuer Hybrid-Apps (Web-Lese-Surfaces + native
Submit/Widget/ShareExt). Extrahiert aus den fast-byte-identischen
`WebShell/`-Ordnern in seepuls-native und zitare-native (~900 LOC,
davon ~700 LOC Duplikat). Audit 2026-05-17 V2.

Neu (public API):
- `WebShellView` — WKWebView-Wrapper mit Progress-Bar, Pull-to-
  Refresh (iOS), Fehler-Snackbar, External-Link-Delegation. Universal
  (iOS + macOS)
- `WebShellConfig` — Host-Whitelist mit Wildcard-Support (`"*.mana.how"`),
  User-Agent, Theme-Hints, User-Scripts
- `WebTarget` — URL + monoton wachsender reloadToken
- `WebNavState` — @Observable, @MainActor, reaktiver Nav-State
- `WebShellCoordinator` — WKNavigationDelegate + WKUIDelegate
- `WebShellScripts` — Helfer fuer `preferDarkScheme`,
  `syncDarkMode(localStorageKey:)`, `hideElements(selectors:tagName:)`

Logging unter Subsystem `ev.mana.webshell` (App-OSLog bleibt eigen).

Tests: 6 neue Tests gegen `WebShellConfig.isAllowed` (Wildcards,
Negativ-Cases). 50/50 grün insgesamt (6 ManaWebShell + 44 ManaAuthUI).

Doku: `mana/docs/playbooks/HYBRID_NATIVE_APP.md` (Schwester-Repo).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Till JS 2026-05-17 21:11:47 +02:00
parent e284240f3c
commit 8f4d4b0c03
9 changed files with 689 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

47
CHANGELOG.md
View file

@ -6,6 +6,53 @@ Alle Änderungen werden hier dokumentiert. Format orientiert an
## [Unreleased]
## [0.6.0] — 2026-05-17
Minor — **neues Library-Product `ManaWebShell`**. WKWebView-Hülle für
Hybrid-Apps (Web-Lese-Surfaces + native Submit/Widget/ShareExt).
Extrahiert aus den fast-byte-identischen `WebShell/`-Ordnern in
`seepuls-native` und `zitare-native` (~900 LOC, davon ~700 LOC
Duplikat). Audit 2026-05-17 Vorschlag V2.
### Neu
- `WebShellView` (public SwiftUI View) — `WKWebView`-Wrapper mit
Progress-Bar, Pull-to-Refresh (iOS), Fehler-Snackbar, External-Link-
Delegation in den System-Browser. Universal (iOS + macOS).
- `WebShellConfig` (public, Sendable) — Host-Whitelist mit Wildcard-
Support (`"*.mana.how"`), User-Agent, Theme-Hints (background,
progressTint, errorBackground/Foreground/Icon), User-Scripts.
- `WebTarget` (public, Equatable+Sendable) — URL + monoton wachsender
`reloadToken`. Forciert Reload bei Universal-Link auf aktuelle URL.
- `WebNavState` (public, @Observable, @MainActor) — reaktiver
Navigation-State (isLoading, estimatedProgress, lastError,
currentURL, canGoBack).
- `WebShellCoordinator` (public, @MainActor) — `WKNavigationDelegate`
+ `WKUIDelegate`-Implementierung. KVO-Observations, Pull-to-Refresh-
Action.
- `WebShellScripts` (public Enum, @MainActor) — vor-gefertigte
`WKUserScript`-Helfer: `preferDarkScheme`, `syncDarkMode(localStorageKey:)`,
`hideElements(selectors:tagName:)`. Apps stapeln nach Bedarf.
### Logging
- ManaWebShell loggt unter Subsystem `ev.mana.webshell`, Kategorie
`web`. App-OSLog bleibt unverändert.
### Tests
- `ManaWebShellTests` mit 6 Tests gegen `WebShellConfig.isAllowed`.
Coverage für exakte Hosts, `*.root`-Wildcard, Root-selbst,
Negativ-Cases, leere Whitelist. 6/6 grün.
### Migrations-Hinweis
`seepuls-native` und `zitare-native` können ihre lokalen
`Sources/Features/WebShell/`-Dateien gegen `ManaWebShell` ersetzen.
Pattern in `mana/docs/playbooks/HYBRID_NATIVE_APP.md` (entsteht
parallel). App-spezifisches (CookieBridge, App-Theme als
`config.backgroundColor`) bleibt in der App.
## [0.5.0] — 2026-05-14
Minor — `ManaTwoFactorAccountRow` + `ManaBackupCodeRegenerateView`.

13
Package.swift
View file

@ -10,6 +10,7 @@ let package = Package(
],
products: [
.library(name: "ManaAuthUI", targets: ["ManaAuthUI"]),
.library(name: "ManaWebShell", targets: ["ManaWebShell"]),
],
dependencies: [
// Lokaler Dev-Pfad. Apps konsumieren beide Pakete parallel über
@ -29,10 +30,22 @@ let package = Package(
.enableExperimentalFeature("StrictConcurrency"),
]
),
.target(
name: "ManaWebShell",
path: "Sources/ManaWebShell",
swiftSettings: [
.enableExperimentalFeature("StrictConcurrency"),
]
),
.testTarget(
name: "ManaAuthUITests",
dependencies: ["ManaAuthUI"],
path: "Tests/ManaAuthUITests"
),
.testTarget(
name: "ManaWebShellTests",
dependencies: ["ManaWebShell"],
path: "Tests/ManaWebShellTests"
),
]
)

16
Sources/ManaWebShell/WebNavState.swift Normal file
View file

@ -0,0 +1,16 @@
import Foundation
/// Reactive Navigation-State, geteilt zwischen SwiftUI und Coordinator.
/// Auf `MainActor` — alle Mutationen passieren via WKWebView-Callbacks
/// (KVO + Delegate), die WebKit auf Main liefert.
@Observable
@MainActor
public final class WebNavState {
public var isLoading: Bool = false
public var estimatedProgress: Double = 0
public var lastError: String?
public var currentURL: URL?
public var canGoBack: Bool = false
public init() {}
}

94
Sources/ManaWebShell/WebShellConfig.swift Normal file
View file

@ -0,0 +1,94 @@
import Foundation
import SwiftUI
import WebKit
/// Konfiguration für ``WebShellView``.
///
/// Beispiel:
///
/// ```swift
/// WebShellView(
/// target: WebTarget(url: URL(string: "https://seepuls.mana.how")!),
/// config: WebShellConfig(
/// allowedHosts: ["seepuls.mana.how", "*.mana.how", "mana.how"],
/// userAgent: "SeepulsNative/0.1 (iOS)"
/// )
/// )
/// ```
///
/// Apps mit eigenem Theme injizieren `background` / `progressTint` /
/// `warning` etc. — default werden System-Farben benutzt.
public struct WebShellConfig: Sendable {
/// Liste erlaubter Hosts. Unterstützt:
/// - exakte Hosts: `"seepuls.mana.how"`
/// - Wildcard-Subdomains: `"*.mana.how"`
///
/// Pfade auf nicht-gelisteten Hosts werden via `OpenURLAction` an
/// den System-Browser delegiert. Ein leeres Array bedeutet
/// **alles extern** — selten gewünscht, aber explizit erlaubt.
public let allowedHosts: [String]
/// `applicationNameForUserAgent`. WKWebView hängt das an seinen
/// Standard-UA an, ersetzt ihn nicht. Konvention im mana-Ökosystem:
/// `"<AppName>Native/<version> (<platform>)"`.
public let userAgent: String
/// Hintergrund hinter dem WKWebView (verhindert Flash vor first
/// paint). Default: `.clear`. Caller setzt typischerweise auf
/// App-Theme-Background.
public let backgroundColor: Color
/// Tint der Fortschritts-Linie oben (Linear-ProgressView). Default:
/// `.accentColor`.
public let progressTint: Color
/// Hintergrund der Fehler-Snackbar. Default: `.gray.opacity(0.15)`.
public let errorBackgroundColor: Color
/// Vordergrund der Fehler-Snackbar (Icon + Text). Default: `.primary`.
public let errorForegroundColor: Color
/// Icon-Farbe (Warn-Dreieck) in der Fehler-Snackbar. Default: `.orange`.
public let errorIconColor: Color
/// User-Scripts, die in `WKUserContentController` injiziert werden
/// (Reihenfolge bleibt erhalten). Häufig genutzt: Theme-Sync,
/// Web-Nav-Verstecken. Siehe ``WebShellScripts`` für Default-Helfer.
public let userScripts: [WKUserScript]
public init(
allowedHosts: [String],
userAgent: String,
backgroundColor: Color = .clear,
progressTint: Color = .accentColor,
errorBackgroundColor: Color = Color.gray.opacity(0.15),
errorForegroundColor: Color = .primary,
errorIconColor: Color = .orange,
userScripts: [WKUserScript] = []
) {
self.allowedHosts = allowedHosts
self.userAgent = userAgent
self.backgroundColor = backgroundColor
self.progressTint = progressTint
self.errorBackgroundColor = errorBackgroundColor
self.errorForegroundColor = errorForegroundColor
self.errorIconColor = errorIconColor
self.userScripts = userScripts
}
/// Prüft, ob ein Host in dieser Konfiguration erlaubt ist.
/// Unterstützt `*.<root>`-Wildcards (subdomain-suffix + Root selbst).
public func isAllowed(host: String) -> Bool {
for pattern in allowedHosts {
if pattern.hasPrefix("*.") {
let suffix = String(pattern.dropFirst(1)) // ".mana.how"
if host.hasSuffix(suffix) { return true }
let root = String(suffix.dropFirst(1)) // "mana.how"
if host == root { return true }
} else if host == pattern {
return true
}
}
return false
}
}

147
Sources/ManaWebShell/WebShellCoordinator.swift Normal file
View file

@ -0,0 +1,147 @@
import Foundation
import OSLog
import SwiftUI
import WebKit
#if canImport(UIKit)
import UIKit
#endif
private let log = Logger(subsystem: "ev.mana.webshell", category: "web")
/// `WKNavigationDelegate` + `WKUIDelegate` für ``WebShellView``. Hält
/// den reactive ``WebNavState`` aktuell, lenkt externe Links in den
/// System-Browser und treibt Pull-to-Refresh an.
///
/// Lebt auf `MainActor` (Closures von WKWebView liefern auf Main).
/// KVO-Observations werden bei `deinit` entfernt.
@MainActor
public final class WebShellCoordinator: NSObject, WKNavigationDelegate, WKUIDelegate {
let navState: WebNavState
let openURL: OpenURLAction
let config: WebShellConfig
var lastTarget: WebTarget?
private var progressObservation: NSKeyValueObservation?
private var loadingObservation: NSKeyValueObservation?
private var canGoBackObservation: NSKeyValueObservation?
private var urlObservation: NSKeyValueObservation?
#if canImport(UIKit)
private weak var refreshControl: UIRefreshControl?
#endif
init(navState: WebNavState, openURL: OpenURLAction, config: WebShellConfig) {
self.navState = navState
self.openURL = openURL
self.config = config
super.init()
}
deinit {
progressObservation?.invalidate()
loadingObservation?.invalidate()
canGoBackObservation?.invalidate()
urlObservation?.invalidate()
}
func observe(webView: WKWebView) {
progressObservation = webView.observe(\.estimatedProgress, options: [.new]) { [weak self] _, change in
guard let value = change.newValue else { return }
Task { @MainActor in
self?.navState.estimatedProgress = value
}
}
loadingObservation = webView.observe(\.isLoading, options: [.new]) { [weak self] _, change in
guard let value = change.newValue else { return }
Task { @MainActor in
self?.navState.isLoading = value
}
}
canGoBackObservation = webView.observe(\.canGoBack, options: [.new]) { [weak self] _, change in
guard let value = change.newValue else { return }
Task { @MainActor in
self?.navState.canGoBack = value
}
}
urlObservation = webView.observe(\.url, options: [.new]) { [weak self] _, change in
let value = change.newValue ?? nil
Task { @MainActor in
self?.navState.currentURL = value
}
}
}
func load(_ url: URL, into webView: WKWebView) {
log.info("WebShell load: \(url.absoluteString, privacy: .public)")
navState.lastError = nil
let request = URLRequest(url: url)
webView.load(request)
}
#if canImport(UIKit)
func attachRefresh(_ control: UIRefreshControl, webView: WKWebView) {
refreshControl = control
control.addAction(
UIAction { [weak self, weak webView] _ in
webView?.reload()
Task { @MainActor in
self?.refreshControl?.endRefreshing()
}
},
for: .valueChanged
)
}
#endif
// MARK: - WKNavigationDelegate
public func webView(
_: WKWebView,
decidePolicyFor navigationAction: WKNavigationAction
) async -> WKNavigationActionPolicy {
guard let url = navigationAction.request.url else { return .allow }
if let host = url.host, config.isAllowed(host: host) {
return .allow
}
if url.scheme == "http" || url.scheme == "https" {
log.info("WebShell → openURL extern: \(url.absoluteString, privacy: .public)")
openURL(url)
return .cancel
}
return .cancel
}
public func webView(_: WKWebView, didFail _: WKNavigation, withError error: Error) {
log.warning("didFail: \(String(describing: error), privacy: .public)")
navState.lastError = (error as NSError).localizedDescription
}
public func webView(_: WKWebView, didFailProvisionalNavigation _: WKNavigation, withError error: Error) {
log.warning("didFailProvisional: \(String(describing: error), privacy: .public)")
navState.lastError = (error as NSError).localizedDescription
}
public func webView(_: WKWebView, didFinish _: WKNavigation) {
navState.lastError = nil
}
// MARK: - WKUIDelegate
public func webView(
_ webView: WKWebView,
createWebViewWith _: WKWebViewConfiguration,
for navigationAction: WKNavigationAction,
windowFeatures _: WKWindowFeatures
) -> WKWebView? {
// `target=_blank`-Links: kein neues Fenster, im aktuellen WebView
// laden bzw. extern öffnen.
if let url = navigationAction.request.url {
if let host = url.host, config.isAllowed(host: host) {
webView.load(navigationAction.request)
} else {
openURL(url)
}
}
return nil
}
}

119
Sources/ManaWebShell/WebShellScripts.swift Normal file
View file

@ -0,0 +1,119 @@
import Foundation
import WebKit
/// Vor-gefertigte `WKUserScript`-Helfer für ``WebShellView``. Apps
/// pickern, was sie brauchen, und reichen das Ergebnis als
/// `config.userScripts` durch.
///
/// `WKUserScript` ist MainActor-isolated; deshalb sind die Factory-
/// Methoden hier ebenfalls MainActor. Aufrufer leben sowieso auf Main
/// (SwiftUI `makeUIView`/`makeNSView` sind MainActor).
@MainActor
public enum WebShellScripts {
/// Erzwingt Dark-Color-Scheme im WebView, indem ein `<meta
/// name="color-scheme" content="dark">` injiziert und `.dark` an
/// `<html>` gehängt wird. Sinnvoll für Web-Apps, die nur Dark-
/// Styles haben (Seepuls) oder bei denen die App das Light/Dark
/// hart festlegt.
public static let preferDarkScheme: WKUserScript = .init(
source: """
(function() {
var meta = document.querySelector('meta[name="color-scheme"]');
if (!meta) {
meta = document.createElement('meta');
meta.setAttribute('name', 'color-scheme');
(document.head || document.documentElement).appendChild(meta);
}
meta.setAttribute('content', 'dark');
var html = document.documentElement;
if (html) html.classList.add('dark');
})();
""",
injectionTime: .atDocumentStart,
forMainFrameOnly: true
)
/// Synct den System-Dark-Mode in den WebView via
/// `matchMedia('(prefers-color-scheme: dark)')`. Setzt eine
/// `.dark`-Klasse auf `<html>` und optional einen `localStorage`-
/// Key, an dem das Web-Theme hängt. Listener für Live-Switch
/// während die Page offen ist.
///
/// - Parameter localStorageKey: Key, an dem das Web seinen Theme-
/// State liest. `nil` falls Web nur auf `<html>.dark` reagiert.
public static func syncDarkMode(localStorageKey: String? = nil) -> WKUserScript {
let setStorage: String
if let key = localStorageKey {
let escaped = key.replacingOccurrences(of: "'", with: "\\'")
setStorage = """
try {
if (isDark) localStorage.setItem('\(escaped)', 'dark');
else localStorage.removeItem('\(escaped)');
} catch (e) {}
"""
} else {
setStorage = ""
}
let source = """
(function() {
function apply(isDark) {
\(setStorage)
var html = document.documentElement;
if (!html) return;
if (isDark) html.classList.add('dark');
else html.classList.remove('dark');
}
var mq = window.matchMedia('(prefers-color-scheme: dark)');
apply(mq.matches);
if (mq.addEventListener) {
mq.addEventListener('change', function(e) { apply(e.matches); });
}
})();
"""
return WKUserScript(
source: source,
injectionTime: .atDocumentStart,
forMainFrameOnly: true
)
}
/// Versteckt eine Top-Nav-Komponente per CSS, damit eine native
/// TabBar nicht doppelt rendert. Mehrere Selektoren werden
/// gestapelt (mit `,`-Group), damit ein Markup-Refactor in
/// Web-Land das Hide nicht still bricht.
///
/// Konvention für Selektor-Kaskaden:
/// 1. `nav[data-app-nav]` / `header[data-app-nav]` — explizites
/// Attribut, falls Web es markieren will (greift sofort)
/// 2. strukturell (`body header:has(a.brand)` o.ä.) — heutige
/// Realität
/// 3. positionell (`body > nav:first-of-type`) — Fallback
///
/// - Parameter selectors: CSS-Selektoren, die `display: none
/// !important` bekommen. Werden mit `,` gejoint.
/// - Parameter tagName: Wert für das `data-mana-webshell`-
/// Attribut auf dem Style-Tag (debugging, source inspection).
public static func hideElements(
selectors: [String],
tagName: String = "hide"
) -> WKUserScript {
let joined = selectors.joined(separator: ",\n")
let escapedTag = tagName.replacingOccurrences(of: "'", with: "\\'")
let source = """
(function() {
var css = `\(joined) {
display: none !important;
}`;
var style = document.createElement('style');
style.setAttribute('data-mana-webshell', '\(escapedTag)');
style.textContent = css;
(document.head || document.documentElement).appendChild(style);
})();
"""
return WKUserScript(
source: source,
injectionTime: .atDocumentStart,
forMainFrameOnly: true
)
}
}

183
Sources/ManaWebShell/WebShellView.swift Normal file
View file

@ -0,0 +1,183 @@
import SwiftUI
import WebKit
/// SwiftUI-Hülle um `WKWebView`. Eine Instanz gehört üblicherweise zu
/// einem Tab/Screen und behält ihren Web-State (Scroll-Position,
/// Browser-History) während die View lebt.
///
/// **Verhalten:**
/// - Lädt `target` beim ersten Auftauchen.
/// - Wechselt `target` während die View lebt → lädt neue URL (oder
/// reloaded, wenn `target.reloadToken` sich erhöht).
/// - Pull-to-Refresh über `UIRefreshControl` (iOS / iPadOS).
/// - Links auf nicht-gelisteten Hosts (siehe ``WebShellConfig/allowedHosts``)
/// und `target=_blank` öffnen im System-Browser via
/// `OpenURLAction`, nicht im WebView.
/// - Cookies werden über `WKWebsiteDataStore.default()` geteilt.
///
/// **Theme-Hint:**
/// `config.backgroundColor` ist der Hintergrund hinter dem WKWebView
/// — verhindert weißen Flash bis zum first paint. Apps mit Dark-Theme
/// setzen das auf ihren Theme-Background.
public struct WebShellView: View {
let target: WebTarget
let config: WebShellConfig
@State private var navState = WebNavState()
@Environment(\.openURL) private var openURL
public init(target: WebTarget, config: WebShellConfig) {
self.target = target
self.config = config
}
public var body: some View {
VStack(spacing: 0) {
if navState.isLoading {
ProgressView(value: navState.estimatedProgress)
.progressViewStyle(.linear)
.tint(config.progressTint)
.frame(height: 2)
}
#if canImport(UIKit)
WebViewRepresentable(
target: target,
navState: navState,
openURL: openURL,
config: config
)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(config.backgroundColor)
#elseif canImport(AppKit)
MacWebViewRepresentable(
target: target,
navState: navState,
openURL: openURL,
config: config
)
.frame(maxWidth: .infinity, maxHeight: .infinity)
.background(config.backgroundColor)
#endif
if let error = navState.lastError {
errorBar(error)
}
}
.frame(maxWidth: .infinity, maxHeight: .infinity)
}
private func errorBar(_ message: String) -> some View {
HStack(spacing: 12) {
Image(systemName: "exclamationmark.triangle.fill")
.foregroundStyle(config.errorIconColor)
Text(message)
.font(.caption)
.lineLimit(2)
.foregroundStyle(config.errorForegroundColor)
Spacer()
}
.padding(.horizontal, 12)
.padding(.vertical, 8)
.background(config.errorBackgroundColor)
}
}
#if canImport(UIKit)
import UIKit
private struct WebViewRepresentable: UIViewRepresentable {
let target: WebTarget
let navState: WebNavState
let openURL: OpenURLAction
let config: WebShellConfig
func makeCoordinator() -> WebShellCoordinator {
WebShellCoordinator(navState: navState, openURL: openURL, config: config)
}
func makeUIView(context: Context) -> WKWebView {
let wkConfig = WKWebViewConfiguration()
wkConfig.websiteDataStore = .default()
wkConfig.applicationNameForUserAgent = config.userAgent
for script in config.userScripts {
wkConfig.userContentController.addUserScript(script)
}
let webView = WKWebView(frame: .zero, configuration: wkConfig)
webView.navigationDelegate = context.coordinator
webView.uiDelegate = context.coordinator
webView.allowsBackForwardNavigationGestures = true
// Ohne diese drei flackert WKWebView bis zum first paint weiß
// gegen das App-Theme — egal was der SwiftUI-Container als
// Background setzt.
webView.isOpaque = false
webView.backgroundColor = .clear
webView.scrollView.backgroundColor = .clear
webView.scrollView.refreshControl = makeRefreshControl(
webView: webView,
coordinator: context.coordinator
)
context.coordinator.observe(webView: webView)
context.coordinator.load(target.url, into: webView)
context.coordinator.lastTarget = target
return webView
}
func updateUIView(_ webView: WKWebView, context: Context) {
let coord = context.coordinator
if coord.lastTarget != target {
coord.load(target.url, into: webView)
coord.lastTarget = target
}
}
private func makeRefreshControl(
webView: WKWebView,
coordinator: WebShellCoordinator
) -> UIRefreshControl {
let refresh = UIRefreshControl()
coordinator.attachRefresh(refresh, webView: webView)
return refresh
}
}
#elseif canImport(AppKit)
import AppKit
private struct MacWebViewRepresentable: NSViewRepresentable {
let target: WebTarget
let navState: WebNavState
let openURL: OpenURLAction
let config: WebShellConfig
func makeCoordinator() -> WebShellCoordinator {
WebShellCoordinator(navState: navState, openURL: openURL, config: config)
}
func makeNSView(context: Context) -> WKWebView {
let wkConfig = WKWebViewConfiguration()
wkConfig.websiteDataStore = .default()
wkConfig.applicationNameForUserAgent = config.userAgent
for script in config.userScripts {
wkConfig.userContentController.addUserScript(script)
}
let webView = WKWebView(frame: .zero, configuration: wkConfig)
webView.navigationDelegate = context.coordinator
webView.uiDelegate = context.coordinator
webView.allowsBackForwardNavigationGestures = true
// macOS-Pendant zu UIView.isOpaque=false — sonst weißer Flash
// vor first paint.
webView.setValue(false, forKey: "drawsBackground")
context.coordinator.observe(webView: webView)
context.coordinator.load(target.url, into: webView)
context.coordinator.lastTarget = target
return webView
}
func updateNSView(_ webView: WKWebView, context: Context) {
let coord = context.coordinator
if coord.lastTarget != target {
coord.load(target.url, into: webView)
coord.lastTarget = target
}
}
}
#endif

14
Sources/ManaWebShell/WebTarget.swift Normal file
View file

@ -0,0 +1,14 @@
import Foundation
/// URL + monoton wachsende `reloadToken`. Ein neuer Token zwingt den
/// WebView, dieselbe URL nochmal zu laden — wird gebraucht wenn der
/// User auf einen Universal-Link tappt, der zur aktuellen URL führt.
public struct WebTarget: Equatable, Sendable {
public let url: URL
public let reloadToken: Int
public init(url: URL, reloadToken: Int = 0) {
self.url = url
self.reloadToken = reloadToken
}
}

56
Tests/ManaWebShellTests/WebShellConfigTests.swift Normal file
View file

@ -0,0 +1,56 @@
import Testing
@testable import ManaWebShell
@Suite("WebShellConfig — Host-Whitelist")
struct WebShellConfigTests {
private func config(_ hosts: [String]) -> WebShellConfig {
WebShellConfig(allowedHosts: hosts, userAgent: "TestNative/0.1")
}
@Test("Exakter Host matched")
func exactMatch() {
let c = config(["seepuls.mana.how"])
#expect(c.isAllowed(host: "seepuls.mana.how"))
#expect(!c.isAllowed(host: "other.mana.how"))
#expect(!c.isAllowed(host: "mana.how"))
#expect(!c.isAllowed(host: "evil.com"))
}
@Test("Wildcard *.root matched Subdomain")
func wildcardSubdomain() {
let c = config(["*.mana.how"])
#expect(c.isAllowed(host: "seepuls.mana.how"))
#expect(c.isAllowed(host: "auth.mana.how"))
#expect(c.isAllowed(host: "deep.nested.mana.how"))
}
@Test("Wildcard *.root matched Root selbst")
func wildcardCoversRoot() {
let c = config(["*.mana.how"])
#expect(c.isAllowed(host: "mana.how"))
}
@Test("Wildcard matched nicht andere TLDs")
func wildcardScoped() {
let c = config(["*.mana.how"])
#expect(!c.isAllowed(host: "mana.com"))
#expect(!c.isAllowed(host: "fake-mana.how"))
#expect(!c.isAllowed(host: "evil.com"))
}
@Test("Mehrere Patterns kombinieren")
func mixedPatterns() {
let c = config(["zitare.com", "www.zitare.com", "*.mana.how"])
#expect(c.isAllowed(host: "zitare.com"))
#expect(c.isAllowed(host: "www.zitare.com"))
#expect(c.isAllowed(host: "auth.mana.how"))
#expect(c.isAllowed(host: "mana.how"))
#expect(!c.isAllowed(host: "other.zitare.com"))
}
@Test("Leere Whitelist verbietet alles")
func emptyDenies() {
let c = config([])
#expect(!c.isAllowed(host: "anything.com"))
}
}