From ba7e1ee17706717785bc37bfa876543742e38494 Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Wed, 7 May 2025 18:46:17 +0300
Subject: [PATCH 1/6] add CustomCell

---
 LICENSE                                       | 21 ++++
 Package.swift                                 | 45 ++++++---
 Sources/CustomCell/CustomCell.swift           | 99 +++++++++++++++++++
 .../CustomCellStyle+Environment.swift         | 34 +++++++
 .../CustomCellStyle/CustomCellStyle.swift     | 27 +++++
 .../CustomCellStyleConfiguration.swift        | 39 ++++++++
 .../DefaultCustomCellStyle.swift              | 35 +++++++
 7 files changed, 288 insertions(+), 12 deletions(-)
 create mode 100644 LICENSE
 create mode 100644 Sources/CustomCell/CustomCell.swift
 create mode 100644 Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift
 create mode 100644 Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift
 create mode 100644 Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift
 create mode 100644 Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift

diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..6bee456
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Valeriy Malishevskyi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/Package.swift b/Package.swift
index 4150f2f..0cc868b 100644
--- a/Package.swift
+++ b/Package.swift
@@ -3,22 +3,43 @@
 
 import PackageDescription
 
+struct Component {
+    static let sharedDependencies: [Target.Dependency] = [
+        .product(name: "SwiftHelpers", package: "SwiftHelpers"),
+        .product(name: "SwiftUIHelpers", package: "SwiftUIHelpers"),
+    ]
+    
+    let name: String
+    let dependencies: [Target.Dependency]
+    
+    init(name: String, dependencies: [Target.Dependency] = sharedDependencies) {
+        self.name = name
+        self.dependencies = dependencies
+    }
+}
+
+let components: [Component] = [
+    Component(name: "CustomCell"),
+    //Component(name: "CustomPicker")
+]
+
 let package = Package(
     name: "CustomComponents",
+    platforms: [.macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v10), .macCatalyst(.v15)],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.
-        .library(
-            name: "CustomComponents",
-            targets: ["CustomComponents"]),
+        .library(name: "CustomComponents", targets: ["CustomComponents"]),
     ],
-    targets: [
-        // Targets are the basic building blocks of a package, defining a module or a test suite.
-        // Targets can depend on other targets in this package and products from dependencies.
-        .target(
-            name: "CustomComponents"),
-        .testTarget(
-            name: "CustomComponentsTests",
-            dependencies: ["CustomComponents"]
-        ),
+    dependencies: [
+        .package(url: "https://github.com/stalkermv/SwiftHelpers.git", from: "1.0.0"),
+        .package(url: "https://github.com/stalkermv/SwiftUIHelpers.git", from: "1.0.0"),
     ]
 )
+
+let umbrella: Target = .target(name: "CustomComponents", dependencies: components.map { .target(name: $0.name) })
+let testTarget: Target = .testTarget(name: "CustomComponentsTests", dependencies: ["CustomComponents"])
+let componentsTargets: [Target] = components.map { component in
+    .target(name: component.name, dependencies: component.dependencies)
+}
+
+package.targets = [umbrella, testTarget] + componentsTargets
diff --git a/Sources/CustomCell/CustomCell.swift b/Sources/CustomCell/CustomCell.swift
new file mode 100644
index 0000000..fedb7ef
--- /dev/null
+++ b/Sources/CustomCell/CustomCell.swift
@@ -0,0 +1,99 @@
+//
+//  CustomCell.swift
+//  UIComponentsLibrary
+//
+//  Created by Valeriy Malishevskyi on 06.08.2024.
+//
+
+import SwiftUI
+import SwiftUIHelpers
+
+/// A configurable cell component that adapts to a custom style and supports image, label, secondary text, and accessory views.
+///
+/// `CustomCell` is a generic, reusable building block for list items or rows. It supports the injection
+/// of four content types: a main `content`, a `secondary` label, an optional leading `image`, and a trailing `accessory`.
+/// The appearance is driven by a `CustomCellStyle` provided via the environment.
+///
+/// ```swift
+/// CustomCell {
+///     Text("Title")
+/// } secondary: {
+///     Text("Subtitle")
+/// } image: {
+///     Image(systemName: "star")
+/// } accessory: {
+///     Image(systemName: "chevron.right")
+/// }
+/// ```
+///
+/// You can override the visual style using `.customCellStyle(...)`.
+public struct CustomCell<Content, Image, Secondary, Accessory> : View
+where Content: View, Image: View, Secondary: View, Accessory: View {
+    
+    @Environment(\.customCellStyle) var style
+    
+    @ViewBuilder var content: Content
+    @ViewBuilder var image: Image
+    @ViewBuilder var secondary: Secondary
+    @ViewBuilder var accessory: Accessory
+        
+    public var body: some View {
+        let configuration = CustomCellStyleConfiguration(
+            label: .init(body: AnyView(content)),
+            secondaryLabel: .init(body: AnyView(secondary)),
+            image: .init(body: AnyView(image)),
+            accessory: .init(body: AnyView(accessory))
+        )
+        
+        AnyView(style.makeBody(configuration: configuration))
+    }
+}
+
+extension CustomCell {
+    /// Creates a `CustomCell` with optional secondary, image, and accessory views.
+    ///
+    /// - Parameters:
+    ///   - content: The primary content view.
+    ///   - secondary: A secondary label view (e.g. subtitle). Defaults to `EmptyView`.
+    ///   - image: A leading image view. Defaults to `EmptyView`.
+    ///   - accessory: A trailing accessory view. Defaults to `EmptyView`.
+    public init(
+        @ViewBuilder content: () -> Content,
+        @ViewBuilder secondary: () -> Secondary = EmptyView.init,
+        @ViewBuilder image: () -> Image = EmptyView.init,
+        @ViewBuilder accessory: () -> Accessory = EmptyView.init
+    ) {
+        self.init(
+            content: content,
+            image: image,
+            secondary: secondary,
+            accessory: accessory
+        )
+    }
+}
+
+#Preview {
+    List {
+        CustomCell {
+            Text("Default")
+        }
+        
+        CustomCell {
+            Text("With image")
+        } image: {
+            Image(systemName: "star")
+        }
+        
+        CustomCell {
+            Text("Subtitle")
+        } secondary: {
+            Text("Secondary")
+        }
+        
+        CustomCell {
+            Text("Accessory")
+        } accessory: {
+            Image(systemName: "arrow.right")
+        }
+    }
+}
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift b/Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift
new file mode 100644
index 0000000..3e1445b
--- /dev/null
+++ b/Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift
@@ -0,0 +1,34 @@
+//
+//  CustomCellStyle+Environment.swift
+//  UIComponentsLibrary
+//
+//  Created by Valeriy Malishevskyi on 06.08.2024.
+//
+
+import SwiftUI
+
+extension View {
+
+    /// Sets a custom style to be used for `CustomCell` within the view hierarchy.
+    ///
+    /// - Parameter style: The custom style to apply.
+    /// - Returns: A view that uses the specified `CustomCellStyle`.
+    public func customCellStyle<Style: CustomCellStyle>(_ style: Style) -> some View {
+        environment(\.customCellStyle, style)
+    }
+}
+
+extension EnvironmentValues {
+
+    /// The current `CustomCellStyle` from the environment.
+    var customCellStyle: any CustomCellStyle {
+        get { self[CustomCellStyleKey.self] }
+        set { self[CustomCellStyleKey.self] = newValue }
+    }
+}
+
+struct CustomCellStyleKey: EnvironmentKey {
+
+    /// The default cell style used when no other style is set in the environment.
+    nonisolated(unsafe) static let defaultValue: any CustomCellStyle = DefaultCustomCellStyle()
+}
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift b/Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift
new file mode 100644
index 0000000..be4a5b2
--- /dev/null
+++ b/Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift
@@ -0,0 +1,27 @@
+//
+//  CustomCellStyle.swift
+//  UIComponentsLibrary
+//
+//  Created by Valeriy Malishevskyi on 06.08.2024.
+//
+
+import SwiftUI
+
+/// A protocol that defines the visual appearance of a `CustomCell`.
+///
+/// Conform to `CustomCellStyle` to customize the layout and appearance of cells across your app.
+/// Apply your style with `.customCellStyle(...)` on any view.
+public protocol CustomCellStyle {
+
+    /// The configuration passed into a custom cell style.
+    typealias Configuration = CustomCellStyleConfiguration
+
+    /// The type of view produced by the style.
+    associatedtype Body: View
+
+    /// Creates a view representing the body of a custom cell using the given configuration.
+    ///
+    /// - Parameter configuration: The current configuration of the custom cell.
+    /// - Returns: A view representing the styled cell.
+    @MainActor func makeBody(configuration: Self.Configuration) -> Self.Body
+}
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift b/Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift
new file mode 100644
index 0000000..f3c18d9
--- /dev/null
+++ b/Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift
@@ -0,0 +1,39 @@
+//
+//  CustomCellStyleConfiguration.swift
+//  UIComponentsLibrary
+//
+//  Created by Valeriy Malishevskyi on 06.08.2024.
+//
+
+import SwiftUI
+
+/// A configuration object that describes the content provided to a `CustomCellStyle`.
+///
+/// Contains views for the main label, secondary label, image, and accessory.
+public struct CustomCellStyleConfiguration {
+
+    /// The primary label content.
+    public struct Label: View {
+        public let body: AnyView
+    }
+
+    /// The secondary label content.
+    public struct SecondaryLabel: View {
+        public let body: AnyView
+    }
+
+    /// The image content, typically displayed on the leading edge.
+    public struct Image: View {
+        public let body: AnyView
+    }
+
+    /// The accessory content, typically displayed on the trailing edge.
+    public struct Accessory: View {
+        public let body: AnyView
+    }
+
+    public let label: Label
+    public let secondaryLabel: SecondaryLabel
+    public let image: Image
+    public let accessory: Accessory
+}
diff --git a/Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift b/Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift
new file mode 100644
index 0000000..e1fdde4
--- /dev/null
+++ b/Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift
@@ -0,0 +1,35 @@
+//
+//  DefaultCustomCellStyle.swift
+//  UIComponentsLibrary
+//
+//  Created by Valeriy Malishevskyi on 06.08.2024.
+//
+
+import SwiftUI
+import SwiftUIHelpers
+
+extension CustomCellStyle where Self == DefaultCustomCellStyle {
+    static var `default`: DefaultCustomCellStyle {
+        DefaultCustomCellStyle()
+    }
+}
+
+public struct DefaultCustomCellStyle: CustomCellStyle {
+    public func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.image
+
+            VStack(alignment: .leading) {
+                configuration.label
+                
+                configuration.secondaryLabel
+                    .font(.subheadline)
+                    .foregroundStyle(.secondary)
+            }
+            .frame(maxWidth: .infinity, alignment: .leading)
+            
+            configuration.accessory
+                .foregroundStyle(.tint)
+        }
+    }
+}

From 810d54e8f118d1d77d6af38226145ae8f676e1aa Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Wed, 7 May 2025 19:04:17 +0300
Subject: [PATCH 2/6] Create README.md

---
 README.md | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 README.md

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..4612828
--- /dev/null
+++ b/README.md
@@ -0,0 +1,47 @@
+# CustomComponents
+
+CustomComponents is a Swift package offering a collection of reusable, production-ready SwiftUI components. Designed to accelerate iOS development, this library provides modular UI elements that seamlessly integrate into your SwiftUI projects.
+
+## Features
+- Reusable SwiftUI Components: A variety of customizable UI elements to enhance your app’s interface.
+- Modular Design: Each component is self-contained, promoting clean and maintainable code.
+- Swift Package Manager Support: Easily integrate into your projects using Swift Package Manager.
+
+## Installation
+
+You can add CustomComponents to your project using Swift Package Manager:
+1. In Xcode, go to File > Add Packages…
+2. Enter the repository URL: `https://github.com/stalkermv/CustomComponents`
+3. Select the development branch.
+
+Alternatively, add it directly to your Package.swift:
+
+```
+dependencies: [
+    .package(url: "https://github.com/stalkermv/CustomComponents.git", branch: "development")
+]
+```
+
+## Usage
+
+Import CustomComponents in your SwiftUI files:
+
+```swift
+import CustomComponents
+```
+
+Then, utilize the provided components as needed. For example:
+
+```swift
+struct ContentView: View {
+    var body: some View {
+        CustomCell {
+            Text("Hello, Custom Component!")
+        }
+    }
+}
+```
+
+## License
+
+CustomComponents is released under the MIT License. See LICENSE for details.

From 37f478bf7091b88e4526a38e208fdd312768ee5e Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Thu, 8 May 2025 21:04:01 +0300
Subject: [PATCH 3/6] Create tests.yml

---
 .github/workflows/tests.yml | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 .github/workflows/tests.yml

diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml
new file mode 100644
index 0000000..37f769c
--- /dev/null
+++ b/.github/workflows/tests.yml
@@ -0,0 +1,24 @@
+# This workflow will build a Swift project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-swift
+
+name: Test
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: macos-15
+
+    steps:
+    - name: Select Xcode 16.3
+      run: sudo xcode-select -s /Applications/Xcode_16.3.app
+    - uses: actions/checkout@v4
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v

From 016d146116d844c73d4cfeb70bfaeb84882944e5 Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Tue, 13 May 2025 02:24:29 +0300
Subject: [PATCH 4/6] add components

---
 Package.resolved                              |   24 +
 Package.swift                                 |    7 +-
 Sources/AsyncButton/AsyncButton.swift         |   79 ++
 .../AsyncButton/AsyncButtonExecution.swift    |   49 +
 .../AsyncButtonExecutionModifier.swift        |   37 +
 Sources/AsyncButton/AsyncButtonOptions.swift  |   26 +
 Sources/AsyncButton/EnvironmentValues.swift   |   13 +
 Sources/AsyncButton/Previews.swift            |   84 ++
 Sources/CustomCell/CustomCell.swift           |   42 +-
 .../CustomCellStyle+Environment.swift         |    1 -
 .../CustomCellStyle.swift                     |    3 +-
 .../CustomCellStyleConfiguration.swift        |    1 -
 .../DefaultCustomCellStyle.swift              |    1 -
 Sources/CustomSection/CustomSection.swift     |  137 +++
 .../CustomSection/CustomSectionStyle.swift    |   48 +
 .../CustomSectionStyleEnvironmentKey.swift    |   16 +
 .../DefaultCustomSectionStyle.swift           |   17 +
 .../CustomStepper+Initializers.swift          | 1040 +++++++++++++++++
 Sources/CustomStepper/CustomStepper.swift     |  281 +++++
 .../CustomStepperElementConfiguration.swift   |   17 +
 .../CustomStepperElementStyle.swift           |   38 +
 .../CustomStepper/CustomStepperStyle.swift    |   26 +
 .../CustomStepperStyleConfiguration.swift     |   43 +
 .../DefaultCustomStepperElementStyle.swift    |   21 +
 .../DefaultCustomStepperStyle.swift           |   29 +
 .../View+CustomStepperElementStyle.swift      |   29 +
 .../View+CustomStepperStyle.swift             |   31 +
 .../CustomTextField+Init.swift                |  339 ++++++
 Sources/CustomTextField/CustomTextField.swift |  226 ++++
 .../CustomTextFieldStyle.swift                |   49 +
 .../CustomTextFieldStyleConfiguration.swift   |   44 +
 .../DefaultCustomTextFieldStyle.swift         |   13 +
 .../CustomTextField/EmptyFormatStyle.swift    |   23 +
 .../CustomTextField/EnvironmentValues.swift   |   29 +
 .../CustomTextField/TextFieldStyleProxy.swift |   16 +
 .../View+CustomTextFieldStyle.swift           |   41 +
 36 files changed, 2911 insertions(+), 9 deletions(-)
 create mode 100644 Package.resolved
 create mode 100644 Sources/AsyncButton/AsyncButton.swift
 create mode 100644 Sources/AsyncButton/AsyncButtonExecution.swift
 create mode 100644 Sources/AsyncButton/AsyncButtonExecutionModifier.swift
 create mode 100644 Sources/AsyncButton/AsyncButtonOptions.swift
 create mode 100644 Sources/AsyncButton/EnvironmentValues.swift
 create mode 100644 Sources/AsyncButton/Previews.swift
 rename Sources/CustomCell/{CustomCellStyle => }/CustomCellStyle+Environment.swift (97%)
 rename Sources/CustomCell/{CustomCellStyle => }/CustomCellStyle.swift (93%)
 rename Sources/CustomCell/{CustomCellStyle => }/CustomCellStyleConfiguration.swift (97%)
 rename Sources/CustomCell/{CustomCellStyle => }/DefaultCustomCellStyle.swift (97%)
 create mode 100644 Sources/CustomSection/CustomSection.swift
 create mode 100644 Sources/CustomSection/CustomSectionStyle.swift
 create mode 100644 Sources/CustomSection/CustomSectionStyleEnvironmentKey.swift
 create mode 100644 Sources/CustomSection/DefaultCustomSectionStyle.swift
 create mode 100644 Sources/CustomStepper/CustomStepper+Initializers.swift
 create mode 100644 Sources/CustomStepper/CustomStepper.swift
 create mode 100644 Sources/CustomStepper/CustomStepperElementConfiguration.swift
 create mode 100644 Sources/CustomStepper/CustomStepperElementStyle.swift
 create mode 100644 Sources/CustomStepper/CustomStepperStyle.swift
 create mode 100644 Sources/CustomStepper/CustomStepperStyleConfiguration.swift
 create mode 100644 Sources/CustomStepper/DefaultCustomStepperElementStyle.swift
 create mode 100644 Sources/CustomStepper/DefaultCustomStepperStyle.swift
 create mode 100644 Sources/CustomStepper/View+CustomStepperElementStyle.swift
 create mode 100644 Sources/CustomStepper/View+CustomStepperStyle.swift
 create mode 100644 Sources/CustomTextField/CustomTextField+Init.swift
 create mode 100644 Sources/CustomTextField/CustomTextField.swift
 create mode 100644 Sources/CustomTextField/CustomTextFieldStyle.swift
 create mode 100644 Sources/CustomTextField/CustomTextFieldStyleConfiguration.swift
 create mode 100644 Sources/CustomTextField/DefaultCustomTextFieldStyle.swift
 create mode 100644 Sources/CustomTextField/EmptyFormatStyle.swift
 create mode 100644 Sources/CustomTextField/EnvironmentValues.swift
 create mode 100644 Sources/CustomTextField/TextFieldStyleProxy.swift
 create mode 100644 Sources/CustomTextField/View+CustomTextFieldStyle.swift

diff --git a/Package.resolved b/Package.resolved
new file mode 100644
index 0000000..397d276
--- /dev/null
+++ b/Package.resolved
@@ -0,0 +1,24 @@
+{
+  "originHash" : "f23732d2b879b4a4e2eb81ce177da597f008ed3b62e19a8628e9bbc4796f06d7",
+  "pins" : [
+    {
+      "identity" : "swifthelpers",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/stalkermv/SwiftHelpers.git",
+      "state" : {
+        "revision" : "3d6eda3fbfe4e8607731c3a9c6e2d30711b8024d",
+        "version" : "1.0.3"
+      }
+    },
+    {
+      "identity" : "swiftuihelpers",
+      "kind" : "remoteSourceControl",
+      "location" : "https://github.com/stalkermv/SwiftUIHelpers.git",
+      "state" : {
+        "revision" : "5a1b7138c7b9db75deff39717138ad833aa4c8b8",
+        "version" : "1.0.1"
+      }
+    }
+  ],
+  "version" : 3
+}
diff --git a/Package.swift b/Package.swift
index 0cc868b..8afd3d2 100644
--- a/Package.swift
+++ b/Package.swift
@@ -19,13 +19,16 @@ struct Component {
 }
 
 let components: [Component] = [
+    Component(name: "AsyncButton"),
     Component(name: "CustomCell"),
-    //Component(name: "CustomPicker")
+    Component(name: "CustomSection"),
+    Component(name: "CustomStepper"),
+    Component(name: "CustomTextField")
 ]
 
 let package = Package(
     name: "CustomComponents",
-    platforms: [.macOS(.v12), .iOS(.v15), .tvOS(.v15), .watchOS(.v10), .macCatalyst(.v15)],
+    platforms: [.macOS(.v13), .iOS(.v15), .tvOS(.v15), .watchOS(.v10), .macCatalyst(.v15)],
     products: [
         // Products define the executables and libraries a package produces, making them visible to other packages.
         .library(name: "CustomComponents", targets: ["CustomComponents"]),
diff --git a/Sources/AsyncButton/AsyncButton.swift b/Sources/AsyncButton/AsyncButton.swift
new file mode 100644
index 0000000..b5ad7e4
--- /dev/null
+++ b/Sources/AsyncButton/AsyncButton.swift
@@ -0,0 +1,79 @@
+//
+//  AsyncButton.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+/// A SwiftUI button that supports asynchronous actions with execution control and optional role and styling.
+///
+/// `AsyncButton` triggers an `async` action when tapped, while managing execution state
+/// such as disabling the button during task execution. It supports roles (e.g. `.destructive`) and
+/// can be customized via `AsyncButtonOptions`.
+///
+/// ```swift
+/// AsyncButton {
+///     try await Task.sleep(nanoseconds: 1_000_000_000)
+///     print("Action complete!")
+/// } label: {
+///     Text("Submit")
+/// }
+/// ```
+///
+/// - Note: Internally, this button uses a unique `executionID` to trigger side effects via a custom modifier.
+///
+/// - Parameters:
+///   - role: The semantic role of the button (e.g., `.destructive`). Default is `nil`.
+///   - options: Behavior options that affect execution (e.g. disables during execution). Default is empty.
+///   - action: An async closure to execute on tap.
+///   - label: A `ViewBuilder` closure that generates the button’s label.
+public struct AsyncButton<Label: View>: View {
+
+    private let action: () async -> Void
+    private let label: () -> Label
+    private let role: ButtonRole?
+    private let options: AsyncButtonOptions
+    
+    var executionModifier: AsyncButtonExecutionModifier {
+        AsyncButtonExecutionModifier(
+            executionID: executionID,
+            options: options,
+            isDisabled: $isDisabled,
+            action: action
+        )
+    }
+    
+    @State private var isDisabled = false
+    @State private var executionID: UUID?
+    
+    /// Creates an `AsyncButton` with the given role, options, async action, and label.
+    ///
+    /// - Parameters:
+    ///   - role: The button's semantic role, such as `.cancel` or `.destructive`. Default is `nil`.
+    ///   - options: A set of flags controlling how the async action behaves (e.g., auto-disabling). Default is `[]`.
+    ///   - action: An `async` closure to execute when the button is tapped.
+    ///   - label: A closure that returns the button’s label view.
+    public init(
+        role: ButtonRole? = nil,
+        options: AsyncButtonOptions = [],
+        action: @escaping () async -> Void,
+        @ViewBuilder label: @escaping () -> Label
+    ) {
+        self.role = role
+        self.options = options
+        self.action = action
+        self.label = label
+    }
+    
+    public var body: some View {
+        Button(role: role, action: performAction, label: label)
+            .disabled(isDisabled)
+            .modifier(executionModifier)
+    }
+    
+    private func performAction() {
+        executionID = UUID()
+    }
+}
diff --git a/Sources/AsyncButton/AsyncButtonExecution.swift b/Sources/AsyncButton/AsyncButtonExecution.swift
new file mode 100644
index 0000000..f30c116
--- /dev/null
+++ b/Sources/AsyncButton/AsyncButtonExecution.swift
@@ -0,0 +1,49 @@
+//
+//  AsyncButtonExecution.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+@MainActor final class AsyncButtonExecution: ObservableObject {
+    @Published private(set) var task: Task<Void, Error>?
+    @Published private(set) var isLoading = false
+    private var options: AsyncButtonOptions = []
+    
+    func start(options: AsyncButtonOptions, _ action: @escaping () async -> Void) {
+        self.options = options
+        self.task?.cancel()
+        self.task = Task { [weak self] in
+            let loadingIndicatorTask = Task {
+                try await Task.sleep(for: .seconds(1))
+                try Task.checkCancellation()
+                
+                if !options.contains(.loadingIndicatorHidden) {
+                    self?.isLoading = true
+                }
+            }
+            
+            await action()
+            
+            try Task.checkCancellation()
+            
+            // Cancel loading indicator task
+            loadingIndicatorTask.cancel()
+            
+            if !options.contains(.loadingIndicatorHidden) {
+                self?.isLoading = false
+            }
+
+            self?.task = nil
+        }
+    }
+    
+    deinit {
+        MainActor.assumeIsolated {
+            guard !options.contains(.detachesTask) else { return }
+            task?.cancel()
+        }
+    }
+}
diff --git a/Sources/AsyncButton/AsyncButtonExecutionModifier.swift b/Sources/AsyncButton/AsyncButtonExecutionModifier.swift
new file mode 100644
index 0000000..6146a97
--- /dev/null
+++ b/Sources/AsyncButton/AsyncButtonExecutionModifier.swift
@@ -0,0 +1,37 @@
+//
+//  AsyncButtonExecutionModifier.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+struct AsyncButtonExecutionModifier: ViewModifier {
+    let executionID: UUID?
+    let options: AsyncButtonOptions
+    @Binding var isDisabled: Bool
+    let action: () async -> Void
+    
+    @StateObject private var execution = AsyncButtonExecution()
+    
+    func body(content: Content) -> some View {
+        content.onChange(of: executionID) { newValue in
+            if newValue != nil {
+                performAction()
+            }
+        }
+        .onChange(of: execution.task) { newTask in
+            if newTask != nil, !options.contains(.enabledDuringExecution) {
+                isDisabled = true
+            } else {
+                isDisabled = false
+            }
+        }
+        .environment(\.isLoading, execution.isLoading)
+    }
+    
+    private func performAction() {
+        execution.start(options: options, action)
+    }
+}
diff --git a/Sources/AsyncButton/AsyncButtonOptions.swift b/Sources/AsyncButton/AsyncButtonOptions.swift
new file mode 100644
index 0000000..17f2f3d
--- /dev/null
+++ b/Sources/AsyncButton/AsyncButtonOptions.swift
@@ -0,0 +1,26 @@
+//
+//  AsyncButtonOptions.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+/// Options to configure the behavior of `AsyncButton`.
+/// Use these options to **disable** or **hide** features.
+/// The default (empty set) enables all features except keeping the button enabled during execution.
+public struct AsyncButtonOptions: OptionSet, Sendable {
+    public let rawValue: Int
+
+    public init(rawValue: Int) {
+        self.rawValue = rawValue
+    }
+
+    /// Hide the loading indicator during the async operation.
+    public static let loadingIndicatorHidden = AsyncButtonOptions(rawValue: 1 << 0)
+    /// Keep the button enabled while the async operation is running (default is disabled).
+    public static let enabledDuringExecution = AsyncButtonOptions(rawValue: 1 << 1)
+    /// Detach the task from the button's lifecycle (won't be cancelled on deinit).
+    public static let detachesTask = AsyncButtonOptions(rawValue: 1 << 2)
+}
diff --git a/Sources/AsyncButton/EnvironmentValues.swift b/Sources/AsyncButton/EnvironmentValues.swift
new file mode 100644
index 0000000..4542633
--- /dev/null
+++ b/Sources/AsyncButton/EnvironmentValues.swift
@@ -0,0 +1,13 @@
+//
+//  EnvironmentValues.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+extension EnvironmentValues {
+    /// A Boolean value indicating whether the button is currently loading.
+    @Entry public var isLoading: Bool = false
+}
diff --git a/Sources/AsyncButton/Previews.swift b/Sources/AsyncButton/Previews.swift
new file mode 100644
index 0000000..a334fb2
--- /dev/null
+++ b/Sources/AsyncButton/Previews.swift
@@ -0,0 +1,84 @@
+//
+//  AsyncButton.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 12.05.2025.
+//
+
+import SwiftUI
+
+private struct PreviewButtonStyle: ButtonStyle {
+    @Environment(\.isEnabled) private var isEnabled
+    @Environment(\.isLoading) private var isLoading
+    
+    func makeBody(configuration: Configuration) -> some View {
+        ZStack {
+            if isLoading {
+                ProgressView()
+                    .progressViewStyle(CircularProgressViewStyle())
+            } else {
+                configuration.label
+            }
+        }
+        .padding()
+        .background(configuration.isPressed ? Color.gray : Color.blue)
+        .opacity(isEnabled ? 1 : 0.5)
+        .foregroundColor(.white)
+        .cornerRadius(8)
+    }
+}
+
+private struct PreviewView: View {
+    var body: some View {
+        NavigationStack {
+            NavigationLink(destination: Text("Destination")) {
+                Text("Go to Destination")
+            }
+            
+            NavigationLink {
+                VStack {
+                    AsyncButton(role: .destructive) {
+                        do {
+                            try await Task.sleep(for: .seconds(3))
+                            print("Destructive action completed")
+                        } catch {
+                            print("Error: \(error)")
+                        }
+                    } label: {
+                        Text("Destructive")
+                    }
+                    
+                    AsyncButton(options: .detachesTask, action: someAction) {
+                        Text("Detached")
+                    }
+                }
+            } label: {
+                Text("Destructive Navigation")
+            }
+            
+            AsyncButton(options: .loadingIndicatorHidden, action: someAction) {
+                Text("No Loading Indicator")
+            }
+            
+            AsyncButton(options: .enabledDuringExecution, action: someAction) {
+                Text("Enabled")
+            }
+        }
+        .frame(maxWidth: .infinity, maxHeight: .infinity)
+        .buttonStyle(PreviewButtonStyle())
+    }
+    
+    private func someAction() async {
+        do {
+            try await Task.sleep(for: .seconds(2))
+            print("Action completed")
+        } catch {
+            print("Error: \(error)")
+        }
+    }
+}
+
+@available(iOS 16.0, macOS 14.0, tvOS 16.0, watchOS 10.0, *)
+#Preview(traits: .fixedLayout(width: 400, height: 400)) {
+    PreviewView()
+}
diff --git a/Sources/CustomCell/CustomCell.swift b/Sources/CustomCell/CustomCell.swift
index fedb7ef..97d7f19 100644
--- a/Sources/CustomCell/CustomCell.swift
+++ b/Sources/CustomCell/CustomCell.swift
@@ -1,6 +1,5 @@
 //
 //  CustomCell.swift
-//  UIComponentsLibrary
 //
 //  Created by Valeriy Malishevskyi on 06.08.2024.
 //
@@ -45,7 +44,23 @@ where Content: View, Image: View, Secondary: View, Accessory: View {
             accessory: .init(body: AnyView(accessory))
         )
         
-        AnyView(style.makeBody(configuration: configuration))
+        AnyView(style.resolve(configuration))
+    }
+}
+
+private struct CustomCellResolver<Style>: View
+where Style: CustomCellStyle {
+    let style: Style
+    let configuration: CustomCellStyleConfiguration
+    
+    var body: some View {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+extension CustomCellStyle {
+    @MainActor func resolve(_ configuration: CustomCellStyleConfiguration) -> some View {
+        CustomCellResolver(style: self, configuration: configuration)
     }
 }
 
@@ -72,6 +87,26 @@ extension CustomCell {
     }
 }
 
+private struct PreviewCellStyle: CustomCellStyle {
+    @Environment(\.lineLimit) private var lineLimit
+    
+    func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.image
+            configuration.label
+            Spacer()
+            configuration.accessory
+            
+            Text("Line limit: \(lineLimit)")
+                .font(.caption)
+                .foregroundColor(.gray)
+                .padding(.leading, 8)
+        }
+        .padding()
+        .background(Color.gray.opacity(0.1))
+    }
+}
+
 #Preview {
     List {
         CustomCell {
@@ -89,6 +124,8 @@ extension CustomCell {
         } secondary: {
             Text("Secondary")
         }
+        .customCellStyle(PreviewCellStyle())
+        .environment(\.lineLimit, 20)
         
         CustomCell {
             Text("Accessory")
@@ -96,4 +133,5 @@ extension CustomCell {
             Image(systemName: "arrow.right")
         }
     }
+    .environment(\.lineLimit, 20)
 }
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift b/Sources/CustomCell/CustomCellStyle+Environment.swift
similarity index 97%
rename from Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift
rename to Sources/CustomCell/CustomCellStyle+Environment.swift
index 3e1445b..cbac80c 100644
--- a/Sources/CustomCell/CustomCellStyle/CustomCellStyle+Environment.swift
+++ b/Sources/CustomCell/CustomCellStyle+Environment.swift
@@ -1,6 +1,5 @@
 //
 //  CustomCellStyle+Environment.swift
-//  UIComponentsLibrary
 //
 //  Created by Valeriy Malishevskyi on 06.08.2024.
 //
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift b/Sources/CustomCell/CustomCellStyle.swift
similarity index 93%
rename from Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift
rename to Sources/CustomCell/CustomCellStyle.swift
index be4a5b2..4b57481 100644
--- a/Sources/CustomCell/CustomCellStyle/CustomCellStyle.swift
+++ b/Sources/CustomCell/CustomCellStyle.swift
@@ -1,6 +1,5 @@
 //
 //  CustomCellStyle.swift
-//  UIComponentsLibrary
 //
 //  Created by Valeriy Malishevskyi on 06.08.2024.
 //
@@ -11,7 +10,7 @@ import SwiftUI
 ///
 /// Conform to `CustomCellStyle` to customize the layout and appearance of cells across your app.
 /// Apply your style with `.customCellStyle(...)` on any view.
-public protocol CustomCellStyle {
+public protocol CustomCellStyle: DynamicProperty {
 
     /// The configuration passed into a custom cell style.
     typealias Configuration = CustomCellStyleConfiguration
diff --git a/Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift b/Sources/CustomCell/CustomCellStyleConfiguration.swift
similarity index 97%
rename from Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift
rename to Sources/CustomCell/CustomCellStyleConfiguration.swift
index f3c18d9..2631955 100644
--- a/Sources/CustomCell/CustomCellStyle/CustomCellStyleConfiguration.swift
+++ b/Sources/CustomCell/CustomCellStyleConfiguration.swift
@@ -1,6 +1,5 @@
 //
 //  CustomCellStyleConfiguration.swift
-//  UIComponentsLibrary
 //
 //  Created by Valeriy Malishevskyi on 06.08.2024.
 //
diff --git a/Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift b/Sources/CustomCell/DefaultCustomCellStyle.swift
similarity index 97%
rename from Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift
rename to Sources/CustomCell/DefaultCustomCellStyle.swift
index e1fdde4..f3010c2 100644
--- a/Sources/CustomCell/CustomCellStyle/DefaultCustomCellStyle.swift
+++ b/Sources/CustomCell/DefaultCustomCellStyle.swift
@@ -1,6 +1,5 @@
 //
 //  DefaultCustomCellStyle.swift
-//  UIComponentsLibrary
 //
 //  Created by Valeriy Malishevskyi on 06.08.2024.
 //
diff --git a/Sources/CustomSection/CustomSection.swift b/Sources/CustomSection/CustomSection.swift
new file mode 100644
index 0000000..3f1787c
--- /dev/null
+++ b/Sources/CustomSection/CustomSection.swift
@@ -0,0 +1,137 @@
+//
+//  Created by Valeriy Malishevskyi on 10.06.2024.
+//
+
+import SwiftUI
+
+public struct CustomSection<Header: View, Footer: View, Content: View>: View {
+    @Environment(\.customSectionStyle) private var style
+    
+    let header: Header
+    let footer: Footer
+    let content: Content
+    
+    public init(
+        @ViewBuilder content: () -> Content,
+        @ViewBuilder header: () -> Header,
+        @ViewBuilder footer: () -> Footer
+    ) {
+        self.header = header()
+        self.footer = footer()
+        self.content = content()
+    }
+    
+    public init(@ViewBuilder content: () -> Content)
+    where Header == EmptyView, Footer == EmptyView {
+        self.init(content: content, header: { EmptyView() }, footer: { EmptyView() })
+    }
+    
+    public init(@ViewBuilder content: () -> Content, header: () -> Header)
+    where Footer == EmptyView {
+        self.init(content: content, header: header, footer: { EmptyView() })
+    }
+    
+    public var body: some View {
+        let configuration = CustomSectionStyleConfiguration(
+            header: CustomSectionStyleConfiguration.Header(header),
+            footer: CustomSectionStyleConfiguration.Footer(footer),
+            content: CustomSectionStyleConfiguration.Content(content)
+        )
+        AnyView(style.resolve(configuration))
+    }
+}
+
+private struct CustomSectionResolver<Style>: View
+where Style: CustomSectionStyle {
+    let style: Style
+    let configuration: CustomSectionStyleConfiguration
+    
+    var body: some View {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+extension CustomSectionStyle {
+    @MainActor func resolve(_ configuration: CustomSectionStyleConfiguration) -> some View {
+        CustomSectionResolver(style: self, configuration: configuration)
+    }
+}
+
+extension CustomSection where Header == Text, Content : View, Footer == EmptyView {
+
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - titleKey: The key for the section's localized title, which describes
+    ///     the contents of the section.
+    ///   - content: The section's content.
+    public init(_ titleKey: LocalizedStringKey, @ViewBuilder content: () -> Content) {
+        self.init(content: content, header: { Text(titleKey) })
+    }
+
+    /// Creates a section with the provided section content.
+    /// - Parameters:
+    ///   - title: A string that describes the contents of the section.
+    ///   - content: The section's content.
+    public init<S>(_ title: S, @ViewBuilder content: () -> Content) where S : StringProtocol {
+        self.init(content: content, header: { Text(title) })
+    }
+}
+
+private struct PreviewSectionStyle: CustomSectionStyle {
+    @Environment(\.lineLimit) private var lineLimit
+    func makeBody(configuration: CustomSectionStyleConfiguration) -> some View {
+        VStack(alignment: .leading) {
+            configuration.header
+                .font(.headline)
+            configuration.content
+            configuration.footer
+                .font(.footnote)
+                .foregroundColor(.gray)
+            
+            Text("Line limit: \(lineLimit)")
+                .font(.subheadline)
+                .foregroundColor(.green)
+        }
+    }
+}
+
+private struct PreviewAlternativeSectionStyle: CustomSectionStyle {
+    func makeBody(configuration: CustomSectionStyleConfiguration) -> some View {
+        VStack(alignment: .leading) {
+            configuration.header
+                .font(.title)
+                .foregroundColor(.blue)
+            configuration.content
+            configuration.footer
+                .font(.caption)
+                .foregroundColor(.red)
+        }
+        .padding(8)
+        .background(Color.gray.opacity(0.2))
+        .cornerRadius(8)
+    }
+}
+
+#Preview {
+    VStack(alignment: .leading) {
+        CustomSection {
+            Text("Section content")
+        } header: {
+            Text("Section header")
+        } footer: {
+            Text("Section footer")
+        }
+        .customSectionStyle(PreviewSectionStyle())
+        .environment(\.lineLimit, 20)
+        
+        CustomSection {
+            Text("Section content")
+        } header: {
+            Text("Section header")
+        } footer: {
+            Text("Section footer")
+        }
+        .customSectionStyle(PreviewAlternativeSectionStyle())
+    }
+    .padding()
+}
diff --git a/Sources/CustomSection/CustomSectionStyle.swift b/Sources/CustomSection/CustomSectionStyle.swift
new file mode 100644
index 0000000..2e0a066
--- /dev/null
+++ b/Sources/CustomSection/CustomSectionStyle.swift
@@ -0,0 +1,48 @@
+//
+//  Created by Valeriy Malishevskyi on 10.06.2024.
+//
+
+import SwiftUI
+
+extension View {
+    public func customSectionStyle<S>(_ style: S) -> some View where S: CustomSectionStyle {
+        environment(\.customSectionStyle, style)
+    }
+}
+
+public protocol CustomSectionStyle: DynamicProperty {
+    typealias Configuration = CustomSectionStyleConfiguration
+
+    associatedtype Body: View
+
+    @MainActor
+    func makeBody(configuration: Self.Configuration) -> Self.Body
+}
+
+public struct CustomSectionStyleConfiguration {
+    
+    public struct Header: View {
+        public let body: AnyView
+        init<V: View>(_ view: V) {
+            self.body = AnyView(view)
+        }
+    }
+    
+    public struct Footer: View {
+        public let body: AnyView
+        init<V: View>(_ view: V) {
+            self.body = AnyView(view)
+        }
+    }
+    
+    public struct Content: View {
+        public let body: AnyView
+        init<V: View>(_ view: V) {
+            self.body = AnyView(view)
+        }
+    }
+    
+    public let header: Header
+    public let footer: Footer
+    public let content: Content
+}
diff --git a/Sources/CustomSection/CustomSectionStyleEnvironmentKey.swift b/Sources/CustomSection/CustomSectionStyleEnvironmentKey.swift
new file mode 100644
index 0000000..9ae8f8c
--- /dev/null
+++ b/Sources/CustomSection/CustomSectionStyleEnvironmentKey.swift
@@ -0,0 +1,16 @@
+//
+//  Created by Valeriy Malishevskyi on 10.06.2024.
+//
+
+import SwiftUI
+
+struct CustomSectionStyleEnvironmentKey: EnvironmentKey {
+    nonisolated(unsafe) static let defaultValue: any CustomSectionStyle = DefaultCustomSectionStyle()
+}
+
+extension EnvironmentValues {
+    var customSectionStyle: any CustomSectionStyle {
+        get { self[CustomSectionStyleEnvironmentKey.self] }
+        set { self[CustomSectionStyleEnvironmentKey.self] = newValue }
+    }
+}
diff --git a/Sources/CustomSection/DefaultCustomSectionStyle.swift b/Sources/CustomSection/DefaultCustomSectionStyle.swift
new file mode 100644
index 0000000..b34b504
--- /dev/null
+++ b/Sources/CustomSection/DefaultCustomSectionStyle.swift
@@ -0,0 +1,17 @@
+//
+//  Created by Valeriy Malishevskyi on 10.06.2024.
+//
+
+import SwiftUI
+
+struct DefaultCustomSectionStyle: CustomSectionStyle {
+    func makeBody(configuration: Configuration) -> some View {
+        Section {
+            configuration.content
+        } header: {
+            configuration.header
+        } footer: {
+            configuration.footer
+        }
+    }
+}
diff --git a/Sources/CustomStepper/CustomStepper+Initializers.swift b/Sources/CustomStepper/CustomStepper+Initializers.swift
new file mode 100644
index 0000000..3ca18c4
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepper+Initializers.swift
@@ -0,0 +1,1040 @@
+//
+//  CustomStepper+Initializers.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 12.05.2025.
+//
+
+import SwiftUI
+
+@available(iOS 13.0, macOS 10.15, watchOS 9.0, *)
+@available(tvOS, unavailable)
+extension CustomStepper {
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a bound value by a specific amount each time the user
+    /// clicks or taps the stepper's increment or decrement buttons.
+    ///
+    /// In the example below, a stepper increments or decrements `value` by the
+    /// `step` value of 5 at each click or tap of the control's increment or
+    /// decrement button:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     step: step) {
+    ///                 Text("Current value: \(value), step: \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements a value by
+    ///   a specified amount each time the user clicks or taps the stepper's
+    ///   increment or decrement buttons.](SwiftUI-Stepper-value-step.png)
+    ///
+    /// - Parameters:
+    ///   - value: The ``Binding`` to a value that you provide.
+    ///   - step: The amount to increment or decrement `value` each time the
+    ///     user clicks or taps the stepper's increment or decrement buttons.
+    ///     Defaults to `1`.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<V>(
+        value: Binding<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V : Strideable {
+        let onIncrement = {
+            value.wrappedValue = value.wrappedValue.advanced(by: step)
+        }
+        
+        let onDecrement = {
+            value.wrappedValue = value.wrappedValue.advanced(by: -step)
+        }
+        
+        self.init(
+            label: label,
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value and within a range of values you provide.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a binding to value by the step size you provide within the given bounds.
+    /// By setting the bounds, you ensure that the value never goes below or
+    /// above the lowest or highest value, respectively.
+    ///
+    /// The example below shows a stepper that displays the effect of
+    /// incrementing or decrementing a value with the step size of `step`
+    /// with the bounds defined by `range`:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     in: range,
+    ///                     step: step) {
+    ///                 Text("Current: \(value) in \(range.description) " +
+    ///                      "stepping by \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper with a step size of five, and a
+    /// prescribed range of 1 though 50.](SwiftUI-Stepper-value-step-range.png)
+    ///
+    /// - Parameters:
+    ///   - value: A ``Binding`` to a value that you provide.
+    ///   - bounds: A closed range that describes the upper and lower bounds
+    ///     permitted by the stepper.
+    ///   - step: The amount to increment or decrement the stepper when the
+    ///     user clicks or taps the stepper's increment or decrement buttons,
+    ///     respectively.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<V>(
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V : Strideable {
+        let onIncrement: () -> Void = {
+            value.wrappedValue = min(value.wrappedValue.advanced(by: step), bounds.upperBound)
+        }
+        let onDecrement: () -> Void = {
+            value.wrappedValue = max(value.wrappedValue.advanced(by: -step), bounds.lowerBound)
+        }
+        self.init(
+            label: label,
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+}
+
+@available(iOS 13.0, macOS 10.15, watchOS 9.0, *)
+@available(tvOS, unavailable)
+extension CustomStepper where Label == Text {
+
+    /// Creates a stepper that uses a title key and executes the closures
+    /// you provide when the user clicks or taps the stepper's increment and
+    /// decrement buttons.
+    ///
+    /// Use this initializer to create a stepper with a custom title that
+    /// executes closures you provide when either of the stepper's increment
+    /// or decrement buttons are pressed. This version of ``Stepper`` doesn't
+    /// take a binding to a value, nor does it allow you to specify a range of
+    /// acceptable values, or a step value -- it simply calls the closures you
+    /// provide when the control's buttons are pressed.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons SwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// SwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper("Value: \(value) Color: \(colors[value].description)",
+    ///                      onIncrement: incrementStep,
+    ///                      onDecrement: decrementStep)
+    ///             .padding(5)
+    ///             .background(colors[value])
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that uses a title key for the stepper's
+    /// localized title and that changes the background color of its view
+    /// when incremented or decremented selecting a color from a predefined
+    /// array using the stepper value as the
+    /// index.](SwiftUI-Stepper-increment-decrement-closures.png)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps the
+    ///       control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps the
+    ///       control's minus button.
+    ///    - onEditingChanged: A closure that's called when editing begins and
+    ///      ends. For example, on iOS, the user may touch and hold the increment
+    ///      or decrement buttons on a `Stepper` which causes the execution
+    ///      of the `onEditingChanged` closure at the start and end of
+    ///      the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init(
+        _ titleKey: LocalizedStringKey,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) {
+        self.init(
+            label: { Text(titleKey) },
+            onIncrement: {onIncrement},
+            onDecrement: {onDecrement},
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper using a title string and that executes closures
+    /// you provide when the user clicks or taps the stepper's increment or
+    /// decrement buttons.
+    ///
+    /// Use `Stepper(_:onIncrement:onDecrement:onEditingChanged:)` to create a
+    /// control with a custom title that executes closures you provide when
+    /// the user clicks or taps on the stepper's increment or decrement buttons.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons SwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// SwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let title: String
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, onIncrement: incrementStep, onDecrement: decrementStep)
+    ///                 .padding(5)
+    ///                 .background(colors[value])
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that uses a string for the stepper's title
+    ///   and that changes the background color of its view when incremented or
+    ///   decremented selecting a color from a predefined array using the
+    ///   stepper's value as the
+    ///   index.](SwiftUI-Stepper-increment-decrement-closures.png)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps the
+    ///       control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps the
+    ///       control's minus button.
+    ///    - onEditingChanged: A closure that's called when editing begins and
+    ///      ends. For example, on iOS, the user may touch and hold the increment
+    ///      or decrement buttons on a `Stepper` which causes the execution
+    ///      of the `onEditingChanged` closure at the start and end of
+    ///      the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<S>(
+        _ title: S,
+        onIncrement: (() -> Void)?,
+        onDecrement: (() -> Void)?,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S : StringProtocol {
+        self.init(
+            label: { Text(title) },
+            onIncrement: {onIncrement},
+            onDecrement: {onDecrement},
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper with a title key and configured to increment and
+    /// decrement a binding to a value and step amount you provide.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time the user clicks or taps on the control's
+    /// increment or decrement buttons, respectively:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///
+    ///         var body: some View {
+    ///             Stepper("Current value: \(value), step: \(step)",
+    ///                     value: $value,
+    ///                     step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 5 each
+    ///   time the user clicks or taps on the control's increment or decrement
+    ///   buttons, respectively.](SwiftUI-Stepper-value-step.png)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's plus or minus button,
+    ///       respectively.  Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<V>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V : Strideable {
+        let onIncrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: step)
+        }
+        let onDecrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: -step)
+        }
+        self.init(
+            label: { Text(titleKey) },
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper with a title and configured to increment and
+    /// decrement a binding to a value and step amount you provide.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time one of the user clicks or taps the control's
+    /// increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         let title: String
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, value: $value, step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 1 each
+    ///   time the control's buttons
+    ///   are pressed.](SwiftUI-Stepper-value-step.png)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: The ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<S, V>(
+        _ title: S,
+        value: Binding<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S : StringProtocol, V : Strideable {
+        let onIncrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: step)
+        }
+        let onDecrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: -step)
+        }
+        self.init(
+            label: { Text(title) },
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide.
+    ///
+    /// Use `Stepper(_:value:in:step:onEditingChanged:)` to create a stepper
+    /// that increments or decrements a value within a specific range of values
+    /// by a specific step size. In the example below, a stepper increments or
+    /// decrements a binding to value over a range of `1...50` by `5` at each
+    /// press of the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         @State private var titleKey = "Stepper"
+    ///
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             VStack(spacing: 20) {
+    ///                 Text("Current Stepper Value: \(value)")
+    ///                 Stepper(titleKey, value: $value, in: range, step: step)
+    ///             }
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements within a
+    ///   specified range and step size.](SwiftUI-Stepper-value-step-range.png)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<V>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where V : Strideable {
+        let onIncrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: step)
+        }
+        let onDecrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: -step)
+        }
+        self.init(
+            label: { Text(titleKey) },
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide.
+    ///
+    /// Use `Stepper(_:value:in:step:onEditingChanged:)` to create a stepper
+    /// that increments or decrements a value within a specific range of values
+    /// by a specific step size. In the example below, a stepper increments or
+    /// decrements a binding to value over a range of `1...50` by `5` each time
+    /// the user clicks or taps the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper("Current: \(value) in \(range.description) stepping by \(step)",
+    ///                     value: $value,
+    ///                     in: range,
+    ///                     step: step)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements within a
+    ///   specified range and step size.](SwiftUI-Stepper-value-step-range.png)
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    @available(watchOS 9.0, *)
+    @available(tvOS, unavailable)
+    public init<S, V>(
+        _ title: S,
+        value: Binding<V>,
+        in bounds: ClosedRange<V>,
+        step: V.Stride = 1,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S : StringProtocol, V : Strideable {
+        let onIncrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: step)
+        }
+        let onDecrement: () -> Void = {
+            value.wrappedValue = value.wrappedValue.advanced(by: -step)
+        }
+        self.init(
+            label: { Text(title) },
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+}
+
+@available(iOS 16.0, macOS 13.0, watchOS 9.0, *)
+@available(tvOS, unavailable)
+extension CustomStepper {
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value you provide, displaying its value with an
+    /// applied format style.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a bound value by a specific amount each time the user clicks or taps
+    /// the stepper's increment or decrement buttons, while displaying the
+    /// current value.
+    ///
+    /// In the example below, a stepper increments or decrements `value` by the
+    /// `step` value of 5 at each click or tap of the control's increment or
+    /// decrement button:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///         let step = 5
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     step: step,
+    ///                     format: .number) {
+    ///                 Text("Current value: \(value), step: \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements a value by
+    ///   a specified amount each time the user clicks or taps the stepper's
+    ///   increment or decrement buttons.](SwiftUI-Stepper-value-step.png)
+    ///
+    /// - Parameters:
+    ///   - value: The ``Binding`` to a value that you provide.
+    ///   - step: The amount to increment or decrement `value` each time the
+    ///     user clicks or taps the stepper's increment or decrement buttons.
+    ///     Defaults to `1`.
+    ///   - format: A format style of type `F` to use when converting between
+    ///     the string the user edits and the underlying value of type
+    ///     `F.FormatInput`. If `format` can't perform the conversion, the
+    ///     stepper leaves `value` unchanged. If the user stops editing the
+    ///     text in an invalid state, the stepper updates the text to the last
+    ///     known valid value.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    public init<F>(
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F: ParseableFormatStyle, F.FormatInput: BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        self.init(
+            label: label,
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper configured to increment or decrement a binding to a
+    /// value using a step value and within a range of values you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use this initializer to create a stepper that increments or decrements
+    /// a binding to value by the step size you provide within the given bounds.
+    /// By setting the bounds, you ensure that the value never goes below or
+    /// above the lowest or highest value, respectively.
+    ///
+    /// The example below shows a stepper that displays the effect of
+    /// incrementing or decrementing a value with the step size of `step`
+    /// with the bounds defined by `range`:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper(value: $value,
+    ///                     in: range,
+    ///                     step: step,
+    ///                     format: .number) {
+    ///                 Text("Current: \(value) in \(range.description) " +
+    ///                      "stepping by \(step)")
+    ///             }
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper with a step size of five, and a
+    /// prescribed range of 1 though 50.](SwiftUI-Stepper-value-step-range.png)
+    ///
+    /// - Parameters:
+    ///   - value: A ``Binding`` to a value that you provide.
+    ///   - bounds: A closed range that describes the upper and lower bounds
+    ///     permitted by the stepper.
+    ///   - step: The amount to increment or decrement the stepper when the
+    ///     user clicks or taps the stepper's increment or decrement buttons,
+    ///     respectively.
+    ///   - format: A format style of type `F` to use when converting between
+    ///     the string the user edits and the underlying value of type
+    ///     `F.FormatInput`. If `format` can't perform the conversion, the
+    ///     stepper leaves `value` unchanged. If the user stops editing the
+    ///     text in an invalid state, the stepper updates the text to the last
+    ///     known valid value.
+    ///   - label: A view describing the purpose of this stepper.
+    ///   - onEditingChanged: A closure that's called when editing begins and
+    ///     ends. For example, on iOS, the user may touch and hold the increment
+    ///     or decrement buttons on a stepper which causes the execution
+    ///     of the `onEditingChanged` closure at the start and end of
+    ///     the gesture.
+    public init<F>(
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        @ViewBuilder label: () -> Label,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F : ParseableFormatStyle, F.FormatInput : BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = max(min(formattedValue, bounds.upperBound), bounds.lowerBound)
+            }
+        }
+        
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = max(min(formattedValue, bounds.upperBound), bounds.lowerBound)
+            }
+        }
+        
+        self.init(
+            label: label,
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+}
+
+extension CustomStepper where Label == Text {
+
+    /// Creates a stepper with a title key and configured to increment and
+    /// decrement a binding to a value and step amount you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:step:onEditingChanged:)` to create a stepper with a
+    /// custom title that increments or decrements a binding to value by the
+    /// step size you specify, while displaying the current value.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time the user clicks or taps on the control's
+    /// increment or decrement buttons, respectively:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 1
+    ///
+    ///         var body: some View {
+    ///             Stepper("Stepping by \(step)",
+    ///                 value: $value,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// ![A view displaying a stepper that increments or decrements by 5 each
+    ///   time the user clicks or taps on the control's increment or decrement
+    ///   buttons, respectively.](SwiftUI-Stepper-value-step.png)
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's plus or minus button,
+    ///       respectively.  Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    public init<F>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F : ParseableFormatStyle, F.FormatInput : BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        self.init(
+            label: { Text(titleKey) },
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper with a title and configured to increment and
+    /// decrement a binding to a value and step amount you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:step:format:onEditingChanged:)` to create a stepper
+    /// with a custom title that increments or decrements a binding to value by
+    /// the step size you specify, while displaying the current value.
+    ///
+    /// In the example below, the stepper increments or decrements the binding
+    /// value by `5` each time one of the user clicks or taps the control's
+    /// increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         let title: String
+    ///         @State private var value = 1
+    ///
+    ///         var body: some View {
+    ///             Stepper(title, value: $value, step: 5, format: .number)
+    ///                 .padding(10)
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: The ``Binding`` to a value that you provide.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the
+    ///       increment or decrement buttons on a `Stepper` which causes the
+    ///       execution of the `onEditingChanged` closure at the start and end
+    ///       of the gesture.
+    public init<S, F>(
+        _ title: S,
+        value: Binding<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S : StringProtocol, F : ParseableFormatStyle, F.FormatInput : BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        self.init(
+            label: { Text(title) },
+            onIncrement: { onIncrement },
+            onDecrement: { onDecrement },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:in:step:format:onEditingChanged:)` to create a
+    /// stepper that increments or decrements a value within a specific range
+    /// of values by a specific step size, while displaying the current value.
+    /// In the example below, a stepper increments or decrements a binding to
+    /// value over a range of `1...50` by `5` each time the user clicks or taps
+    /// the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///
+    ///         var body: some View {
+    ///             Stepper("Stepping by \(step) in \(range.description)",
+    ///                 value: $value,
+    ///                 in: 1...50,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding()
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - titleKey: The key for the stepper's localized title describing
+    ///       the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    public init<F>(
+        _ titleKey: LocalizedStringKey,
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where F : ParseableFormatStyle, F.FormatInput : BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        self.init(
+            label: { Text(titleKey) },
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+
+    /// Creates a stepper instance that increments and decrements a binding to
+    /// a value, by a step size and within a closed range that you provide,
+    /// displaying its value with an applied format style.
+    ///
+    /// Use `Stepper(_:value:in:step:format:onEditingChanged:)` to create a
+    /// stepper that increments or decrements a value within a specific range
+    /// of values by a specific step size, while displaying the current value.
+    /// In the example below, a stepper increments or decrements a binding to
+    /// value over a range of `1...50` by `5` each time the user clicks or taps
+    /// the stepper's increment or decrement buttons:
+    ///
+    ///     struct StepperView: View {
+    ///         let title: String
+    ///         @State private var value = 0
+    ///
+    ///         let step = 5
+    ///         let range = 1...50
+    ///
+    ///         var body: some View {
+    ///             Stepper(title,
+    ///                 value: $value,
+    ///                 in: 1...50,
+    ///                 step: 5,
+    ///                 format: .number
+    ///             )
+    ///             .padding()
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///     - title: A string describing the purpose of the stepper.
+    ///     - value: A ``Binding`` to a value that your provide.
+    ///     - bounds: A closed range that describes the upper and lower bounds
+    ///       permitted by the stepper.
+    ///     - step: The amount to increment or decrement `value` each time the
+    ///       user clicks or taps the stepper's increment or decrement button,
+    ///       respectively. Defaults to `1`.
+    ///     - format: A format style of type `F` to use when converting between
+    ///       the string the user edits and the underlying value of type
+    ///       `F.FormatInput`. If `format` can't perform the conversion, the
+    ///       stepper leaves `value` unchanged. If the user stops editing the
+    ///       text in an invalid state, the stepper updates the text to the last
+    ///       known valid value.
+    ///     - onEditingChanged: A closure that's called when editing begins and
+    ///       ends. For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    public init<S, F>(
+        _ title: S,
+        value: Binding<F.FormatInput>,
+        in bounds: ClosedRange<F.FormatInput>,
+        step: F.FormatInput.Stride = 1,
+        format: F,
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) where S : StringProtocol, F : ParseableFormatStyle, F.FormatInput : BinaryFloatingPoint, F.FormatOutput == String {
+        let onIncrement: () -> Void = {
+            // Increment the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        let onDecrement: () -> Void = {
+            // Decrement the value, then use format to apply it back
+            let newValue = value.wrappedValue.advanced(by: -step)
+            if let formattedValue = try? format.parseStrategy.parse(format.format(newValue)) {
+                value.wrappedValue = formattedValue
+            }
+        }
+        
+        self.init(
+            label: { Text(title) },
+            onIncrement: {
+                bounds.contains(value.wrappedValue.advanced(by: step)) ? onIncrement : nil
+            },
+            onDecrement: {
+                bounds.contains(value.wrappedValue.advanced(by: -step)) ? onDecrement : nil
+            },
+            onEditingChanged: onEditingChanged
+        )
+    }
+}
diff --git a/Sources/CustomStepper/CustomStepper.swift b/Sources/CustomStepper/CustomStepper.swift
new file mode 100644
index 0000000..d34e5ed
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepper.swift
@@ -0,0 +1,281 @@
+//
+//  CustomStepper.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+/// A control that performs increment and decrement actions.
+///
+/// Use a stepper control when you want the user to have granular control while
+/// incrementing or decrementing a value. For example, you can use a stepper
+/// to:
+///
+///  * Change a value up or down by `1`.
+///  * Operate strictly over a prescribed range.
+///  * Step by specific amounts over a stepper's range of possible values.
+///
+/// The example below uses an array that holds a number of ``Color`` values,
+/// a local state variable, `value`, to set the control's background
+/// color, and title label. When the user clicks or taps the stepper's
+/// increment or decrement buttons, SwiftUI executes the relevant
+/// closure that updates `value`, wrapping the `value` to prevent overflow.
+/// SwiftUI then re-renders the view, updating the text and background
+/// color to match the current index:
+///
+///     struct StepperView: View {
+///         @State private var value = 0
+///         let colors: [Color] = [.orange, .red, .gray, .blue,
+///                                .green, .purple, .pink]
+///
+///         func incrementStep() {
+///             value += 1
+///             if value >= colors.count { value = 0 }
+///         }
+///
+///         func decrementStep() {
+///             value -= 1
+///             if value < 0 { value = colors.count - 1 }
+///         }
+///
+///         var body: some View {
+///             Stepper {
+///                 Text("Value: \(value) Color: \(colors[value].description)")
+///             } onIncrement: {
+///                 incrementStep()
+///             } onDecrement: {
+///                 decrementStep()
+///             }
+///             .padding(5)
+///             .background(colors[value])
+///         }
+///     }
+///
+/// ![A view displaying a stepper that uses a text view for stepper's title and that changes the background color of its view when incremented or decremented. The view selects the new background color from a predefined array of colors using the stepper's value as the index.](SwiftUI-Stepper-increment-decrement-closures.png)
+///
+/// The following example shows a stepper that displays the effect of
+/// incrementing or decrementing a value with the step size of `step` with
+/// the bounds defined by `range`:
+///
+///     struct StepperView: View {
+///         @State private var value = 0
+///         let step = 5
+///         let range = 1...50
+///
+///         var body: some View {
+///             Stepper(
+///                 value: $value,
+///                 in: range,
+///                 step: step
+///             ) {
+///                 Text("Current: \(value) in \(range.description) " +
+///                      "stepping by \(step)")
+///             }
+///             .padding(10)
+///         }
+///     }
+///
+/// ![A view displaying a stepper with a step size of five, and a prescribed range of 1 though 50.](SwiftUI-Stepper-value-step-range.png)
+@available(iOS 13.0, macOS 10.15, watchOS 9.0, *)
+@available(tvOS, unavailable)
+@MainActor public struct CustomStepper<Label> : View
+where Label : View {
+    
+    @Environment(\.isEnabled) private var isEnabled
+    @Environment(\.customStepperStyle) private var style
+    @Environment(\.customStepperElementStyle) private var elementStyle
+    
+    private let label: Label
+    private let onIncrement: () -> ((() -> Void)?)
+    private let onDecrement: () -> ((() -> Void)?)
+    private let onEditingChanged: (Bool) -> Void
+
+    /// Creates a stepper instance that performs the closures you provide when
+    /// the user increments or decrements the stepper.
+    ///
+    /// Use this initializer to create a control with a custom title that
+    /// executes closures you provide when the user clicks or taps the
+    /// stepper's increment or decrement buttons.
+    ///
+    /// The example below uses an array that holds a number of ``Color`` values,
+    /// a local state variable, `value`, to set the control's background
+    /// color, and title label. When the user clicks or taps on the stepper's
+    /// increment or decrement buttons SwiftUI executes the relevant
+    /// closure that updates `value`, wrapping the `value` to prevent overflow.
+    /// SwiftUI then re-renders the view, updating the text and background
+    /// color to match the current index:
+    ///
+    ///     struct StepperView: View {
+    ///         @State private var value = 0
+    ///         let colors: [Color] = [.orange, .red, .gray, .blue, .green,
+    ///                                .purple, .pink]
+    ///
+    ///         func incrementStep() {
+    ///             value += 1
+    ///             if value >= colors.count { value = 0 }
+    ///         }
+    ///
+    ///         func decrementStep() {
+    ///             value -= 1
+    ///             if value < 0 { value = colors.count - 1 }
+    ///         }
+    ///
+    ///         var body: some View {
+    ///             Stepper {
+    ///                 Text("Value: \(value) Color: \(colors[value].description)")
+    ///             } onIncrement: {
+    ///                 incrementStep()
+    ///             } onDecrement: {
+    ///                 decrementStep()
+    ///             }
+    ///             .padding(5)
+    ///             .background(colors[value])
+    ///         }
+    ///    }
+    ///
+    /// ![A view displaying a stepper that uses a text view for stepper's title
+    ///   and that changes the background color of its view when incremented or
+    ///   decremented. The view selects the new background color from a
+    ///    predefined array of colors using the stepper's value as the
+    ///   index.](SwiftUI-Stepper-increment-decrement-closures.png)
+    ///
+    /// - Parameters:
+    ///     - label: A view describing the purpose of this stepper.
+    ///     - onIncrement: The closure to execute when the user clicks or taps
+    ///       the control's plus button.
+    ///     - onDecrement: The closure to execute when the user clicks or taps
+    ///       the control's minus button.
+    ///     - onEditingChanged: A closure called when editing begins and ends.
+    ///       For example, on iOS, the user may touch and hold the increment
+    ///       or decrement buttons on a `Stepper` which causes the execution
+    ///       of the `onEditingChanged` closure at the start and end of
+    ///       the gesture.
+    public init(
+        @ViewBuilder label: () -> Label,
+        onIncrement: @escaping () -> ((() -> Void)?),
+        onDecrement: @escaping () -> ((() -> Void)?),
+        onEditingChanged: @escaping (Bool) -> Void = { _ in }
+    ) {
+        self.label = label()
+        self.onIncrement = onIncrement
+        self.onDecrement = onDecrement
+        self.onEditingChanged = onEditingChanged
+    }
+
+    /// The content and behavior of the view.
+    ///
+    /// When you implement a custom view, you must implement a computed
+    /// `body` property to provide the content for your view. Return a view
+    /// that's composed of built-in views that SwiftUI provides, plus other
+    /// composite views that you've already defined:
+    ///
+    ///     struct MyView: View {
+    ///         var body: some View {
+    ///             Text("Hello, World!")
+    ///         }
+    ///     }
+    ///
+    /// For more information about composing views and a view hierarchy,
+    /// see <doc:Declaring-a-Custom-View>.
+    @MainActor public var body: some View {
+        
+        let elementConfiguration = CustomStepperElementConfiguration(
+            onIncrement: onIncrement() ?? {},
+            onDecrement: onDecrement() ?? {}
+        )
+        
+        let decrement = (elementStyle ?? style).makeDecrement(configuration: elementConfiguration)
+            .disabled(onDecrement() == nil)
+        
+        let increment = (elementStyle ?? style).makeIncrement(configuration: elementConfiguration)
+            .disabled(onIncrement() == nil)
+        
+        let configuration = CustomStepperConfiguration(
+            label: .init(body: .init(label)),
+            onIncrement: onIncrement() ?? {},
+            onDecrement: onDecrement() ?? {},
+            decrement: .init(body: .init(decrement)),
+            increment: .init(body: .init(increment))
+        )
+        
+        let view = style.resolve(configuration)
+        AnyView(view)
+    }
+}
+
+private struct CustomStepperResolver<Style>: View
+where Style: CustomStepperStyle {
+    let style: Style
+    let configuration: CustomStepperConfiguration
+    
+    var body: some View {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+extension CustomStepperStyle {
+    @MainActor func resolve(_ configuration: CustomStepperConfiguration) -> some View {
+        CustomStepperResolver(style: self, configuration: configuration)
+    }
+}
+
+private struct PreviewStepperStyle: CustomStepperStyle {
+    @Environment(\.lineLimit) private var lineLimit
+    func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.decrement
+            VStack {
+                configuration.label
+                Text("Line limit: \(lineLimit)")
+                    .font(.caption)
+                    .foregroundStyle(.secondary)
+            }
+            configuration.increment
+        }
+        .padding()
+        .background(Color.gray)
+    }
+    
+    func makeIncrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onIncrement) {
+            Image(systemName: "plus")
+                .imageScale(.large)
+                .foregroundStyle(.purple)
+                .bold()
+        }
+    }
+    
+    func makeDecrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onDecrement) {
+            Image(systemName: "minus")
+        }
+        .clipShape(.circle)
+    }
+}
+
+private struct PreviewView: View {
+    @State private var value = 0
+
+    private let step = 1
+    
+    var body: some View {
+        VStack {
+            CustomStepper("Value is \(value)", value: $value, step: step) { isChanged in
+                print("Is changed: \(isChanged)")
+            }
+            .customStepperStyle(PreviewStepperStyle())
+            
+            CustomStepper(value: $value, in: 0...10, step: step) {
+                Text("Value is \(value)")
+            } onEditingChanged: {
+                print("Is editing: \($0)")
+            }
+        }
+        .environment(\.lineLimit, 20)
+    }
+}
+
+#Preview {
+    PreviewView()
+}
diff --git a/Sources/CustomStepper/CustomStepperElementConfiguration.swift b/Sources/CustomStepper/CustomStepperElementConfiguration.swift
new file mode 100644
index 0000000..df100d9
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepperElementConfiguration.swift
@@ -0,0 +1,17 @@
+//
+//  CustomStepperElementConfiguration.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+/// A configuration object passed to custom increment and decrement element styles.
+///
+/// Provides closures for handling user-initiated increment and decrement actions.
+public struct CustomStepperElementConfiguration {
+
+    /// A closure that should be called to perform an increment action.
+    public let onIncrement: () -> Void
+
+    /// A closure that should be called to perform a decrement action.
+    public let onDecrement: () -> Void
+}
diff --git a/Sources/CustomStepper/CustomStepperElementStyle.swift b/Sources/CustomStepper/CustomStepperElementStyle.swift
new file mode 100644
index 0000000..b7b2312
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepperElementStyle.swift
@@ -0,0 +1,38 @@
+//
+//  CustomStepperElementStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+/// A protocol that defines both increment and decrement styles for a custom stepper.
+///
+/// Conform to this protocol to provide buttons or views for both ends of the stepper UI.
+public protocol CustomStepperElementStyle: CustomStepperDecrementStyle, CustomStepperIncrementStyle { }
+
+/// A protocol that defines the style for a stepper's decrement button or view.
+public protocol CustomStepperDecrementStyle {
+
+    /// The view type to render the decrement element.
+    associatedtype DecrementBody: View
+
+    /// Creates the decrement view using the given configuration.
+    ///
+    /// - Parameter configuration: The increment/decrement action handler.
+    /// - Returns: A view that performs a decrement action.
+    @MainActor func makeDecrement(configuration: CustomStepperElementConfiguration) -> DecrementBody
+}
+
+/// A protocol that defines the style for a stepper's increment button or view.
+public protocol CustomStepperIncrementStyle {
+
+    /// The view type to render the increment element.
+    associatedtype IncrementBody: View
+
+    /// Creates the increment view using the given configuration.
+    ///
+    /// - Parameter configuration: The increment/decrement action handler.
+    /// - Returns: A view that performs an increment action.
+    @MainActor func makeIncrement(configuration: CustomStepperElementConfiguration) -> IncrementBody
+}
diff --git a/Sources/CustomStepper/CustomStepperStyle.swift b/Sources/CustomStepper/CustomStepperStyle.swift
new file mode 100644
index 0000000..fce90b0
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepperStyle.swift
@@ -0,0 +1,26 @@
+//
+//  CustomStepperStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+/// A protocol that defines the complete visual layout and behavior of a custom stepper.
+///
+/// `CustomStepperStyle` combines increment/decrement element styles with a custom layout implementation.
+/// It receives a `CustomStepperConfiguration` that includes the label, controls, and action handlers.
+public protocol CustomStepperStyle: CustomStepperDecrementStyle, CustomStepperElementStyle, DynamicProperty {
+
+    /// A typealias for the configuration object passed into the style.
+    typealias Configuration = CustomStepperConfiguration
+
+    /// The view returned by the custom stepper's body.
+    associatedtype Body: View
+
+    /// Creates the full custom stepper view using the given configuration.
+    ///
+    /// - Parameter configuration: A structure containing the stepper's label, controls, and handlers.
+    /// - Returns: A complete stepper view.
+    @MainActor func makeBody(configuration: Configuration) -> Self.Body
+}
diff --git a/Sources/CustomStepper/CustomStepperStyleConfiguration.swift b/Sources/CustomStepper/CustomStepperStyleConfiguration.swift
new file mode 100644
index 0000000..c61f50a
--- /dev/null
+++ b/Sources/CustomStepper/CustomStepperStyleConfiguration.swift
@@ -0,0 +1,43 @@
+//
+//  CustomStepperStyleConfiguration.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+/// A configuration object provided to custom stepper styles.
+///
+/// Contains all views and action closures required to render and operate a custom stepper.
+public struct CustomStepperConfiguration {
+
+    /// A type-erased view for the stepper's label.
+    public struct Label: View {
+        public let body: AnyView
+    }
+
+    /// A view representing the stepper's decrement control.
+    public struct Decrement: View {
+        public let body: AnyView
+    }
+
+    /// A view representing the stepper's increment control.
+    public struct Increment: View {
+        public let body: AnyView
+    }
+
+    /// The view shown as the stepper's label.
+    public let label: Label
+
+    /// Called when the stepper is incremented.
+    public let onIncrement: () -> Void
+
+    /// Called when the stepper is decremented.
+    public let onDecrement: () -> Void
+
+    /// The decrement control view.
+    public let decrement: Decrement
+
+    /// The increment control view.
+    public let increment: Increment
+}
diff --git a/Sources/CustomStepper/DefaultCustomStepperElementStyle.swift b/Sources/CustomStepper/DefaultCustomStepperElementStyle.swift
new file mode 100644
index 0000000..084e12d
--- /dev/null
+++ b/Sources/CustomStepper/DefaultCustomStepperElementStyle.swift
@@ -0,0 +1,21 @@
+//
+//  DefaultCustomStepperElementStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+public struct DefaultCustomStepperElementStyle: CustomStepperElementStyle {
+    public func makeDecrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onDecrement) {
+            Image(systemName: "minus")
+        }
+    }
+
+    public func makeIncrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onIncrement) {
+            Image(systemName: "plus")
+        }
+    }
+}
diff --git a/Sources/CustomStepper/DefaultCustomStepperStyle.swift b/Sources/CustomStepper/DefaultCustomStepperStyle.swift
new file mode 100644
index 0000000..afef1fb
--- /dev/null
+++ b/Sources/CustomStepper/DefaultCustomStepperStyle.swift
@@ -0,0 +1,29 @@
+//
+//  DefaultCustomStepperStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+public struct DefaultCustomStepperStyle: CustomStepperStyle {
+    public func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.label.body
+            configuration.decrement
+            configuration.increment
+        }
+    }
+    
+    public func makeDecrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onDecrement) {
+            Image(systemName: "minus")
+        }
+    }
+    
+    public func makeIncrement(configuration: CustomStepperElementConfiguration) -> some View {
+        Button(action: configuration.onIncrement) {
+            Image(systemName: "plus")
+        }
+    }
+}
diff --git a/Sources/CustomStepper/View+CustomStepperElementStyle.swift b/Sources/CustomStepper/View+CustomStepperElementStyle.swift
new file mode 100644
index 0000000..af6954a
--- /dev/null
+++ b/Sources/CustomStepper/View+CustomStepperElementStyle.swift
@@ -0,0 +1,29 @@
+//
+//  View+CustomStepperElementStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+extension View {
+
+    /// Sets a custom style for the increment and decrement controls in a `CustomStepper`.
+    ///
+    /// - Parameter style: A type conforming to `CustomStepperElementStyle`.
+    /// - Returns: A view that uses the provided style within its subtree.
+    public func customStepperElementStyle(_ style: some CustomStepperElementStyle) -> some View {
+        environment(\.customStepperElementStyle, style)
+    }
+}
+
+extension EnvironmentValues {
+    var customStepperElementStyle: (any CustomStepperElementStyle)? {
+        get { self[CustomStepperElementConfigurationKey.self] }
+        set { self[CustomStepperElementConfigurationKey.self] = newValue }
+    }
+}
+
+private struct CustomStepperElementConfigurationKey: EnvironmentKey {
+    nonisolated(unsafe) static let defaultValue: (any CustomStepperElementStyle)? = nil
+}
diff --git a/Sources/CustomStepper/View+CustomStepperStyle.swift b/Sources/CustomStepper/View+CustomStepperStyle.swift
new file mode 100644
index 0000000..3dbced6
--- /dev/null
+++ b/Sources/CustomStepper/View+CustomStepperStyle.swift
@@ -0,0 +1,31 @@
+//
+//  View+CustomStepperStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 15.09.2024.
+//
+
+import SwiftUI
+
+extension View {
+
+    /// Sets a custom full layout style for a `CustomStepper`.
+    ///
+    /// Use this to override the appearance of the stepper’s structure and behavior.
+    ///
+    /// - Parameter style: A style conforming to `CustomStepperStyle`.
+    /// - Returns: A view that uses the provided stepper style in the environment.
+    public func customStepperStyle<S>(_ style: S) -> some View where S: CustomStepperStyle {
+        self.environment(\.customStepperStyle, style)
+    }
+}
+
+extension EnvironmentValues {
+    var customStepperStyle: any CustomStepperStyle {
+        get { self[CustomStepperStyleKey.self] }
+        set { self[CustomStepperStyleKey.self] = newValue }
+    }
+}
+
+private struct CustomStepperStyleKey: EnvironmentKey {
+    nonisolated(unsafe) static let defaultValue: any CustomStepperStyle = DefaultCustomStepperStyle()
+}
diff --git a/Sources/CustomTextField/CustomTextField+Init.swift b/Sources/CustomTextField/CustomTextField+Init.swift
new file mode 100644
index 0000000..3177b6f
--- /dev/null
+++ b/Sources/CustomTextField/CustomTextField+Init.swift
@@ -0,0 +1,339 @@
+//
+//  CustomTextField+Init.swift
+//
+//  Created by Valeriy Malishevskyi on 02.09.2024.
+//
+
+import SwiftUI
+
+extension CustomTextField where Label == Text, F == EmptyParseableFormatStyle {
+
+    /// Creates a text field with a preferred axis and a text label generated
+    /// from a localized title string.
+    ///
+    /// Specify a preferred axis in which the text field should scroll
+    /// its content when it does not fit in the available space. Depending
+    /// on the style of the field, this axis may not be respected.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - titleKey: The key for the localized title of the text field,
+    ///     describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - axis: The axis in which to scroll text when it doesn't fit
+    ///     in the available space.
+    @available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, axis: Axis) {
+        self.init(label: Text(titleKey), text: text, prompt: nil, axis: axis)
+    }
+
+    /// Creates a text field with a preferred axis and a text label generated
+    /// from a localized title string.
+    ///
+    /// Specify a preferred axis in which the text field should scroll
+    /// its content when it does not fit in the available space. Depending
+    /// on the style of the field, this axis may not be respected.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - titleKey: The key for the localized title of the text field,
+    ///     describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    ///   - axis: The axis in which to scroll text when it doesn't fit
+    ///     in the available space.
+    @available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, prompt: Text?, axis: Axis) {
+        self.init(label: Text(titleKey), text: text, prompt: prompt, axis: axis)
+    }
+
+    /// Creates a text field with a preferred axis and a text label generated
+    /// from a title string.
+    ///
+    /// Specify a preferred axis in which the text field should scroll
+    /// its content when it does not fit in the available space. Depending
+    /// on the style of the field, this axis may not be respected.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - title: The title of the text view, describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - axis: The axis in which to scroll text when it doesn't fit
+    ///     in the available space.
+    @available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+    public init<S>(_ title: S, text: Binding<String>, axis: Axis) where S : StringProtocol {
+        self.init(label: Text(title), text: text, prompt: nil, axis: axis)
+    }
+
+    /// Creates a text field with a text label generated from a title string.
+    ///
+    /// Specify a preferred axis in which the text field should scroll
+    /// its content when it does not fit in the available space. Depending
+    /// on the style of the field, this axis may not be respected.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - title: The title of the text view, describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    ///   - axis: The axis in which to scroll text when it doesn't fit
+    ///     in the available space.
+    @available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+    public init<S>(_ title: S, text: Binding<String>, prompt: Text?, axis: Axis) where S : StringProtocol {
+        self.init(label: Text(title), text: text, prompt: prompt, axis: axis)
+    }
+}
+
+extension CustomTextField where F == EmptyParseableFormatStyle {
+
+    /// Creates a text field with a preferred axis and a prompt generated from
+    /// a `Text`.
+    ///
+    /// Specify a preferred axis in which the text field should scroll
+    /// its content when it does not fit in the available space. Depending
+    /// on the style of the field, this axis may not be respected.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    ///   - axis: The axis in which to scroll text when it doesn't fit
+    ///     in the available space.
+    ///   - label: A view that describes the purpose of the text field.
+    @available(iOS 16.0, macOS 13.0, tvOS 16.0, watchOS 9.0, *)
+    public init(text: Binding<String>, prompt: Text? = nil, axis: Axis, @ViewBuilder label: () -> Label) {
+        self.init(label: label(), text: text, prompt: prompt, axis: axis)
+    }
+}
+
+extension CustomTextField where Label == Text, F == EmptyParseableFormatStyle {
+
+    /// Creates a text field with a text label generated from a localized title
+    /// string.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - titleKey: The key for the localized title of the text field,
+    ///     describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>, prompt: Text?) {
+        self.init(label: Text(titleKey), text: text, prompt: prompt)
+    }
+
+    /// Creates a text field with a text label generated from a title string.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - title: The title of the text view, describing its purpose.
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+    public init<S>(_ title: S, text: Binding<String>, prompt: Text?) where S : StringProtocol {
+        self.init(label: Text(title), text: text, prompt: prompt)
+    }
+}
+
+extension CustomTextField where F == EmptyParseableFormatStyle {
+
+    /// Creates a text field with a prompt generated from a `Text`.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// - Parameters:
+    ///   - text: The text to display and edit.
+    ///   - prompt: A `Text` representing the prompt of the text field
+    ///     which provides users with guidance on what to type into the text
+    ///     field.
+    ///   - label: A view that describes the purpose of the text field.
+    @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+    public init(text: Binding<String>, prompt: Text? = nil, @ViewBuilder label: () -> Label) {
+        self.init(label: label(), text: text, prompt: prompt)
+    }
+}
+
+extension CustomTextField where Label == Text, F == EmptyParseableFormatStyle {
+
+    /// Creates a text field with a text label generated from a localized title
+    /// string.
+    ///
+    /// - Parameters:
+    ///   - titleKey: The key for the localized title of the text field,
+    ///     describing its purpose.
+    ///   - text: The text to display and edit.
+    @available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+    public init(_ titleKey: LocalizedStringKey, text: Binding<String>) {
+        self.init(label: Text(titleKey), text: text, prompt: nil)
+    }
+
+    /// Creates a text field with a text label generated from a title string.
+    ///
+    /// - Parameters:
+    ///   - title: The title of the text view, describing its purpose.
+    ///   - text: The text to display and edit.
+    @available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+    public init<S>(_ title: S, text: Binding<String>) where S : StringProtocol {
+        self.init(label: Text(title), text: text, prompt: nil)
+    }
+}
+
+extension CustomTextField where Label == Text, F == EmptyParseableFormatStyle {
+    
+    /// Create an instance which binds over an arbitrary type, `V`.
+    ///
+    /// Use this initializer to create a text field that binds to a bound optional
+    /// value, using a
+    /// <doc://com.apple.documentation/documentation/Foundation/Formatter>
+    /// to convert to and from this type. Changes to the bound value update
+    /// the string displayed by the text field. Editing the text field
+    /// updates the bound value, as long as the formatter can parse the
+    /// text. If the format style can't parse the input, the bound value
+    /// remains unchanged.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// The following example uses a
+    /// <doc://com.apple.documentation/documentation/Swift/Double>
+    /// as the bound value, and a
+    /// <doc://com.apple.documentation/documentation/Foundation/NumberFormatter>
+    /// instance to convert to and from a string representation. The formatter
+    /// uses the
+    /// <doc://com.apple.documentation/documentation/Foundation/NumberFormatter/Style/decimal>
+    /// style, to allow entering a fractional part. As the user types, the bound
+    /// value updates, which in turn updates three ``Text`` views that use
+    /// different format styles. If the user enters text that doesn't represent
+    /// a valid `Double`, the bound value doesn't update.
+    ///
+    ///     @State private var myDouble: Double = 0.673
+    ///     @State private var numberFormatter: NumberFormatter = {
+    ///         var nf = NumberFormatter()
+    ///         nf.numberStyle = .decimal
+    ///         return nf
+    ///     }()
+    ///
+    ///     var body: some View {
+    ///         VStack {
+    ///             TextField(
+    ///                 value: $myDouble,
+    ///                 formatter: numberFormatter
+    ///             ) {
+    ///                 Text("Double")
+    ///             }
+    ///             Text(myDouble, format: .number)
+    ///             Text(myDouble, format: .number.precision(.significantDigits(5)))
+    ///             Text(myDouble, format: .number.notation(.scientific))
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///   - titleKey: The key for the localized title of the text field,
+    ///     describing its purpose.
+    ///   - value: The underlying value to edit.
+    ///   - formatter: A formatter to use when converting between the
+    ///     string the user edits and the underlying value of type `V`.
+    ///     If `formatter` can't perform the conversion, the text field doesn't
+    ///     modify `binding.value`.
+    @available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
+    public init<V>(_ titleKey: LocalizedStringKey, value: Binding<V>, formatter: Formatter) {
+        let binding = Binding<String>(
+            get: { formatter.string(for: value.wrappedValue) ?? "" },
+            set: { newValue in
+                var object: AnyObject?
+                var errorDescription: NSString?
+                
+                if formatter.getObjectValue(&object, for: newValue, errorDescription: &errorDescription),
+                   let formattedValue = object as? V {
+                    value.wrappedValue = formattedValue
+                }
+            }
+        )
+        
+        self.init(label: Text(titleKey), text: binding, prompt: nil)
+    }
+}
+
+extension CustomTextField where Label == Text {
+    
+    /// Creates a text field that applies a format style to a bound optional
+    /// value, with a label generated from a localized title string.
+    ///
+    /// Use this initializer to create a text field that binds to a bound optional
+    /// value, using a
+    /// <doc://com.apple.documentation/documentation/Foundation/ParseableFormatStyle>
+    /// to convert to and from this type. Changes to the bound value update
+    /// the string displayed by the text field. Editing the text field
+    /// updates the bound value, as long as the format style can parse the
+    /// text. If the format style can't parse the input, the text field
+    /// sets the bound value to `nil`.
+    ///
+    /// Use the ``View/onSubmit(of:_:)`` modifier to invoke an action
+    /// whenever the user submits this text field.
+    ///
+    /// The following example uses an optional
+    /// <doc://com.apple.documentation/documentation/Swift/Double>
+    /// as the bound currency value, and a
+    /// <doc://com.apple.documentation/documentation/Foundation/FloatingPointFormatStyle/Currency>
+    /// instance to convert to and from a representation as U.S. dollars. As
+    /// the user types, a `View.onChange(of:_:)` modifier logs the new value to
+    /// the console. If the user enters an invalid currency value, like letters
+    /// or emoji, the console output is `Optional(nil)`.
+    ///
+    ///     @State private var myMoney: Double? = 300.0
+    ///     var body: some View {
+    ///         TextField(
+    ///             "Currency (USD)",
+    ///             value: $myMoney,
+    ///             format: .currency(code: "USD")
+    ///         )
+    ///         .onChange(of: myMoney) { newValue in
+    ///             print ("myMoney: \(newValue)")
+    ///         }
+    ///     }
+    ///
+    /// - Parameters:
+    ///   - titleKey: The title of the text field, describing its purpose.
+    ///   - value: The underlying value to edit.
+    ///   - format: A format style of type `F` to use when converting between
+    ///     the string the user edits and the underlying value of type
+    ///     `F.FormatInput`. If `format` can't perform the conversion, the text
+    ///     field sets `binding.value` to `nil`.
+    ///   - prompt: A `Text` which provides users with guidance on what to type
+    ///     into the text field.
+    @available(iOS 15.0, macOS 12.0, tvOS 15.0, watchOS 8.0, *)
+    @MainActor public init(_ titleKey: LocalizedStringKey, value: Binding<F.FormatInput?>, format: F, prompt: Text? = nil)
+    where F : ParseableFormatStyle, F.FormatOutput == String {
+        self.init(
+            label: .init(titleKey),
+            value: value,
+            format: format,
+            prompt: prompt
+        )
+    }
+}
diff --git a/Sources/CustomTextField/CustomTextField.swift b/Sources/CustomTextField/CustomTextField.swift
new file mode 100644
index 0000000..6538a4a
--- /dev/null
+++ b/Sources/CustomTextField/CustomTextField.swift
@@ -0,0 +1,226 @@
+//
+//  CustomTextField.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+/// A customizable and stylable text field with parsing and formatting capabilities.
+///
+/// `CustomTextField` supports two-way binding of optional values, using a `ParseableFormatStyle`
+/// to convert between strings and model data types. It integrates with a custom text field style
+/// system and provides real-time validation feedback.
+///
+/// Use this view to build formatted inputs (e.g. currency, dates, numbers) with custom rendering
+/// and validation behavior.
+///
+/// ```swift
+/// CustomTextField(
+///     label: Text("Amount"),
+///     value: $amount,
+///     format: .currency(code: "USD"),
+///     prompt: Text("Enter amount")
+/// )
+/// ```
+///
+/// - Parameters:
+///   - label: A view describing the field (e.g., a `Text` label).
+///   - value: A binding to the underlying optional parsed value.
+///   - format: A `ParseableFormatStyle` used to convert between `String` and the model value.
+///   - prompt: An optional prompt (placeholder).
+///   - axis: Whether the text field should be single-line (`.horizontal`) or multi-line (`.vertical`).
+public struct CustomTextField<Label, F> : View
+where Label: View, F: ParseableFormatStyle, F.FormatOutput == String {
+    @Environment(\.customTextFieldStyle) var customTextFieldStyle
+    
+    private let label: Label
+    private let prompt: Text?
+    private let axis: Axis
+    private let format: F
+    @Binding private var value: F.FormatInput?
+    
+    @FocusState private var isFocused: Bool
+    @State private var error: LocalizedError?
+    @State private var localText: String = ""
+    
+    private var textBinding: Binding<String> {
+        Binding(
+            get: { readValue() ?? localText },
+            set: { updateValue($0) }
+        )
+    }
+    
+    /// Initializes a new `CustomTextField` using a parseable format style.
+    ///
+    /// - Parameters:
+    ///   - label: A view describing the field.
+    ///   - value: A binding to the formatted value.
+    ///   - format: The formatter to use for string conversion.
+    ///   - prompt: A placeholder shown when the field is empty.
+    ///   - axis: Determines the layout direction of the field. Default is `.horizontal`.
+    public init(
+        label: Label,
+        value: Binding<F.FormatInput?>,
+        format: F,
+        prompt: Text? = nil,
+        axis: Axis = .horizontal
+    ) {
+        self.label = label
+        self._value = value
+        self.format = format
+        self.prompt = prompt
+        self.axis = axis
+    }
+    
+    public var body: some View {
+        let style = TextFieldStyleProxy { label in
+            let configuration = CustomTextFieldStyleConfiguration(
+                label: CustomTextFieldStyleConfiguration.Label(body: AnyView(label)),
+                text: textBinding,
+                placeholder: prompt,
+                axis: axis,
+                isFocused: $isFocused
+            )
+            
+            let resolved = customTextFieldStyle.resolve(configuration: configuration)
+            
+            return AnyView(resolved)
+        }
+        
+        TextField(
+            text: textBinding,
+            prompt: prompt,
+            axis: axis,
+            label: { label }
+        )
+        .textFieldStyle(style)
+        .focused($isFocused)
+        .environment(\.customTextFieldParseError, error)
+    }
+    
+    private func updateValue(_ value: String) {
+        do {
+            let parsedValue = try format.parseStrategy.parse(value)
+            self.value = parsedValue
+            self.error = nil
+        } catch {
+            self.localText = value
+            self.value = nil
+            self.error = error as? LocalizedError
+        }
+    }
+    
+    private func readValue() -> F.FormatOutput? {
+        guard let value else { return nil }
+        return format.format(value)
+    }
+}
+
+extension CustomTextField where F == EmptyParseableFormatStyle {
+    /// Creates a `CustomTextField` for raw text entry without formatting or parsing.
+    ///
+    /// This is a shorthand initializer that bypasses format logic using `EmptyParseableFormatStyle`.
+    ///
+    /// - Parameters:
+    ///   - label: A view describing the field.
+    ///   - text: A binding to the raw string value.
+    ///   - prompt: A placeholder shown when the field is empty.
+    ///   - axis: Determines the layout direction of the field. Default is `.horizontal`.
+    public init(
+        label: Label,
+        text: Binding<F.FormatInput>,
+        prompt: Text? = nil,
+        axis: Axis = .horizontal
+    ) {
+        self.init(
+            label: label,
+            value: Binding(text),
+            format: EmptyParseableFormatStyle(),
+            prompt: prompt,
+            axis: axis
+        )
+    }
+}
+
+private struct ResolvedCustomTextField<Style: CustomTextFieldStyle>: View {
+    let configuration: CustomTextFieldStyleConfiguration
+    let style: Style
+    
+    var body: some View {
+        style.makeBody(configuration: configuration)
+    }
+}
+
+extension CustomTextFieldStyle {
+    @MainActor func resolve(configuration: Configuration) -> some View {
+        ResolvedCustomTextField(configuration: configuration, style: self)
+    }
+}
+
+// MARK: - Preview
+
+private struct DemoTextFieldStyle: CustomTextFieldStyle {
+    @Environment(\.lineLimit) private var lineLimit
+    
+    func makeBody(configuration: Configuration) -> some View {
+        HStack {
+            configuration.label
+            if !configuration.text.wrappedValue.isEmpty {
+                Button(action: { configuration.text.wrappedValue = "" }) {
+                    Image(systemName: "xmark")
+                }
+                .imageScale(.small)
+            }
+            Text("Line limit: \(String(describing: lineLimit))")
+                .font(.caption)
+                .foregroundStyle(.secondary)
+        }
+        .frame(height: 22)
+        .padding(8)
+        .background {
+            RoundedRectangle(cornerRadius: 12)
+                .stroke(Color.accentColor, lineWidth: 1)
+                .opacity(configuration.isFocused ? 1 : 0)
+        }
+        .background {
+            RoundedRectangle(cornerRadius: 12)
+                .foregroundStyle(.bar)
+        }
+    }
+}
+
+private struct PreviewView: View {
+    
+    @State private var text = ""
+    @State private var text2 = ""
+    @State private var text3 = ""
+    
+    var body: some View {
+        CustomTextField("Test", text: $text)
+            .padding()
+            .customTextFieldStyle(DemoTextFieldStyle())
+        
+        CustomTextField("Test", text: $text2)
+            .padding()
+            .customTextFieldStyle(DemoTextFieldStyle())
+        
+        CustomTextField("Test", text: $text3)
+            .padding()
+            .customTextFieldStyle(DemoTextFieldStyle())
+        
+        TextField("Test", text: $text)
+            .background {
+                RoundedRectangle(cornerRadius: 12)
+                    .foregroundStyle(.bar)
+            }
+    }
+}
+
+#Preview {
+    PreviewView()
+        .textFieldStyle(.plain)
+        .customTextFieldStyle(DemoTextFieldStyle())
+        .environment(\.lineLimit, 1)
+}
diff --git a/Sources/CustomTextField/CustomTextFieldStyle.swift b/Sources/CustomTextField/CustomTextFieldStyle.swift
new file mode 100644
index 0000000..8683989
--- /dev/null
+++ b/Sources/CustomTextField/CustomTextFieldStyle.swift
@@ -0,0 +1,49 @@
+//
+//  CustomTextFieldStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 01.09.2024.
+//
+
+import SwiftUI
+
+/// A protocol that defines the visual and behavioral style of a `CustomTextField`.
+///
+/// Conform to `CustomTextFieldStyle` to customize how `CustomTextField` is rendered,
+/// including layout, focus appearance, placeholder display, and other visual aspects.
+///
+/// A `CustomTextFieldStyle` is provided via the SwiftUI environment and must implement
+/// `makeBody(configuration:)` to return a view that renders the styled text field.
+///
+/// ```swift
+/// struct RoundedBorderTextFieldStyle: CustomTextFieldStyle {
+///     func makeBody(configuration: Configuration) -> some View {
+///         HStack {
+///             configuration.label.body
+///             TextField("", text: configuration.text)
+///                 .padding(8)
+///                 .background(RoundedRectangle(cornerRadius: 8).stroke())
+///         }
+///     }
+/// }
+/// ```
+///
+/// Apply a custom style using:
+/// ```swift
+/// CustomTextField(...)
+///     .customTextFieldStyle(RoundedBorderTextFieldStyle())
+/// ```
+public protocol CustomTextFieldStyle: DynamicProperty {
+
+    /// The associated view returned by the custom style.
+    associatedtype Body: View
+
+    /// The configuration structure passed into `makeBody`, containing all necessary
+    /// data to render a styled field.
+    typealias Configuration = CustomTextFieldStyleConfiguration
+
+    /// Creates the styled view representing the body of a `CustomTextField`.
+    ///
+    /// - Parameter configuration: The current state and metadata of the field.
+    /// - Returns: A view describing the styled appearance of the field.
+    @MainActor func makeBody(configuration: Configuration) -> Self.Body
+}
diff --git a/Sources/CustomTextField/CustomTextFieldStyleConfiguration.swift b/Sources/CustomTextField/CustomTextFieldStyleConfiguration.swift
new file mode 100644
index 0000000..7faa265
--- /dev/null
+++ b/Sources/CustomTextField/CustomTextFieldStyleConfiguration.swift
@@ -0,0 +1,44 @@
+//
+//  CustomTextFieldStyleConfiguration.swift
+//
+//  Created by Valeriy Malishevskyi on 01.09.2024.
+//
+
+import SwiftUI
+
+/// A configuration object that provides context and content for rendering a `CustomTextFieldStyle`.
+///
+/// This structure is passed to the `makeBody(configuration:)` method of a `CustomTextFieldStyle`,
+/// giving the style access to the label, text binding, placeholder, layout axis, and focus state.
+///
+/// Use this data to render a custom layout or behavior for the text field.
+public struct CustomTextFieldStyleConfiguration {
+
+    /// A view representing the field's label.
+    ///
+    /// Typically a `Text`, but may be any view supplied during the `CustomTextField`'s initialization.
+    public struct Label: View {
+
+        /// The rendered body of the label.
+        public let body: AnyView
+    }
+
+    /// The label view associated with the field.
+    public let label: Label
+
+    /// A binding to the user-entered or formatted string content.
+    ///
+    /// Use this to create the actual `TextField` within your style implementation.
+    public let text: Binding<String>
+
+    /// An optional placeholder to show when the field is empty.
+    public let placeholder: Text?
+
+    /// The layout axis of the field, either `.horizontal` (single-line) or `.vertical` (multi-line).
+    public let axis: Axis
+
+    /// A binding to the focus state of the text field.
+    ///
+    /// Use this to customize the visual appearance based on whether the field is currently focused.
+    @FocusState.Binding public var isFocused: Bool
+}
diff --git a/Sources/CustomTextField/DefaultCustomTextFieldStyle.swift b/Sources/CustomTextField/DefaultCustomTextFieldStyle.swift
new file mode 100644
index 0000000..780284e
--- /dev/null
+++ b/Sources/CustomTextField/DefaultCustomTextFieldStyle.swift
@@ -0,0 +1,13 @@
+//
+//  DefaultCustomTextFieldStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 01.09.2024.
+//
+
+import SwiftUI
+
+public struct DefaultCustomTextFieldStyle: CustomTextFieldStyle {
+    public func makeBody(configuration: Configuration) -> some View {
+        configuration.label
+    }
+}
diff --git a/Sources/CustomTextField/EmptyFormatStyle.swift b/Sources/CustomTextField/EmptyFormatStyle.swift
new file mode 100644
index 0000000..f9fe503
--- /dev/null
+++ b/Sources/CustomTextField/EmptyFormatStyle.swift
@@ -0,0 +1,23 @@
+//
+//  EmptyFormatStyle.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+public struct EmptyParseableFormatStyle: ParseableFormatStyle {
+    
+    public struct Strategy: ParseStrategy {
+        public func parse(_ value: String) throws -> String {
+            value
+        }
+    }
+    
+    public func format(_ value: String) -> String {
+        value
+    }
+    
+    public var parseStrategy: Strategy { Strategy() }
+}
diff --git a/Sources/CustomTextField/EnvironmentValues.swift b/Sources/CustomTextField/EnvironmentValues.swift
new file mode 100644
index 0000000..a5611d5
--- /dev/null
+++ b/Sources/CustomTextField/EnvironmentValues.swift
@@ -0,0 +1,29 @@
+//
+//  EnvironmentValues.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+extension EnvironmentValues {
+    /// An error representing the most recent parse failure from a `CustomTextField`, if any.
+    ///
+    /// This environment value is automatically set by `CustomTextField` when parsing user input fails,
+    /// allowing styles or other views to react to validation errors and display feedback.
+    ///
+    /// You can access this in a custom `CustomTextFieldStyle` or surrounding views to show error messages.
+    ///
+    /// ```swift
+    /// @Environment(\.customTextFieldParseError) var error
+    ///
+    /// if let error = error {
+    ///     Text(error.localizedDescription)
+    ///         .foregroundColor(.red)
+    /// }
+    /// ```
+    ///
+    /// - Note: This value is `nil` when parsing succeeds or no attempt has been made.
+    @Entry public var customTextFieldParseError: Error?
+}
diff --git a/Sources/CustomTextField/TextFieldStyleProxy.swift b/Sources/CustomTextField/TextFieldStyleProxy.swift
new file mode 100644
index 0000000..327dcba
--- /dev/null
+++ b/Sources/CustomTextField/TextFieldStyleProxy.swift
@@ -0,0 +1,16 @@
+//
+//  TextFieldStyleProxy.swift
+//  CustomComponents
+//
+//  Created by Valeriy Malishevskyi on 13.05.2025.
+//
+
+import SwiftUI
+
+struct TextFieldStyleProxy<V: View>: TextFieldStyle {
+    let makeBody: (TextField<Self._Label>) -> V
+    
+    func _body(configuration: TextField<Self._Label>) -> V {
+        makeBody(configuration)
+    }
+}
diff --git a/Sources/CustomTextField/View+CustomTextFieldStyle.swift b/Sources/CustomTextField/View+CustomTextFieldStyle.swift
new file mode 100644
index 0000000..207f5bf
--- /dev/null
+++ b/Sources/CustomTextField/View+CustomTextFieldStyle.swift
@@ -0,0 +1,41 @@
+//
+//  View+CustomTextFieldStyle.swift
+//
+//  Created by Valeriy Malishevskyi on 01.09.2024.
+//
+
+import SwiftUI
+
+extension View {
+
+    /// Sets a custom text field style for use within this view’s hierarchy.
+    ///
+    /// This modifier allows you to override the appearance and behavior of `CustomTextField`
+    /// by injecting a `CustomTextFieldStyle` into the environment.
+    ///
+    /// ```swift
+    /// CustomTextField(...)
+    ///     .customTextFieldStyle(MyCustomStyle())
+    /// ```
+    ///
+    /// - Parameter style: A style conforming to `CustomTextFieldStyle`.
+    /// - Returns: A view that uses the provided text field style within its subtree.
+    public func customTextFieldStyle<Style: CustomTextFieldStyle>(_ style: Style) -> some View {
+        environment(\.customTextFieldStyle, style)
+    }
+}
+
+extension EnvironmentValues {
+    /// The current `CustomTextFieldStyle` used in the environment.
+    ///
+    /// This value is read by `CustomTextField` to determine how to render itself.
+    /// If no style is explicitly set, `DefaultCustomTextFieldStyle` is used.
+    var customTextFieldStyle: any CustomTextFieldStyle {
+        get { self[CustomTextFieldStyleKey.self] }
+        set { self[CustomTextFieldStyleKey.self] = newValue }
+    }
+}
+
+private struct CustomTextFieldStyleKey: EnvironmentKey {
+    nonisolated(unsafe) static let defaultValue: any CustomTextFieldStyle = DefaultCustomTextFieldStyle()
+}

From e81521bed542b276e8e23de27eb0c7e8cf653a69 Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Tue, 13 May 2025 02:30:11 +0300
Subject: [PATCH 5/6] code cleanup

---
 Sources/CustomCell/CustomCell.swift       |  2 +-
 Sources/CustomStepper/CustomStepper.swift | 17 ++++++++++-------
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/Sources/CustomCell/CustomCell.swift b/Sources/CustomCell/CustomCell.swift
index 97d7f19..2d5a9a4 100644
--- a/Sources/CustomCell/CustomCell.swift
+++ b/Sources/CustomCell/CustomCell.swift
@@ -97,7 +97,7 @@ private struct PreviewCellStyle: CustomCellStyle {
             Spacer()
             configuration.accessory
             
-            Text("Line limit: \(lineLimit)")
+            Text("Line limit: \(String(describing: lineLimit))")
                 .font(.caption)
                 .foregroundColor(.gray)
                 .padding(.leading, 8)
diff --git a/Sources/CustomStepper/CustomStepper.swift b/Sources/CustomStepper/CustomStepper.swift
index d34e5ed..b49571a 100644
--- a/Sources/CustomStepper/CustomStepper.swift
+++ b/Sources/CustomStepper/CustomStepper.swift
@@ -180,21 +180,24 @@ where Label : View {
     /// see <doc:Declaring-a-Custom-View>.
     @MainActor public var body: some View {
         
+        let resolvedOnIncrement = onIncrement()
+        let resolvedOnDecrement = onDecrement()
+        
         let elementConfiguration = CustomStepperElementConfiguration(
-            onIncrement: onIncrement() ?? {},
-            onDecrement: onDecrement() ?? {}
+            onIncrement: resolvedOnIncrement ?? {},
+            onDecrement: resolvedOnDecrement ?? {}
         )
         
         let decrement = (elementStyle ?? style).makeDecrement(configuration: elementConfiguration)
-            .disabled(onDecrement() == nil)
+            .disabled(resolvedOnDecrement == nil)
         
         let increment = (elementStyle ?? style).makeIncrement(configuration: elementConfiguration)
-            .disabled(onIncrement() == nil)
+            .disabled(resolvedOnIncrement == nil)
         
         let configuration = CustomStepperConfiguration(
             label: .init(body: .init(label)),
-            onIncrement: onIncrement() ?? {},
-            onDecrement: onDecrement() ?? {},
+            onIncrement: resolvedOnIncrement ?? {},
+            onDecrement: resolvedOnDecrement ?? {},
             decrement: .init(body: .init(decrement)),
             increment: .init(body: .init(increment))
         )
@@ -227,7 +230,7 @@ private struct PreviewStepperStyle: CustomStepperStyle {
             configuration.decrement
             VStack {
                 configuration.label
-                Text("Line limit: \(lineLimit)")
+                Text("Line limit: \(String(describing: lineLimit))")
                     .font(.caption)
                     .foregroundStyle(.secondary)
             }

From 60cf09779eac46efae4934a66fce17cdf9373a20 Mon Sep 17 00:00:00 2001
From: Valeriy Malishevskyi <stalkermv@ukr.net>
Date: Tue, 13 May 2025 02:30:16 +0300
Subject: [PATCH 6/6] Update CustomSection.swift

---
 Sources/CustomSection/CustomSection.swift | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sources/CustomSection/CustomSection.swift b/Sources/CustomSection/CustomSection.swift
index 3f1787c..e074355 100644
--- a/Sources/CustomSection/CustomSection.swift
+++ b/Sources/CustomSection/CustomSection.swift
@@ -88,7 +88,7 @@ private struct PreviewSectionStyle: CustomSectionStyle {
                 .font(.footnote)
                 .foregroundColor(.gray)
             
-            Text("Line limit: \(lineLimit)")
+            Text("Line limit: \(String(describing: lineLimit))")
                 .font(.subheadline)
                 .foregroundColor(.green)
         }