@swiftbrowser/swift 0.0.0-stage → 0.2.0

package/Sources/SwiftUI/API/Controls.swift

@@ -0,0 +1,300 @@
+import Foundation
+
+// MARK: - TextField
+
+public protocol TextFieldStyle {
+    var _name: String { get }
+}
+public struct DefaultTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct PlainTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "plain" }
+}
+public struct RoundedBorderTextFieldStyle: TextFieldStyle {
+    public init() {}
+    public var _name: String { "roundedBorder" }
+}
+extension TextFieldStyle where Self == DefaultTextFieldStyle {
+    public static var automatic: DefaultTextFieldStyle { DefaultTextFieldStyle() }
+}
+extension TextFieldStyle where Self == PlainTextFieldStyle {
+    public static var plain: PlainTextFieldStyle { PlainTextFieldStyle() }
+}
+extension TextFieldStyle where Self == RoundedBorderTextFieldStyle {
+    public static var roundedBorder: RoundedBorderTextFieldStyle { RoundedBorderTextFieldStyle() }
+}
+
+nonisolated extension View {
+    public func textFieldStyle<S: TextFieldStyle>(_ style: S) -> some View {
+        environment(\._textFieldStyle, style._name)
+    }
+}
+
+/// What the user typed into a formatted field, and the formatted form of the
+/// value it parsed to. The field shows the typed text while the bound value
+/// still formats to that form; an outside change to the value replaces it.
+struct _TextDraft {
+    var typed: String
+    var formatted: String
+}
+
+public struct TextField<Label: View> {
+    let placeholder: String
+    let text: Binding<String>
+    let secure: Bool
+    /// Persistent storage for `TextField(_:value:format:)` (unused otherwise);
+    /// a `State` so the runtime keeps it across re-renders.
+    let draft: State<_TextDraft?>
+    /// `TextField(_:text:axis: .vertical)`: a multi-line field that grows
+    /// with its text (TextFieldAxis.swift).
+    var axis: Axis = .horizontal
+    /// The iOS 13 `onCommit:` action (TextFieldCommit.swift): run on Return, like `.onSubmit`.
+    var onCommit: (() -> Void)?
+
+    init(placeholder: String, text: Binding<String>, secure: Bool) {
+        self.placeholder = placeholder
+        self.text = text
+        self.secure = secure
+        draft = State(wrappedValue: nil)
+    }
+}
+
+extension TextField where Label == Text {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
+        self.init(placeholder: String(title), text: text, secure: false)
+    }
+
+    /// The prompt, when given, is the placeholder; the title names the field.
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>, prompt: Text?) {
+        self.init(placeholder: prompt?.content ?? String(title), text: text, secure: false)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, prompt: Text? = nil) {
+        self.init(placeholder: prompt?.content ?? titleKey.key, text: text, secure: false)
+    }
+
+    /// A field bound to a value through a format: it shows the formatted value
+    /// and, as the user types, parses the text and sets the value when parsing
+    /// succeeds. The typed text stays visible while the value matches it.
+    public init<S: StringProtocol, F: ParseableFormatStyle>(_ title: S, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(placeholder: prompt?.content ?? String(title), value: value, format: format)
+    }
+
+    public init<F: ParseableFormatStyle>(_ titleKey: LocalizedStringKey, value: Binding<F.FormatInput>, format: F, prompt: Text? = nil)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        self.init(placeholder: prompt?.content ?? titleKey.key, value: value, format: format)
+    }
+
+    /// The formatted field with its placeholder resolved.
+    init<F: ParseableFormatStyle>(placeholder: String, value: Binding<F.FormatInput>, format: F)
+    where F.FormatOutput == String, F.Strategy.ParseInput == String {
+        let draft = State<_TextDraft?>(wrappedValue: nil)
+        let text = Binding<String>(
+            get: {
+                let formatted = format.format(value.wrappedValue)
+                if let current = draft.wrappedValue, current.formatted == formatted { return current.typed }
+                return formatted
+            },
+            set: { typed in
+                if let parsed = try? format.parseStrategy.parse(typed) {
+                    draft.wrappedValue = _TextDraft(typed: typed, formatted: format.format(parsed))
+                    value.wrappedValue = parsed
+                } else {
+                    let formatted = draft.wrappedValue?.formatted ?? format.format(value.wrappedValue)
+                    draft.wrappedValue = _TextDraft(typed: typed, formatted: formatted)
+                }
+            }
+        )
+        self.placeholder = placeholder
+        self.text = text
+        secure = false
+        self.draft = draft
+    }
+}
+extension TextField: _PrimitiveView {}
+extension TextField: _HostView {
+    var _kind: String { "textfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON {
+        var props: [String: _JSON] = [
+            "text": .string(text.wrappedValue),
+            "placeholder": .string(placeholder),
+            "style": .string(environment._textFieldStyle),
+            "secure": .bool(secure),
+        ]
+        // Phase 12: `.focused(...)` binds the field's focus; `.onSubmit` wants
+        // the Enter key; `.submitLabel` names the return key.
+        if let focus = environment._focus { props["focused"] = .bool(focus.isFocused()) }
+        if environment._onSubmit != nil || onCommit != nil { props["submit"] = .bool(true) }
+        if let label = environment._submitLabel { props["submitLabel"] = .string(label) }
+        if axis == .vertical { props["axis"] = .string("vertical") }
+        return .object(props)
+    }
+    var _handler: ((_JSON) -> Void)? { _handler(in: EnvironmentValues()) }
+}
+extension TextField: _EnvironmentHandling {
+    /// Text (`"value"` as a string), `focus` (`{type, value: Bool}`) and `submit` (`{type}`) events.
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? {
+        let text = self.text
+        let focus = environment._focus
+        let onSubmit = environment._onSubmit
+        let onCommit = self.onCommit
+        return { payload in
+            switch payload {
+            case .string(let value):
+                text.wrappedValue = value
+            case .object(let fields):
+                switch fields["type"] {
+                case .string("focus")?:
+                    if case .bool(let focused)? = fields["value"] { focus?.setFocused(focused) }
+                case .string("submit")?:
+                    onCommit?()
+                    onSubmit?()
+                default:
+                    break
+                }
+            default:
+                break
+            }
+        }
+    }
+}
+
+public struct SecureField<Label: View> {
+    let field: TextField<Label>
+}
+extension SecureField where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>) {
+        field = TextField(placeholder: titleKey.key, text: text, secure: true)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, text: Binding<String>) {
+        field = TextField(placeholder: String(title), text: text, secure: true)
+    }
+}
+extension SecureField: _PrimitiveView {}
+extension SecureField: _HostView {
+    var _kind: String { "textfield" }
+    func _props(in environment: EnvironmentValues) -> _JSON { field._props(in: environment) }
+    var _handler: ((_JSON) -> Void)? { field._handler }
+}
+extension SecureField: _EnvironmentHandling {
+    func _handler(in environment: EnvironmentValues) -> ((_JSON) -> Void)? { field._handler(in: environment) }
+}
+
+// MARK: - Toggle
+
+public struct Toggle<Label: View> {
+    let isOn: Binding<Bool>
+    let label: Label
+
+    public init(isOn: Binding<Bool>, @ViewBuilder label: () -> Label) {
+        self.isOn = isOn
+        self.label = label()
+    }
+}
+extension Toggle where Label == Text {
+    public init(_ titleKey: LocalizedStringKey, isOn: Binding<Bool>) {
+        self.init(isOn: isOn) { Text(titleKey) }
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, isOn: Binding<Bool>) {
+        self.init(isOn: isOn) { Text(title) }
+    }
+}
+extension Toggle: _PrimitiveView {}
+extension Toggle: _HostView {
+    var _kind: String { "toggle" }
+    func _props(in environment: EnvironmentValues) -> _JSON { .object(["isOn": .bool(isOn.wrappedValue)]) }
+    var _content: [any View] { [label] }
+    var _handler: ((_JSON) -> Void)? {
+        let isOn = self.isOn
+        return { payload in
+            if case .bool(let value) = payload { isOn.wrappedValue = value }
+        }
+    }
+}
+
+// MARK: - Label
+
+/// A title and an icon, laid out like SwiftUI's default label style.
+public struct Label<Title: View, Icon: View>: View {
+    let title: Title
+    let icon: Icon
+
+    public init(@ViewBuilder title: () -> Title, @ViewBuilder icon: () -> Icon) {
+        self.title = title()
+        self.icon = icon()
+    }
+
+    public var body: some View {
+        _StyledLabel(title: title, icon: icon)
+    }
+}
+
+extension Label where Title == Text, Icon == Image {
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, systemImage: String) {
+        self.title = Text(title)
+        self.icon = Image(systemName: systemImage)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, systemImage: String) {
+        self.title = Text(titleKey)
+        self.icon = Image(systemName: systemImage)
+    }
+
+    @_disfavoredOverload
+    public init<S: StringProtocol>(_ title: S, image name: String) {
+        self.title = Text(title)
+        self.icon = Image(name)
+    }
+
+    public init(_ titleKey: LocalizedStringKey, image name: String) {
+        self.title = Text(titleKey)
+        self.icon = Image(name)
+    }
+}
+
+// MARK: - Enabling
+
+nonisolated extension View {
+    public func disabled(_ disabled: Bool) -> some View {
+        _styled { $0.disabled = disabled ? true : nil }
+    }
+
+    /// Runs `action` once, right after the view is first rendered.
+    public func onAppear(perform action: (@MainActor () -> Void)? = nil) -> some View {
+        _OnAppearView(content: self, action: action)
+    }
+
+    /// Runs `action` once the view has left the screen (after the render that removed it).
+    public func onDisappear(perform action: (@MainActor () -> Void)? = nil) -> some View {
+        _OnDisappearView(content: self, action: action)
+    }
+}
+
+struct _OnDisappearView<Content: View> {
+    let content: Content
+    let action: (@MainActor () -> Void)?
+}
+extension _OnDisappearView: _PrimitiveView {}
+extension _OnDisappearView: _GroupView {
+    var _children: [any View] { [content] }
+}
+
+struct _OnAppearView<Content: View> {
+    let content: Content
+    let action: (@MainActor () -> Void)?
+}
+extension _OnAppearView: _PrimitiveView {}
+extension _OnAppearView: _GroupView {
+    var _children: [any View] { [content] }
+}