CoreUI 1.0.0

Author: ivkosh

.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+/.build
+/Packages
+/*.xcodeproj
+xcuserdata/
+DerivedData/
+.swiftpm/config/registries.json
+.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Ivan Koshkin
+
+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.

Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version:5.3
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "CoreUI",
+    platforms: [.iOS(.v11)],
+    products: [
+        .library(name: "CoreUI", targets: ["CoreUI"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "CoreUI",
+            dependencies: []),
+        .testTarget(
+            name: "CoreUITests",
+            dependencies: ["CoreUI"]),
+    ]
+)

README.md

@@ -0,0 +1,33 @@
+# CoreUI
+
+Library to build UI in declarative and functional style. Built on top of UIKit and supports old iOS versions.
+
+```swift
+import UIKit
+import CoreUI
+
+class MyViewController: UIViewController {
+
+  override func viewDidLoad() {
+    super.viewDidLoad()
+
+    addSubview(
+      UI.VScrollView(
+        contentInset: .vertical(12),
+        UI.VStack(
+          UI.View(backgroundColor: .red, height: 20),
+          UI.Label("Are you sure?", font: .systemFont(ofSize: 24), color: .label),
+          UI.Spacer(minHeight: 30),
+          UI.HStack(
+            spacing: 12,
+            UI.Button("Yes").apply { $0.addTarget(self, action: #selector(yesTapped), for: .touchUpInside) },
+            UI.Button("No").apply { $0.addTarget(self, action: #selector(noTapped), for: .touchUpInside) }
+          )
+        ),
+        .leading(6), .trailing(-6), .safeTop(0), .safeBottom(0)
+      )
+    )
+  }
+
+}
+```

Sources/CoreUI/ApplyProtocol/ApplyProtocol+Optional.swift

@@ -0,0 +1,31 @@
+/*
+ 
+/// Extension for `Optional` to use as `someOptionalVar.let { ... }`
+/// No actual need for this in real life, we can always use `someOptionalVar?.let { ... }`.
+/// Keeping it here for future reference.
+///
+extension Optional where Wrapped: ApplyProtocol {
+    /// Applies `block` to some optional `object` and returns block result or `nil`.
+    /// If `object` is non-nil, block receives `object` as its first parameter.
+    /// - Parameter block: block receiving Self as its first parameter and returning
+    /// - Returns: block return value
+    ///
+    /// # Example
+    /// ```
+    /// var optionalValue: SomeClass? = nil
+    /// let propertyOrNil = optionalValue.let {
+    ///    return $0.someProperty
+    /// }
+    /// XCAssertNil(propertyOrNil)
+    ///
+    /// optionalValue = SomeClass()
+    ///
+    /// ```
+    @inlinable
+    func `let`<R>(block: (Wrapped) -> R?) -> R? {
+        guard let `self` = self else { return nil }
+        return block(self)
+    }
+}
+
+*/

Sources/CoreUI/ApplyProtocol/ApplyProtocol+UIKit.swift

@@ -0,0 +1,9 @@
+import Foundation
+import UIKit
+
+/// Adding ApplyProtocol to some manually selected classes only (UIView, etc).
+/// Do not adding ApplyProtocol to NSObject: it will be too wide.
+extension UIView: ApplyProtocol {}
+extension UIViewController: ApplyProtocol {}
+extension NSLayoutConstraint: ApplyProtocol {}
+extension UIGestureRecognizer: ApplyProtocol {}

Sources/CoreUI/ApplyProtocol/ApplyProtocol.swift

@@ -0,0 +1,44 @@
+/// Kotlin-like .apply and .let function
+public protocol ApplyProtocol {}
+
+public extension ApplyProtocol {
+
+    /// Applies `block` to some `object` and returns `object`.
+    /// Block receives `object` as its first parameter.
+    /// - Parameter block: block which is applied to self
+    /// - Returns: self
+    ///
+    /// # Example
+    /// ```
+    /// let view = UIView().apply {
+    ///    $0.backgroundColor = .red
+    ///    $0.translatesAutoresizingMaskIntoConstraints = false
+    ///    // implicitly returns modified UIView
+    /// }
+    /// ```
+    @inlinable
+    @discardableResult
+    func apply(_ block: (Self) -> Void) -> Self {
+        block(self)
+        return self
+    }
+
+    /// Applies `block` to some `object` and returns block result.
+    /// Block receives `object` as its first parameter.
+    /// - Parameter block: block which is applied to self
+    /// - Returns: block return value
+    ///
+    /// # Example
+    /// ```
+    /// let xFromFrameOriginWithAddition = UIView(frame: .zero).let {
+    ///    // do something with new UIView here
+    ///    return $0.frame.origin.x + 200
+    /// }
+    /// XCTAssertEqual(xFromFrameOriginWithAddition, 200)
+    /// ```
+    @inlinable
+    func `let`<R>(block: (Self) -> R) -> R {
+        return block(self)
+    }
+}
+