@swiftbrowser/swift 0.1.0 → 0.2.0

package/Sources/FoundationLite/FoundationLite.swift

@@ -1,171 +0,0 @@
-/// The slice of Foundation's formatting API that SwiftUI apps lean on, for
-/// platforms where only `FoundationEssentials` is linked (WebAssembly, Linux):
-/// the CLI's lean mode and the repository's own examples.
-///
-/// Full Foundation on Wasm costs about 14 MB more than FoundationEssentials
-/// even with its ICU data trimmed (docs/ops-protocol.md, "Phase 11"), so apps
-/// that must stay small import `FoundationEssentials` plus this module; the
-/// CLI's default is the real Foundation with `FoundationBridge`.
-/// The spellings match Foundation's, so a file that does
-///
-///     #if canImport(FoundationEssentials)
-///     import FoundationEssentials
-///     import FoundationLite
-///     #else
-///     import Foundation
-///     #endif
-///
-/// compiles unchanged against Apple's SDKs. Output is fixed to US English
-/// conventions (`1,234.5`, `Nov 14, 2023`, `10:13 PM`), which is also what
-/// keeps headless snapshots byte-stable.
-#if canImport(FoundationEssentials)
-import FoundationEssentials
-
-// MARK: - Dates
-
-extension Date {
-    /// Namespaces for `formatted(date:time:)`, mirroring `Foundation.Date.FormatStyle`.
-    public struct FormatStyle: Sendable {
-        public enum DateStyle: Hashable, Sendable {
-            case omitted, numeric, abbreviated, long, complete
-        }
-
-        public enum TimeStyle: Hashable, Sendable {
-            case omitted, shortened, standard, complete
-        }
-    }
-
-    /// `11/14/2023, 10:13 PM`, `Nov 14, 2023`, `November 14, 2023`,
-    /// `Tuesday, November 14, 2023`; times `10:13 PM`, `10:13:20 PM`.
-    /// Uses `Calendar.current`, which is Gregorian/UTC on WebAssembly.
-    public func formatted(date dateStyle: FormatStyle.DateStyle = .numeric,
-                          time timeStyle: FormatStyle.TimeStyle = .shortened) -> String {
-        let calendar = Calendar.current
-        let c = calendar.dateComponents([.year, .month, .day, .weekday, .hour, .minute, .second], from: self)
-        let year = c.year ?? 1970, month = c.month ?? 1, day = c.day ?? 1
-        let monthName = _monthNames[(month - 1) % 12]
-        let datePart: String?
-        switch dateStyle {
-        case .omitted: datePart = nil
-        case .numeric: datePart = "\(month)/\(day)/\(year)"
-        case .abbreviated: datePart = "\(monthName.prefix(3)) \(day), \(year)"
-        case .long: datePart = "\(monthName) \(day), \(year)"
-        case .complete: datePart = "\(_weekdayNames[((c.weekday ?? 1) - 1) % 7]), \(monthName) \(day), \(year)"
-        }
-        let timePart: String?
-        if timeStyle == .omitted {
-            timePart = nil
-        } else {
-            let hour24 = c.hour ?? 0, minute = c.minute ?? 0, second = c.second ?? 0
-            let hour12 = hour24 % 12 == 0 ? 12 : hour24 % 12
-            let suffix = hour24 < 12 ? "AM" : "PM"
-            let base = "\(hour12):\(_twoDigits(minute))"
-            switch timeStyle {
-            case .shortened: timePart = "\(base) \(suffix)"
-            case .standard, .complete: timePart = "\(base):\(_twoDigits(second)) \(suffix)"
-            case .omitted: timePart = nil
-            }
-        }
-        switch (datePart, timePart) {
-        case (let d?, let t?): return "\(d), \(t)"
-        case (let d?, nil): return d
-        case (nil, let t?): return t
-        case (nil, nil): return ""
-        }
-    }
-
-    public func formatted() -> String { formatted(date: .numeric, time: .shortened) }
-}
-
-private let _monthNames = ["January", "February", "March", "April", "May", "June", "July",
-                           "August", "September", "October", "November", "December"]
-private let _weekdayNames = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"]
-
-func _twoDigits(_ value: Int) -> String { value < 10 ? "0\(value)" : "\(value)" }
-
-// MARK: - Numbers
-
-/// Inserts thousands separators into a run of digits (optionally signed).
-func _grouped(_ digits: Substring) -> String {
-    var sign = ""
-    var body = digits
-    if body.first == "-" {
-        sign = "-"
-        body = body.dropFirst()
-    }
-    var out: [Character] = []
-    for (index, ch) in body.reversed().enumerated() {
-        if index > 0 && index % 3 == 0 { out.append(",") }
-        out.append(ch)
-    }
-    return sign + String(out.reversed())
-}
-
-/// Formats a decimal string (`-1234.5000`) the way `.number` does: grouped
-/// integer digits and at most `maxFractionDigits` fraction digits, trailing
-/// zeros dropped.
-func _formatDecimalString(_ text: String, maxFractionDigits: Int = 3) -> String {
-    let parts = text.split(separator: ".", maxSplits: 1, omittingEmptySubsequences: false)
-    let integer = _grouped(parts[0])
-    guard parts.count == 2 else { return integer }
-    var fraction = String(parts[1].prefix(maxFractionDigits))
-    while fraction.last == "0" { fraction.removeLast() }
-    return fraction.isEmpty ? integer : "\(integer).\(fraction)"
-}
-
-extension BinaryInteger {
-    /// `1234` → `1,234`.
-    public func formatted() -> String { _grouped(Substring(String(self))) }
-}
-
-extension BinaryFloatingPoint where Self: CustomStringConvertible {
-    /// `1234.5678` → `1,234.568`; whole numbers lose the `.0`.
-    public func formatted() -> String {
-        guard isFinite else { return isNaN ? "NaN" : (self < 0 ? "-∞" : "∞") }
-        // Round to 3 fraction digits in integer arithmetic to avoid exponents.
-        let scaled = (Double(self) * 1000).rounded()
-        let negative = scaled < 0
-        let magnitude = Int64(min(abs(scaled), Double(Int64.max / 2)))
-        let integer = magnitude / 1000
-        let fraction = magnitude % 1000
-        let text = "\(negative && magnitude != 0 ? "-" : "")\(integer)." + _threeDigits(fraction)
-        return _formatDecimalString(text)
-    }
-}
-
-/// Three-digit zero-padded fraction.
-private func _threeDigits(_ value: Int64) -> String {
-    let raw = String(value)
-    return String(repeating: "0", count: max(0, 3 - raw.count)) + raw
-}
-
-extension Decimal {
-    /// `Decimal(string: "3.75")! * 4` → `15`; `Decimal(string: "1234.5")!` → `1,234.5`.
-    public func formatted() -> String { _formatDecimalString(description) }
-}
-
-// MARK: - Strings
-
-extension StringProtocol {
-    public func localizedCaseInsensitiveContains<T: StringProtocol>(_ other: T) -> Bool {
-        lowercased().contains(other.lowercased())
-    }
-
-    public func localizedStandardContains<T: StringProtocol>(_ other: T) -> Bool {
-        localizedCaseInsensitiveContains(other)
-    }
-
-    public func localizedCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
-        let a = String(self), b = String(other)
-        return a == b ? .orderedSame : (a < b ? .orderedAscending : .orderedDescending)
-    }
-
-    public func localizedCaseInsensitiveCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
-        lowercased().localizedCompare(other.lowercased())
-    }
-
-    public func localizedStandardCompare<T: StringProtocol>(_ other: T) -> ComparisonResult {
-        localizedCaseInsensitiveCompare(other)
-    }
-}
-#endif

package/Sources/FoundationLite/Interaction.swift

@@ -1,146 +0,0 @@
-// Glue between FoundationEssentials and the SwiftUI shim for the Phase 8
-// controls and list editing (docs/ops-protocol.md, "Phase 8"): the shim
-// cannot name Foundation types, so it is generic over small protocols that
-// this file conforms Foundation's types to. Also the Foundation API the
-// Hacking with SwiftUI projects use that FoundationEssentials lacks:
-// `IndexSet`, `trimmingCharacters(in:)` and the number format styles.
-
-import FoundationEssentials
-import SwiftUI
-
-// MARK: - Dates
-
-extension Date: _DatePickerValue {
-    public var _secondsSince1970: Double { timeIntervalSince1970 }
-    public init(_secondsSince1970 seconds: Double) {
-        self.init(timeIntervalSince1970: seconds)
-    }
-}
-
-// MARK: - IndexSet
-
-/// The subset of Foundation's `IndexSet` that `onDelete` / `onMove` and
-/// `remove(atOffsets:)` need. FoundationEssentials does not ship `IndexSet`.
-public struct IndexSet: Hashable, Sendable, Sequence, _OffsetSet {
-    public private(set) var _offsets: [Int]
-
-    public init() { _offsets = [] }
-    public init(integer: Int) { _offsets = [integer] }
-    public init(integersIn range: Range<Int>) { _offsets = Array(range) }
-    public init(integersIn range: ClosedRange<Int>) { _offsets = Array(range) }
-    public init<S: Sequence>(_ indexes: S) where S.Element == Int {
-        _offsets = Array(Set(indexes)).sorted()
-    }
-    public init(_offsets: [Int]) {
-        self._offsets = Array(Set(_offsets)).sorted()
-    }
-
-    public var count: Int { _offsets.count }
-    public var isEmpty: Bool { _offsets.isEmpty }
-    public var first: Int? { _offsets.first }
-    public var last: Int? { _offsets.last }
-    public func contains(_ integer: Int) -> Bool { _offsets.contains(integer) }
-
-    public mutating func insert(_ integer: Int) {
-        if !_offsets.contains(integer) { _offsets = (_offsets + [integer]).sorted() }
-    }
-    public mutating func remove(_ integer: Int) { _offsets.removeAll { $0 == integer } }
-
-    public func makeIterator() -> IndexingIterator<[Int]> { _offsets.makeIterator() }
-}
-
-// MARK: - Strings
-
-/// The subset of Foundation's `CharacterSet` that `trimmingCharacters(in:)`
-/// needs (FoundationEssentials does not ship `CharacterSet`).
-public struct CharacterSet: Hashable, Sendable {
-    var scalars: Set<Unicode.Scalar>
-
-    public init(charactersIn string: String) {
-        scalars = Set(string.unicodeScalars)
-    }
-
-    public func contains(_ scalar: Unicode.Scalar) -> Bool { scalars.contains(scalar) }
-
-    /// Space and tab, like Foundation's `whitespaces`.
-    public static var whitespaces: CharacterSet { CharacterSet(charactersIn: " \t") }
-    public static var whitespacesAndNewlines: CharacterSet { CharacterSet(charactersIn: " \t\n\r") }
-    public static var newlines: CharacterSet { CharacterSet(charactersIn: "\n\r") }
-}
-
-extension StringProtocol {
-    /// Removes the characters of `set` from both ends.
-    public func trimmingCharacters(in set: CharacterSet) -> String {
-        var scalars = Substring(self).unicodeScalars[...]
-        while let first = scalars.first, set.contains(first) { scalars.removeFirst() }
-        while let last = scalars.last, set.contains(last) { scalars.removeLast() }
-        return String(scalars)
-    }
-
-    /// Every occurrence of `target` replaced by `replacement`.
-    public func replacingOccurrences(of target: String, with replacement: String) -> String {
-        guard !target.isEmpty else { return String(self) }
-        return String(self).split(separator: target, omittingEmptySubsequences: false).joined(separator: replacement)
-    }
-}
-
-// MARK: - Number format styles
-
-/// `Text(value, format: .number)` / `.currency(code:)` for floating-point
-/// values, mirroring `Foundation.FloatingPointFormatStyle` (not in
-/// FoundationEssentials). US English only.
-public struct FloatingPointFormatStyle<Value: BinaryFloatingPoint & CustomStringConvertible & LosslessStringConvertible>: _TextFormat, Sendable {
-    public typealias Input = Value
-
-    public init() {}
-
-    public func _formatText(_ value: Value) -> String { value.formatted() }
-
-    public func _parseText(_ text: String) -> Value? {
-        Value(text.replacingOccurrences(of: ",", with: "").trimmingCharacters(in: .whitespaces))
-    }
-
-    /// `$1,234.50`; negative amounts `-$1.00`. Three-letter codes other than
-    /// USD print as `EUR 1,234.50`, like `Locale(identifier: "en_US")`.
-    public struct Currency: _TextFormat, Sendable {
-        public typealias Input = Value
-        public var code: String
-
-        public init(code: String) { self.code = code }
-
-        public func _formatText(_ value: Value) -> String {
-            let amount = Double(value)
-            let digits = _grouped(Substring(String(Int(abs(amount).rounded(.down))))) + "." + _twoDigits(Int(((abs(amount) * 100).rounded()) ) % 100)
-            let sign = amount < 0 ? "-" : ""
-            return code == "USD" ? "\(sign)$\(digits)" : "\(sign)\(code) \(digits)"
-        }
-
-        public func _parseText(_ text: String) -> Value? {
-            var cleaned = text.trimmingCharacters(in: .whitespaces)
-            for token in ["$", ",", code, " "] { cleaned = cleaned.replacingOccurrences(of: token, with: "") }
-            return Value(cleaned)
-        }
-    }
-}
-
-/// `Text(count, format: .number)` for integers.
-public struct IntegerFormatStyle<Value: BinaryInteger & LosslessStringConvertible>: _TextFormat, Sendable {
-    public typealias Input = Value
-    public init() {}
-    public func _formatText(_ value: Value) -> String { value.formatted() }
-    public func _parseText(_ text: String) -> Value? { Value(text.replacingOccurrences(of: ",", with: "")) }
-}
-
-extension _TextFormat where Self == FloatingPointFormatStyle<Double> {
-    public static var number: FloatingPointFormatStyle<Double> { FloatingPointFormatStyle() }
-}
-
-extension _TextFormat where Self == FloatingPointFormatStyle<Double>.Currency {
-    public static func currency(code: String) -> FloatingPointFormatStyle<Double>.Currency {
-        FloatingPointFormatStyle<Double>.Currency(code: code)
-    }
-}
-
-extension _TextFormat where Self == IntegerFormatStyle<Int> {
-    public static var number: IntegerFormatStyle<Int> { IntegerFormatStyle() }
-}

package/Sources/FoundationLite/Timer.swift

@@ -1,48 +0,0 @@
-// `Timer` for the browser: `Timer.publish(every:on:in:).autoconnect()` with
-// SwiftUI's `onReceive`, and `scheduledTimer(withTimeInterval:repeats:block:)`.
-// Ticks come from the runtime's executor (`_IntervalPublisher` and
-// `_ExecutorTimer` in the SwiftUI shim), so headless runs stay deterministic.
-// FoundationEssentials has no Timer or RunLoop; these are the pieces SwiftUI
-// code uses. FoundationBridge has the same two types for full Foundation,
-// whose own Timer needs CFRunLoop and cannot link on WASI.
-
-import FoundationEssentials
-import SwiftUI
-
-public final class RunLoop: @unchecked Sendable {
-    public struct Mode: Hashable, Sendable {
-        public let rawValue: String
-        public init(rawValue: String) { self.rawValue = rawValue }
-        public static let `default` = Mode(rawValue: "default")
-        public static let common = Mode(rawValue: "common")
-    }
-    nonisolated(unsafe) public static let main = RunLoop()
-    public static var current: RunLoop { main }
-}
-
-public final class Timer: @unchecked Sendable {
-    /// Emits the current date every `interval` seconds once subscribed.
-    public typealias TimerPublisher = _IntervalPublisher<Date>
-
-    public static func publish(every interval: TimeInterval, tolerance: TimeInterval? = nil, on runLoop: RunLoop = .main, in mode: RunLoop.Mode = .default, options: Never? = nil) -> TimerPublisher {
-        _IntervalPublisher(every: interval) { Date() }
-    }
-
-    private var core: _ExecutorTimer!
-
-    public var isValid: Bool { core.isValid }
-    public var timeInterval: TimeInterval { core.timeInterval }
-
-    init(interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) {
-        // The core's task holds this timer until it has fired or is invalidated.
-        core = _ExecutorTimer(interval: interval, repeats: repeats) { _ in block(self) }
-    }
-
-    /// Schedules `block` after `interval` seconds, repeating when asked, on the executor.
-    @discardableResult
-    public static func scheduledTimer(withTimeInterval interval: TimeInterval, repeats: Bool, block: @escaping @Sendable (Timer) -> Void) -> Timer {
-        Timer(interval: interval, repeats: repeats, block: block)
-    }
-
-    public func invalidate() { core.invalidate() }
-}

package/Sources/_FoundationCommon/_FoundationCommon.swift

@@ -1,10 +0,0 @@
-/// What FoundationLite (lean builds) and FoundationBridge (full builds) share:
-/// the browser's `UserDefaults` and `Bundle`. Both are written against
-/// FoundationEssentials, whose `Data`, `Date`, `URL` and `FileManager` are the
-/// very types the full Foundation re-exports, so one implementation serves
-/// both modes. FoundationLite re-exports this module; FoundationBridge aliases
-/// the two classes, and the CLI's generated file aliases them again in the app
-/// so they shadow corelibs Foundation's (whose `UserDefaults` cannot persist
-/// and whose `Bundle.main` traps on WASI). See docs/ops-protocol.md, "Phase 11".
-import FoundationEssentials
-import SwiftUI