223 |
224 | | App Icon |
225 | App Name & Description |
226 | Supported Platforms |
227 |
228 |
229 |
230 |
231 | 
232 |
233 | |
234 |
235 |
236 | TranslateKit: App Localization
237 |
238 |
239 | AI-powered app localization with unmatched accuracy. Fast & easy: AI & proofreading, 125+ languages, market insights. Budget-friendly, free to try.
240 | |
241 | Mac |
242 |
243 |
244 |
245 |
246 | 
247 |
248 | |
249 |
250 |
251 | FreemiumKit: In-App Purchases for Indies
252 |
253 |
254 | Simple In-App Purchases and Subscriptions: Automation, Paywalls, A/B Testing, Live Notifications, PPP, and more.
255 | |
256 | iPhone, iPad, Mac, Vision |
257 |
258 |
259 |
260 |
261 | 
262 |
263 | |
264 |
265 |
266 | Pleydia Organizer: Movie & Series Renamer
267 |
268 |
269 | Simple, fast, and smart media management for your Movie, TV Show and Anime collection.
270 | |
271 | Mac |
272 |
273 |
274 |
275 |
276 | 
277 |
278 | |
279 |
280 |
281 | FreelanceKit: Project Time Tracking
282 |
283 |
284 | Simple & affordable time tracking with a native experience for all devices. iCloud sync & CSV export included.
285 | |
286 | iPhone, iPad, Mac, Vision |
287 |
288 |
289 |
290 |
291 | 
292 |
293 | |
294 |
295 |
296 | CrossCraft: Custom Crosswords
297 |
298 |
299 | Create themed & personalized crosswords. Solve them yourself or share them to challenge others.
300 | |
301 | iPhone, iPad, Mac, Vision |
302 |
303 |
304 |
305 |
306 | 
307 |
308 | |
309 |
310 |
311 | FocusBeats: Pomodoro + Music
312 |
313 |
314 | Deep Focus with proven Pomodoro method & select Apple Music playlists & themes. Automatically pauses music during breaks.
315 | |
316 | iPhone, iPad, Mac, Vision |
317 |
318 |
319 |
320 |
321 | 
322 |
323 | |
324 |
325 |
326 | Posters: Discover Movies at Home
327 |
328 |
329 | Auto-updating & interactive posters for your home with trailers, showtimes, and links to streaming services.
330 | |
331 | Vision |
332 |
333 |
334 |
--------------------------------------------------------------------------------
/Sources/ErrorKit/BuiltInErrors/DatabaseError.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | /// Represents errors that occur during database operations.
4 | ///
5 | /// # Examples of Use
6 | ///
7 | /// ## Handling Database Connections
8 | /// ```swift
9 | /// struct DatabaseConnection {
10 | /// func connect() throws(DatabaseError) {
11 | /// guard let socket = openNetworkSocket() else {
12 | /// throw .connectionFailed
13 | /// }
14 | /// // Successful connection logic
15 | /// }
16 | /// }
17 | /// ```
18 | ///
19 | /// ## Managing Record Operations
20 | /// ```swift
21 | /// struct UserRepository {
22 | /// func findUser(byId id: String) throws(DatabaseError) -> User {
23 | /// guard let user = database.findUser(id: id) else {
24 | /// throw .recordNotFound(entity: "User", identifier: id)
25 | /// }
26 | /// return user
27 | /// }
28 | ///
29 | /// func updateUser(_ user: User) throws(DatabaseError) {
30 | /// guard hasValidPermissions(for: user) else {
31 | /// throw .operationFailed(context: "Updating user profile")
32 | /// }
33 | /// // Update logic
34 | /// }
35 | /// }
36 | /// ```
37 | public enum DatabaseError: Throwable, Catching {
38 | /// The database connection failed.
39 | ///
40 | /// # Example
41 | /// ```swift
42 | /// struct AuthenticationService {
43 | /// func authenticate() throws(DatabaseError) {
44 | /// guard let connection = attemptDatabaseConnection() else {
45 | /// throw .connectionFailed
46 | /// }
47 | /// // Proceed with authentication
48 | /// }
49 | /// }
50 | /// ```
51 | case connectionFailed
52 |
53 | /// The database query failed to execute.
54 | ///
55 | /// # Example
56 | /// ```swift
57 | /// struct AnalyticsRepository {
58 | /// func generateReport(for period: DateInterval) throws(DatabaseError) -> Report {
59 | /// guard period.duration <= maximumReportPeriod else {
60 | /// throw .operationFailed(context: "Generating analytics report")
61 | /// }
62 | /// // Report generation logic
63 | /// }
64 | /// }
65 | /// ```
66 | /// - Parameters:
67 | /// - context: A description of the operation or entity being queried.
68 | case operationFailed(context: String)
69 |
70 | /// A requested record was not found in the database.
71 | ///
72 | /// # Example
73 | /// ```swift
74 | /// struct ProductInventory {
75 | /// func fetchProduct(sku: String) throws(DatabaseError) -> Product {
76 | /// guard let product = database.findProduct(bySKU: sku) else {
77 | /// throw .recordNotFound(entity: "Product", identifier: sku)
78 | /// }
79 | /// return product
80 | /// }
81 | /// }
82 | /// ```
83 | /// - Parameters:
84 | /// - entity: The name of the entity or record type.
85 | /// - identifier: A unique identifier for the missing entity.
86 | case recordNotFound(entity: String, identifier: String?)
87 |
88 | /// Generic error message if the existing cases don't provide the required details.
89 | ///
90 | /// # Example
91 | /// ```swift
92 | /// struct DataMigrationService {
93 | /// func migrate() throws(DatabaseError) {
94 | /// guard canPerformMigration() else {
95 | /// throw .generic(userFriendlyMessage: "Migration cannot be performed")
96 | /// }
97 | /// // Migration logic
98 | /// }
99 | /// }
100 | /// ```
101 | case generic(userFriendlyMessage: String)
102 |
103 | /// Represents a child error (either from your own error types or unknown system errors) that was wrapped into this error type.
104 | /// This case is used internally by the ``catch(_:)`` function to store any errors thrown by the wrapped code.
105 | ///
106 | /// # Example
107 | /// ```swift
108 | /// struct UserRepository {
109 | /// func fetchUserDetails(id: String) throws(DatabaseError) {
110 | /// // Check if user exists - simple case with explicit error
111 | /// guard let user = database.findUser(id: id) else {
112 | /// throw DatabaseError.recordNotFound(entity: "User", identifier: id)
113 | /// }
114 | ///
115 | /// // Any errors from parsing or file access are automatically wrapped
116 | /// let preferences = try DatabaseError.catch {
117 | /// let prefsData = try fileManager.contents(ofFile: user.preferencesPath)
118 | /// return try JSONDecoder().decode(UserPreferences.self, from: prefsData)
119 | /// }
120 | ///
121 | /// // Use the loaded preferences
122 | /// user.applyPreferences(preferences)
123 | /// }
124 | /// }
125 | /// ```
126 | ///
127 | /// The `caught` case stores the original error while maintaining type safety through typed throws.
128 | /// Instead of manually catching and wrapping unknown errors, use the ``catch(_:)`` function
129 | /// which automatically wraps any thrown errors into this case.
130 | ///
131 | /// - Parameters:
132 | /// - error: The original error that was wrapped into this error type.
133 | case caught(Error)
134 |
135 | /// A user-friendly error message suitable for display to end users.
136 | public var userFriendlyMessage: String {
137 | switch self {
138 | case .connectionFailed:
139 | return String.localized(
140 | key: "BuiltInErrors.DatabaseError.connectionFailed",
141 | defaultValue: "Unable to establish a connection to the database. Check your network settings and try again."
142 | )
143 | case .operationFailed(let context):
144 | return String.localized(
145 | key: "BuiltInErrors.DatabaseError.operationFailed",
146 | defaultValue: "The database operation for \(context) could not be completed. Please retry the action."
147 | )
148 | case .recordNotFound(let entity, let identifier):
149 | if let identifier {
150 | return String.localized(
151 | key: "BuiltInErrors.DatabaseError.recordNotFoundWithID",
152 | defaultValue: "The \(entity) record with ID \(identifier) was not found in the database. Verify the details and try again."
153 | )
154 | } else {
155 | return String.localized(
156 | key: "BuiltInErrors.DatabaseError.recordNotFound",
157 | defaultValue: "The \(entity) record was not found in the database. Verify the details and try again."
158 | )
159 | }
160 | case .generic(let userFriendlyMessage):
161 | return userFriendlyMessage
162 | case .caught(let error):
163 | return ErrorKit.userFriendlyMessage(for: error)
164 | }
165 | }
166 | }
167 |
--------------------------------------------------------------------------------
/Sources/ErrorKit/BuiltInErrors/FileError.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | /// Represents errors that occur during file operations.
4 | ///
5 | /// # Examples of Use
6 | ///
7 | /// ## Handling File Retrieval
8 | /// ```swift
9 | /// struct DocumentManager {
10 | /// func loadDocument(named name: String) throws(FileError) -> Document {
11 | /// guard let fileURL = findFile(named: name) else {
12 | /// throw .fileNotFound(fileName: name)
13 | /// }
14 | /// // Document loading logic
15 | /// }
16 | /// }
17 | /// ```
18 | ///
19 | /// ## Managing File Operations
20 | /// ```swift
21 | /// struct FileProcessor {
22 | /// func processFile(at path: String) throws(FileError) {
23 | /// guard canWrite(to: path) else {
24 | /// throw .writeFailed(fileName: path)
25 | /// }
26 | /// // File processing logic
27 | /// }
28 | ///
29 | /// func readConfiguration() throws(FileError) -> Configuration {
30 | /// guard let data = attemptFileRead() else {
31 | /// throw .readFailed(fileName: "config.json")
32 | /// }
33 | /// // Configuration parsing logic
34 | /// }
35 | /// }
36 | /// ```
37 | public enum FileError: Throwable, Catching {
38 | /// The file could not be found.
39 | ///
40 | /// # Example
41 | /// ```swift
42 | /// struct AssetManager {
43 | /// func loadImage(named name: String) throws(FileError) -> Image {
44 | /// guard let imagePath = searchForImage(name) else {
45 | /// throw .fileNotFound(fileName: name)
46 | /// }
47 | /// // Image loading logic
48 | /// }
49 | /// }
50 | /// ```
51 | case fileNotFound(fileName: String)
52 |
53 | /// There was an issue reading the file.
54 | ///
55 | /// # Example
56 | /// ```swift
57 | /// struct LogReader {
58 | /// func readLatestLog() throws(FileError) -> String {
59 | /// guard let logContents = attemptFileRead() else {
60 | /// throw .readFailed(fileName: "application.log")
61 | /// }
62 | /// return logContents
63 | /// }
64 | /// }
65 | /// ```
66 | case readFailed(fileName: String)
67 |
68 | /// There was an issue writing to the file.
69 | ///
70 | /// # Example
71 | /// ```swift
72 | /// struct DataBackup {
73 | /// func backup(data: Data) throws(FileError) {
74 | /// guard canWriteToBackupLocation() else {
75 | /// throw .writeFailed(fileName: "backup.dat")
76 | /// }
77 | /// // Backup writing logic
78 | /// }
79 | /// }
80 | /// ```
81 | case writeFailed(fileName: String)
82 |
83 | /// Generic error message if the existing cases don't provide the required details.
84 | ///
85 | /// # Example
86 | /// ```swift
87 | /// struct FileIntegrityChecker {
88 | /// func validateFile() throws(FileError) {
89 | /// guard passes(integrityCheck) else {
90 | /// throw .generic(userFriendlyMessage: "File integrity compromised")
91 | /// }
92 | /// // Validation logic
93 | /// }
94 | /// }
95 | /// ```
96 | case generic(userFriendlyMessage: String)
97 |
98 | /// An error that occurred during a file operation, wrapped into this error type using the ``catch(_:)`` function.
99 | /// This could include system-level file errors, encoding/decoding errors, or any other errors encountered during file operations.
100 | ///
101 | /// # Example
102 | /// ```swift
103 | /// struct DocumentStorage {
104 | /// func saveDocument(_ document: Document) throws(FileError) {
105 | /// // Regular error for missing file
106 | /// guard fileExists(document.path) else {
107 | /// throw FileError.fileNotFound(fileName: document.name)
108 | /// }
109 | ///
110 | /// // Automatically wrap encoding and file system errors
111 | /// try FileError.catch {
112 | /// let data = try JSONEncoder().encode(document)
113 | /// try data.write(to: document.url, options: .atomic)
114 | /// }
115 | /// }
116 | /// }
117 | /// ```
118 | ///
119 | /// The `caught` case stores the original error while maintaining type safety through typed throws.
120 | /// Instead of manually catching and wrapping system errors, use the ``catch(_:)`` function
121 | /// which automatically wraps any thrown errors into this case.
122 | ///
123 | /// - Parameters:
124 | /// - error: The original error that occurred during the file operation.
125 | case caught(Error)
126 |
127 | /// A user-friendly error message suitable for display to end users.
128 | public var userFriendlyMessage: String {
129 | switch self {
130 | case .fileNotFound(let fileName):
131 | return String.localized(
132 | key: "BuiltInErrors.FileError.fileNotFound",
133 | defaultValue: "The file \(fileName) could not be located. Please verify the file path and try again."
134 | )
135 | case .readFailed(let fileName):
136 | return String.localized(
137 | key: "BuiltInErrors.FileError.readError",
138 | defaultValue: "An error occurred while attempting to read the file \(fileName). Please check file permissions and try again."
139 | )
140 | case .writeFailed(let fileName):
141 | return String.localized(
142 | key: "BuiltInErrors.FileError.writeError",
143 | defaultValue: "Unable to write to the file \(fileName). Ensure you have the necessary permissions and try again."
144 | )
145 | case .generic(let userFriendlyMessage):
146 | return userFriendlyMessage
147 | case .caught(let error):
148 | return ErrorKit.userFriendlyMessage(for: error)
149 | }
150 | }
151 | }
152 |
--------------------------------------------------------------------------------
/Sources/ErrorKit/BuiltInErrors/GenericError.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | /// Represents a generic error with a custom user-friendly message.
4 | /// Use this when the built-in error types don't match your specific error case
5 | /// or when you need a simple way to throw custom error messages.
6 | ///
7 | /// # Examples of Use
8 | ///
9 | /// ## Custom Business Logic Validation
10 | /// ```swift
11 | /// struct BusinessRuleValidator {
12 | /// func validateComplexRule(data: BusinessData) throws(GenericError) {
13 | /// guard meetsCustomCriteria(data) else {
14 | /// throw GenericError(
15 | /// userFriendlyMessage: String(localized: "The business data doesn't meet required criteria")
16 | /// )
17 | /// }
18 | ///
19 | /// // Automatically wrap any other errors if needed
20 | /// try GenericError.catch {
21 | /// try validateAdditionalRules(data)
22 | /// }
23 | /// }
24 | /// }
25 | /// ```
26 | ///
27 | /// ## Application-Specific Errors
28 | /// ```swift
29 | /// struct CustomProcessor {
30 | /// func processSpecialCase() throws(GenericError) {
31 | /// guard canHandleSpecialCase() else {
32 | /// throw GenericError(
33 | /// userFriendlyMessage: String(localized: "Unable to process this special case")
34 | /// )
35 | /// }
36 | /// // Special case handling
37 | /// }
38 | /// }
39 | /// ```
40 | public struct GenericError: Throwable, Catching {
41 | /// A user-friendly message describing the error.
42 | public let userFriendlyMessage: String
43 |
44 | /// Creates a new generic error with a custom user-friendly message.
45 | ///
46 | /// # Example
47 | /// ```swift
48 | /// struct CustomValidator {
49 | /// func validateSpecialRequirement() throws(GenericError) {
50 | /// guard meetsRequirement() else {
51 | /// throw GenericError(
52 | /// userFriendlyMessage: String(localized: "The requirement was not met. Please try again.")
53 | /// )
54 | /// }
55 | /// // Validation logic
56 | /// }
57 | /// }
58 | /// ```
59 | /// - Parameter userFriendlyMessage: A clear, actionable message that will be shown to the user.
60 | public init(userFriendlyMessage: String) {
61 | self.userFriendlyMessage = userFriendlyMessage
62 | }
63 |
64 | /// Creates a new generic error that wraps another error.
65 | /// Used internally by the ``catch(_:)`` function to automatically wrap any thrown errors.
66 | ///
67 | /// # Example
68 | /// ```swift
69 | /// struct FileProcessor {
70 | /// func processUserData() throws(GenericError) {
71 | /// // Explicit throwing for validation
72 | /// guard isValidPath(userDataPath) else {
73 | /// throw GenericError(userFriendlyMessage: "Invalid file path selected")
74 | /// }
75 | ///
76 | /// // Automatically wrap any file system or JSON errors
77 | /// let userData = try GenericError.catch {
78 | /// let data = try Data(contentsOf: userDataPath)
79 | /// return try JSONDecoder().decode(UserData.self, from: data)
80 | /// }
81 | /// }
82 | /// }
83 | /// ```
84 | ///
85 | /// - Parameter error: The error to be wrapped.
86 | public static func caught(_ error: Error) -> Self {
87 | GenericError(userFriendlyMessage: ErrorKit.userFriendlyMessage(for: error))
88 | }
89 | }
90 |
--------------------------------------------------------------------------------
/Sources/ErrorKit/BuiltInErrors/NetworkError.swift:
--------------------------------------------------------------------------------
1 | import Foundation
2 |
3 | /// Represents errors that can occur during network operations.
4 | ///
5 | /// # Examples of Use
6 | ///
7 | /// ## Handling Network Connectivity
8 | /// ```swift
9 | /// struct NetworkService {
10 | /// func fetchData() throws(NetworkError) -> Data {
11 | /// guard isNetworkReachable() else {
12 | /// throw .noInternet
13 | /// }
14 | /// // Network request logic
15 | /// }
16 | /// }
17 | /// ```
18 | ///
19 | /// ## Managing API Requests
20 | /// ```swift
21 | /// struct APIClient {
22 | /// func makeRequest