Added source

Author: amayers

.gitignore

@@ -44,47 +44,7 @@ playground.xcworkspace
 #
 # Xcode automatically generates this directory with a .xcworkspacedata file and xcuserdata
 # hence it is not needed unless you have added a package configuration file to your project
-# .swiftpm
+.swiftpm
 
 .build/
 
-# CocoaPods
-#
-# We recommend against adding the Pods directory to your .gitignore. However
-# you should judge for yourself, the pros and cons are mentioned at:
-# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
-#
-# Pods/
-#
-# Add this line if you want to avoid checking in source code from the Xcode workspace
-# *.xcworkspace
-
-# Carthage
-#
-# Add this line if you want to avoid checking in source code from Carthage dependencies.
-# Carthage/Checkouts
-
-Carthage/Build/
-
-# Accio dependency management
-Dependencies/
-.accio/
-
-# fastlane
-#
-# It is recommended to not store the screenshots in the git repo.
-# Instead, use fastlane to re-generate the screenshots whenever they are needed.
-# For more information about the recommended setup visit:
-# https://docs.fastlane.tools/best-practices/source-control/#source-control
-
-fastlane/report.xml
-fastlane/Preview.html
-fastlane/screenshots/**/*.png
-fastlane/test_output
-
-# Code Injection
-#
-# After new code Injection tools there's a generated folder /iOSInjectionProject
-# https://github.com/johnno1962/injectionforxcode
-
-iOSInjectionProject/

Package.swift

@@ -0,0 +1,23 @@
+// swift-tools-version:5.2
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "NumericText",
+    platforms: [.iOS(.v13), .macOS(.v10_15), .watchOS(.v6), .tvOS(.v13)],
+    products: [
+        .library(
+            name: "NumericText",
+            targets: ["NumericText"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "NumericText",
+            dependencies: []),
+        .testTarget(
+            name: "NumericTextTests",
+            dependencies: ["NumericText"]),
+    ]
+)

README.md

@@ -0,0 +1,37 @@
+# NumericText
+
+A simple SwiftUI `TextField` that limits user input to numbers.
+
+The most common response in https://stackoverflow.com/questions/58733003/swiftui-how-to-create-textfield-that-only-accepts-numbers (the top search result), advocates just setting a numeric keyboard. But that totally misses cases when used with hardware keyboards. Many of the suggested  
+
+This `NumericTextField` prevents any non-numeric text input, no matter the source (paste, external keyboard). You can choose to allow integers or floating point. 
+Standard `TextFields` have a `Formatter` that you can pass in, that will be used to format/validate input. However this only occurs when the user finishes editing, not for every keystroke. So a user can type `123abc4` and see that in the text field, then when they hit return it will change to `1234`. That's really not ideal. With `NumericTextField` when they type a non-numeric character it is ignored and never shows up in the text field.
+
+
+## Usage:
+
+It works just like `TextField` but you are binding it to `NSNumber?` instead of a `String`.
+
+```
+// Inside your view
+@State private static var int: NSNumber?
+@State private static var double: NSNumber?
+
+var body: Some View {
+    VStack {
+        NumericTextField("Int", number: $int, isDecimalAllowed: false)
+        NumericTextField("Double", number: $double, isDecimalAllowed: true)
+    }
+}
+
+```
+
+## Installation
+
+Use Swift Package Manager or just drag and drop the two source files into your project. It supports any of Apple's platforms that support SwiftUI's initial release. So iOS 13, macOS 10.15, tvOS 13, watchOS 6.
+
+## Improvement ideas
+* Ditch `NSNumber?` as the bound value, and allow binding either `Int?` or `Double?`. I took a quick shot at this, but my generics skills weren't sufficient to figure it out.
+* Support the other initializers that `TextField` supports.
+
+Pull requests are welcome to help with these or any other things you may find or think of.

Sources/NumericText/NumericTextField.swift

@@ -0,0 +1,69 @@
+import SwiftUI
+
+/// A `TextField` replacement that limits user input to numbers.
+public struct NumericTextField: View {
+
+    /// This is what consumers of the text field will access
+    @Binding private var number: NSNumber?
+    @State private var string: String
+    private let isDecimalAllowed: Bool
+    private let formatter: NumberFormatter = NumberFormatter()
+
+    private let title: LocalizedStringKey
+    private let onEditingChanged: (Bool) -> Void
+    private let onCommit: () -> Void
+
+    /// 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.
+    ///   - number: The number to be displayed and edited.
+    ///   - isDecimalAllowed: Should the user be allowed to enter a decimal number, or an integer
+    ///   - onEditingChanged: An action thats called when the user begins editing `text` and after the user finishes editing `text`.
+    ///     The closure receives a Boolean indicating whether the text field is currently being edited.
+    ///   - onCommit: An action to perform when the user performs an action (for example, when the user hits the return key) while the text field has focus.
+    public init(_ titleKey: LocalizedStringKey, number: Binding<NSNumber?>, isDecimalAllowed: Bool, onEditingChanged: @escaping (Bool) -> Void = { _ in }, onCommit: @escaping () -> Void = {}) {
+        formatter.numberStyle = .decimal
+        _number = number
+        if let number = number.wrappedValue, let string = formatter.string(from: number) {
+        _string = State(initialValue: string)
+        } else {
+            _string = State(initialValue: "")
+        }
+        self.isDecimalAllowed = isDecimalAllowed
+        title = titleKey
+        self.onEditingChanged = onEditingChanged
+        self.onCommit = onCommit
+    }
+
+    public var body: some View {
+        TextField(title, text: $string, onEditingChanged: onEditingChanged, onCommit: onCommit)
+            .keyboardType(isDecimalAllowed ? .decimalPad : .numberPad)
+            .onChange(of: string, perform: numberChanged(newValue:))
+    }
+
+    private func numberChanged(newValue: String) {
+        let numeric = newValue.numericValue(allowDecimalSeparator: isDecimalAllowed)
+        if newValue != numeric {
+            string = numeric
+        }
+        number = formatter.number(from: string)
+    }
+}
+
+struct NumericTextField_Previews: PreviewProvider {
+    @State private static var int: NSNumber?
+    @State private static var double: NSNumber?
+
+    static var previews: some View {
+        VStack {
+            NumericTextField("Int", number: $int, isDecimalAllowed: false)
+                .textFieldStyle(RoundedBorderTextFieldStyle())
+                .padding()
+            NumericTextField("Double", number: $double, isDecimalAllowed: true)
+                .textFieldStyle(RoundedBorderTextFieldStyle())
+                .padding()
+        }
+    }
+}

Sources/NumericText/String+Numeric.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+public extension String {
+    /// Get the numeric only value from the string
+    /// - Parameter allowDecimalSeparator: If `true` then a single decimal separator will be allowed in the string.
+    /// - Returns: Only numeric characters and optionally a single decimal character. If non-numeric values were interspersed `1a2b` then the result will be `12`.
+    ///            The numeric characters returned may be outside the normal 0-9 ASCII that you would expect. So you should avoid trying any `Int(someString)` with the results.
+    ///            Stick to using `NumberFormatter` like Apple intended.
+    func numericValue(allowDecimalSeparator: Bool) -> String {
+        var hasFoundDecimal = false
+        return self.filter {
+            if $0.isWholeNumber {
+                return true
+            } else if allowDecimalSeparator && String($0) == (Locale.current.decimalSeparator ?? ".") {
+                defer { hasFoundDecimal = true }
+                return !hasFoundDecimal
+            }
+            return false
+        }
+    }
+}

Tests/NumericTextTests/StringNumericTests.swift

@@ -0,0 +1,27 @@
+import NumericText
+import XCTest
+
+final class StringNumericTests: XCTestCase {
+    func testDoubleDecimal() {
+        XCTAssertEqual("12.3.4".numericValue(allowDecimalSeparator: true), "12.34")
+        XCTAssertEqual("12..34".numericValue(allowDecimalSeparator: true), "12.34")
+        XCTAssertEqual(".1234.".numericValue(allowDecimalSeparator: true), ".1234")
+    }
+
+    func testObscureNumericCharacters() throws {
+        let formatter = NumberFormatter()
+        formatter.numberStyle = .decimal
+
+        // DEVANAGARI 5
+        let fiveString = "५"
+        XCTAssertEqual(fiveString.numericValue(allowDecimalSeparator: false), fiveString)
+        let five = try XCTUnwrap(formatter.number(from: fiveString))
+        XCTAssertEqual(five, 5)
+    }
+
+    func testAlphaNumeric() {
+        XCTAssertEqual("12a.3b4".numericValue(allowDecimalSeparator: true), "12.34")
+        XCTAssertEqual("12abc34".numericValue(allowDecimalSeparator: true), "1234")
+        XCTAssertEqual("a.1234.".numericValue(allowDecimalSeparator: true), ".1234")
+    }
+}