Add support for strict concurrency and tweak some styles

Author: danielsaidi

Package.swift

@@ -14,15 +14,19 @@ let package = Package(
     products: [
         .library(
             name: "TagKit",
-            targets: ["TagKit"]),
+            targets: ["TagKit"]
+        )
     ],
-    dependencies: [],
     targets: [
         .target(
             name: "TagKit",
-            dependencies: []),
+            swiftSettings: [
+                .enableExperimentalFeature("StrictConcurrency")
+            ]
+        ),
         .testTarget(
             name: "TagKitTests",
-            dependencies: ["TagKit"]),
+            dependencies: ["TagKit"]
+        )
     ]
 )

RELEASE_NOTES.md

@@ -3,6 +3,16 @@
 TagKit will use semver after 1.0.
 
 
+## 0.3
+
+This version adds support for strict concurrency.
+
+This requires standard styles to be converted to read-only values.
+
+This version also adjusts the visual appearance of some standard styles.
+
+
+
 ## 0.2
 
 This version bumps the package to Swift 5.9 and adds support for visionOS.

Sources/TagKit/SlugConfiguration.swift

@@ -8,23 +8,19 @@
 
 import Foundation
 
-/**
- This configuration defines how ``Slugifiable`` types are to
- be slugified.
-
- Use the ``SlugConfiguration/standard`` configuration if you
- want the standard configuration, which limits the slugified
- strings to `a-z` and `1-9`, using `-` as separator.
- */
+/// This configuration defines how ``Slugifiable`` types are
+/// slugified.
+///
+/// Use the ``SlugConfiguration/standard`` configuration for
+/// the default behavior, which limits the slugified strings
+/// to `a-z` and `1-9`, using `-` as separator.
 public struct SlugConfiguration {
 
-    /**
-     Create a new slug configurator.
-
-     - Parameters:
-       - separator: The separator to use in the slugified string, by default `-`.
-       - allowedCharacters: The characters to allow in the slugified string, by default alphanumerical characters and `-`.
-     */
+    /// Create a new slug configurator.
+    ///
+    /// - Parameters:
+    ///   - separator: The separator to use in the slugified string, by default `-`.
+    ///   - allowedCharacters: The characters to allow in the slugified string, by default alphanumerical characters and `-`.
     public init(
         separator: String = "-",
         allowedCharacters: String = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
@@ -35,27 +31,19 @@ public struct SlugConfiguration {
         self.allowedCharacterSet = NSCharacterSet(charactersIn: chars)
     }
 
-    /**
-     The separator to use in the slugified string.
-     */
+    /// The separator to use in the slugified string.
     public let separator: String
 
-    /**
-     The characters to allow in the slugified string.
-     */
+    /// The characters to allow in the slugified string.
     public let allowedCharacters: String
 
-    /**
-     The character set to allow in the slugified string.
-     */
+    /// The character set to allow in the slugified string.
     public let allowedCharacterSet: NSCharacterSet
 }
 
 public extension SlugConfiguration {
 
-    /**
-     Create a standard slug configuration, which allows `a-z`
-     and `1-9` and uses `-` as separator.
-     */
-    static let standard = SlugConfiguration()
+    /// A standard slug configuration, that allows `a-z` and
+    /// `1-9` and uses `-` as the component separator.
+    static var standard: SlugConfiguration { .init() }
 }

Sources/TagKit/Slugifiable.swift

@@ -8,39 +8,32 @@
 
 import Foundation
 
-/**
- This protocol describes a type that can be slugified into a
- slug representation that can be used in e.g. tags.
-
- Types that implement this protocol get access to a bunch of
- additional functionality, e.g. ``slugified(configuration:)``.
-
- When slugifying, "Hello there, friends!" will by default be
- converted to `hello-there-friends`, but this format depends
- on the ``SlugConfiguration`` that is used.
-
- This protocol is automatically implemented by `String`.
- */
+/// This protocol describes a slugifiable type, which can be
+/// represented as a slugified string.
+///
+/// Slugified strings are for instance used in urls and tags,
+/// where a text is represented by removing unsupported text
+/// components. The standard format can be customized with a
+/// custom ``SlugConfiguration``.
+///
+/// By default, `Hello, world!` is slugified to `hello-world`.
+///
+/// This protocol is automatically implemented by `String`.
 public protocol Slugifiable {
 
-    /**
-     The slugifiable value that will be used when creating a
-     slugified string.
-     */
+    /// The value used to create a slugified representation.
     var slugifiableValue: String { get }
 }
 
 public extension Slugifiable {
 
-    /**
-     Convert the slugifiable value to a slugified string.
-
-     With the default configuration, `I'd love an AppleCar!`
-     will be slugified as `i-d-love-an-apple-car`.
-
-     - Parameters:
-       - configuration: The configuration to use, by default ``SlugConfiguration/standard``.
-     */
+    /// Convert the slugifiable value to a slugified string.
+    ///
+    /// With the default configuration, `Hello, world!` will
+    /// be slugified to `hello-world`.
+    ///
+    /// - Parameters:
+    ///   - configuration: The configuration to use, by default ``SlugConfiguration/standard``.
     func slugified(
         configuration: SlugConfiguration = .standard
     ) -> String {
@@ -55,9 +48,5 @@ public extension Slugifiable {
 
 extension String: Slugifiable {
 
-    /**
-     The sluggable value that will be used when creating the
-     slugified result.
-     */
     public var slugifiableValue: String { self }
 }

Sources/TagKit/Taggable+Collection.swift

@@ -10,20 +10,15 @@ import Foundation
 
 public extension Collection where Element: Taggable {
 
-    /**
-     Get all the slugified tags in the collection.
-
-     The tags are slugified to remove any casing and spacing
-     differences that may exist between the items.
-     */
+    /// Get all the slugified tags in the collection.
+    ///
+    /// Read more about slugified strings in ``Slugifiable``.
     var allTags: [String] {
         let slugs = flatMap { $0.slugifiedTags }
         return Array(Set(slugs)).sorted()
     }
 
-    /**
-     Get all items in the collection that have a certain tag.
-     */
+    /// Get all items in the collection with a certain tag.
     func withTag(_ tag: String) -> [Element] {
         filter { $0.hasTag(tag) }
     }

Sources/TagKit/Taggable.swift

@@ -8,81 +8,62 @@
 
 import Foundation
 
-/**
- This protocol describe types that can be tagged with one or
- many tags, which can then be used to group, search etc.
-
- Types that implement this protocol get access to a bunch of
- additional functionality, e.g. ``hasTags``, ``addTag(_:)``.
-
- Note that the ``tags`` property is a raw list of tags, that
- should contain slugified tags. However, since this protocol
- can be implemented by any type, you can use ``slugifiedTags``
- to ensure that you get a list of slugified tags.
- */
+/// This protocol describe types that can be tagged with one
+/// or many tags, which can be used to group, search etc.
+///
+/// Types that implement this protocol get access to a bunch
+/// of additional features, e.g. ``hasTags``, ``addTag(_:)``,
+/// ``toggleTag(_:)``, etc.
+///
+/// Note that the ``tags`` property is a raw string list. If
+/// ypu want a list of slugified tags, use ``slugifiedTags``.
 public protocol Taggable {
 
-    /**
-     All tags that have been applied to the item.
-     */
+    /// All tags that have been applied to the item.
     var tags: [String] { get set }
 }
 
 public extension Taggable {
 
-    /**
-     Whether or not the item has any tags.
-     */
+    /// Whether or not the item has any tags.
     var hasTags: Bool {
         !tags.isEmpty
     }
 
-    /**
-     Get a list of slugified ``tags``.
-     */
+    /// Get a list of slugified ``tags``.
     var slugifiedTags: [String] {
         slugifiedTags()
     }
 
-    /**
-     Add a tag to the taggable type.
-     */
+    /// Add a tag to the taggable type.
     mutating func addTag(_ tag: String) {
         if hasTag(tag) { return }
         tags.append(tag)
     }
 
-    /**
-     Whether or not the item has a certain tag.
-     */
+    /// Whether or not the item has a certain tag.
     func hasTag(_ tag: String) -> Bool {
         if tag.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty { return true }
         return slugifiedTags.contains(tag.slugified())
     }
 
-    /**
-     Remove a tag from the taggable type.
-     */
+    /// Remove a tag from the taggable type.
     mutating func removeTag(_ tag: String) {
         guard hasTag(tag) else { return }
         tags = tags.filter { $0 != tag }
     }
 
-    /**
-     Get a list of slugified ``tags`` for a certain config.
-
-     - Parameters:
-       - config: The slug configuration to use, by default ``SlugConfiguration/standard``.
-     */
+    /// Get a list of slugified ``tags``.
+    ///
+    /// - Parameters:
+    ///   - config: The slug configuration to use, by default ``SlugConfiguration/standard``.
     func slugifiedTags(
         configuration: SlugConfiguration = .standard
     ) -> [String] {
         tags.map { $0.slugified(configuration: configuration) }
     }
 
-    /**
-     Toggle a tag on the taggable type.
-     */
+    /// Toggle a tag on the taggable type.
     mutating func toggleTag(_ tag: String) {
         if hasTag(tag) {
             removeTag(tag)

Sources/TagKit/Views/FlowLayout.swift

@@ -10,19 +10,14 @@
 
 import SwiftUI
 
-/**
- This view lists data in a leading to trailing flow.
-
- The view will break to a new line whenever the view doesn't
- fit on the current line.
-
- You must specify a container type, since the view has to be
- rendered differently depending on if it's in a `ScrollView`
- or a `VerticalStack`.
-
- The view is internal and kept for reference, if we will use
- it on other ways in the future.
- */
+/// This view lists data in a leading to trailing flow.
+///
+/// The view will break to a new line whenever the view does
+/// not fit on the current line.
+///
+/// You must specify a container type, since the view has to
+/// be rendered differently depending on in the container it
+/// is used in, e.g.  `ScrollView`, `VStack`, etc.
 public struct FlowLayout<ItemType, ItemView: View>: View {
 
     /// Create a flow layout.
@@ -75,6 +70,7 @@ public struct FlowLayout<ItemType, ItemView: View>: View {
     }
 }
 
+@MainActor
 private extension FlowLayout {
 
     var content: some View {