Merge pull request #1 from TUTORVUE-GROUP-LTD/master

Fix image parser

Author: YevheniiHutorovBoosta

Examples/README.md

@@ -12,16 +12,16 @@ The UI-Kit of the example project in Figma:
 
 ### Example iOS project
 
-There are 2 example iOS projects in `Example` and `ExampleSwiftUI` directories which demostrates how to use figma-export with UIKit and SwiftUI.
+There are 2 example iOS projects in `Example` and `ExampleSwiftUI` directories which demonstrates how to use figma-export with UIKit and SwiftUI.
 
 <img src="../images/figma.png" />
 
 **How to setup iOS project**
 1. Open `Example/fastlane/.env` file.
 2. Change FIGMA_PERSONAL_TOKEN to your personal Figma token.
 3. Go to `Example` folder.
-4. Run the following command in Termanal to install cocoapods and fastlane: `bundle install`
-5. Run the following command in Termanal to install figma-export: `bundle exec pod install`
+4. Run the following command in Terminal to install CocoaPods and Fastlane: `bundle install`
+5. Run the following command in Terminal to install figma-export: `bundle exec pod install`
 
 **How to export resources from figma**
 * To export colors run: `bundle exec fastlane export_colors`
@@ -39,7 +39,7 @@ There is an example Android Studio project in `AndroidExample` directory which d
 
 ### Example Android Jetpack Compose project
 
-There is an example Android Studio project in `AndroidComposeExample` directory which demostrates how to use `figma-export` configured for Jetpack Compose.
+There is an example Android Studio project in `AndroidComposeExample` directory which demonstrates how to use `figma-export` configured for Jetpack Compose.
 
 You can find the generated code for compose in the package `com.redmadrobot.androidcomposeexample.ui.figmaexport`
 

FigmaExport.podspec

@@ -1,12 +1,12 @@
 Pod::Spec.new do |spec|
     spec.name           = "FigmaExport"
-    spec.version        = "0.38.2"
+    spec.version        = "0.38.4"
     spec.summary        = "Command line utility to export colors, typography, icons and images from Figma to Xcode / Android Studio project."
     spec.homepage       = "https://github.com/RedMadRobot/figma-export"  
     spec.license        = { type: "MIT", file: "LICENSE" }
     spec.author         = { "Daniil Subbotin" => "mail@subdan.ru" }
     spec.source         = { http: "#{spec.homepage}/releases/download/#{spec.version}/figma-export.zip" }
     spec.preserve_paths = '*'
     spec.platform       = :ios
-    spec.ios.deployment_target  = '15.0'
+    spec.ios.deployment_target  = '15.2'
 end

Package.swift

@@ -41,7 +41,10 @@ let package = Package(
         .target(name: "FigmaExportCore"),
 
         // Loads data via Figma REST API
-        .target(name: "FigmaAPI"),
+        .target(
+            name: "FigmaAPI",
+            dependencies: [.product(name: "Logging", package: "swift-log")]
+        ),
 
         // Exports resources to Xcode project
         .target(
@@ -84,6 +87,10 @@ let package = Package(
         .testTarget(
             name: "AndroidExportTests",
             dependencies: ["AndroidExport", .product(name: "CustomDump", package: "swift-custom-dump")]
+        ),
+        .testTarget(
+            name: "FigmaAPITests",
+            dependencies: ["FigmaAPI"]
         )
     ]
 )

README.md

@@ -85,7 +85,6 @@ Additionally, the following Swift file will be created to use colors from the co
     static var backgroundVideo: UIColor { return UIColor(named: #function)! }
     ...
  }
-
 ```
 
 For SwiftUI the following Swift file will be created to use colors from the code.
@@ -99,7 +98,6 @@ For SwiftUI the following Swift file will be created to use colors from the code
     static var backgroundVideo: Color { return Color(#function) }
     ...
  }
-
 ```
 
 If you set option `useColorAssets: False` in the configuration file, then will be generated code like this:
@@ -221,6 +219,7 @@ Example of these files:
 
 Colors will be exported to `values/colors.xml` and `values-night/colors.xml` files.
 For Jetpack Compose, following code will be generated, if configured:
+
 ```kotlin
 package com.redmadrobot.androidcomposeexample.ui.figmaexport
 
@@ -234,6 +233,7 @@ fun Colors.backgroundPrimary(): Color = colorResource(id = R.color.background_pr
 ```
 
 Icons will be exported to `drawable` directory as vector xml files. For Jetpack Compose, following code will be generated, if configured:
+
 ```kotlin
 package com.redmadrobot.androidcomposeexample.ui.figmaexport
 
@@ -260,6 +260,7 @@ Vector images will be exported to `drawable` and `drawable-night` directories as
 Raster images will be exported to `drawable-???dpi` and `drawable-night-???dpi` directories as `png` or `webp` files.
 
 Typography will be exported to `values/typography.xml`. For Jetpack Compose, following code will be generated, if configured:
+
 ```kotlin
 package com.redmadrobot.androidcomposeexample.ui.figmaexport
 
@@ -290,16 +291,20 @@ object Typography {
 [Download](https://github.com/RedMadRobot/figma-export/releases) the latest release and read [Usage](#usage)
 
 ### Homebrew
-```
+
+```bash
 brew install RedMadRobot/formulae/figma-export
 ```
+
 If you want to export raster images in WebP format install [cwebp](https://developers.google.com/speed/webp/docs/using) command line utility.
-```
+
+```bash
 brew install webp
 ```
 
 ### CocoaPods + Fastlane
 Add the following line to your Podfile:
+
 ```ruby
 pod 'FigmaExport'
 ```
@@ -308,6 +313,7 @@ This will download the FigmaExport binaries and dependencies in `Pods/` during y
 `pod install` execution and will allow you to invoke it via `Pods/FigmaExport/Release/figma-export` in your Fastfile.
 
 Add the following line to your Fastfile:
+
 ```ruby
 lane :sync_colors do
   Dir.chdir("../") do
@@ -321,6 +327,7 @@ Don't forget to place figma-export.yaml file at the root of the project director
 Run `fastlane sync_colors` to run FigmaExport.
 
 ## Usage
+
 1. Open `Terminal.app`
 2. Go (cd) to the folder with `figma-export` binary file
 3. Run `figma-export`
@@ -413,7 +420,8 @@ Example of `figma-export.yaml` file for iOS project — [Examples/Example/figma-
 Example of `figma-export.yaml` file for Android project — [Examples/AndroidExample/figma-export.yaml](./Examples/AndroidExample/figma-export.yaml)
 
 Generate `figma-export.yaml` config file using one of the following command:
-```
+
+```bash
 figma-export init --platform android
 figma-export init --platform ios
 ```

Sources/FigmaAPI/Client.swift

@@ -1,62 +1,135 @@
 import Foundation
+import Logging
 #if os(Linux)
 import FoundationNetworking
 #endif
 
 public typealias APIResult<Value> = Swift.Result<Value, Error>
 
 public protocol Client {
-    
+
     func request<T>(_ endpoint: T) throws -> T.Content where T: Endpoint
-    
+
     func request<T>(
         _ endpoint: T,
         completion: @escaping (APIResult<T.Content>) -> Void ) -> URLSessionTask where T: Endpoint
+
+    func requestWithRetry<T>(
+        _ endpoint: T,
+        configuration: RetryConfiguration
+    ) throws -> T.Content where T: Endpoint
 }
 
 public class BaseClient: Client {
-    
+
     private let baseURL: URL
-    
     private let session: URLSession
-    
+    private let logger = Logger(label: "FigmaAPI.Client")
+
     public init(baseURL: URL, config: URLSessionConfiguration) {
         self.baseURL = baseURL
         session = URLSession(configuration: config, delegate: nil, delegateQueue: .main)
     }
-    
+
     public func request<T>(_ endpoint: T) throws -> T.Content where T: Endpoint {
         var outResult: APIResult<T.Content>!
-        
+
         let task = request(endpoint, completion: { result in
             outResult = result
         })
         task.wait()
 
         return try outResult.get()
     }
-    
+
     public func request<T>(
         _ endpoint: T,
         completion: @escaping (APIResult<T.Content>) -> Void ) -> URLSessionTask where T: Endpoint {
-        
+
         let request = endpoint.makeRequest(baseURL: baseURL)
         let task = session.dataTask(with: request) { (data: Data?, response: URLResponse?, error: Error?) in
-            
+
+            // Handle network errors including timeout
+            if let urlError = error as? URLError, urlError.code == .timedOut {
+                completion(.failure(RateLimitError.timeout))
+                return
+            }
+
             guard let data = data, error == nil else {
                 completion(.failure(error!))
                 return
             }
+
+            // Check for HTTP 429 rate limiting
+            if let httpResponse = response as? HTTPURLResponse, httpResponse.isRateLimited {
+                let retryAfter = httpResponse.extractRetryAfter()
+                completion(.failure(RateLimitError.rateLimited(retryAfter: retryAfter)))
+                return
+            }
+
             let content = APIResult<T.Content>(catching: { () -> T.Content in
                 return try endpoint.content(from: response, with: data)
             })
-            
+
             completion(content)
         }
         task.resume()
         return task
     }
 
+    public func requestWithRetry<T>(
+        _ endpoint: T,
+        configuration: RetryConfiguration = .default
+    ) throws -> T.Content where T: Endpoint {
+
+        var lastError: Error?
+        var currentBackoff = configuration.initialBackoffSeconds
+
+        for attempt in 0..<configuration.maxRetries {
+            do {
+                let result = try request(endpoint)
+                // Delay after successful request to prevent hitting rate limits on subsequent calls
+                if configuration.requestDelaySeconds > 0 {
+                    logger.info("Throttling: waiting \(String(format: "%.1f", configuration.requestDelaySeconds))s before next request")
+                    sleep(forTimeInterval: configuration.requestDelaySeconds)
+                }
+                return result
+            } catch let error as RateLimitError {
+                switch error {
+                case .rateLimited(let retryAfter):
+                    // Exit immediately if retry-after exceeds max allowed wait time
+                    if retryAfter > configuration.maxRetryAfterSeconds {
+                        throw RateLimitError.rateLimitExceeded(retryAfter: retryAfter)
+                    }
+
+                    logger.warning("Rate limited by Figma API. Waiting \(Int(retryAfter))s before retry \(attempt + 1)/\(configuration.maxRetries)")
+                    sleep(forTimeInterval: retryAfter)
+                    lastError = error
+
+                case .timeout:
+                    // Exponential backoff for timeout
+                    logger.warning("Request timed out. Waiting \(Int(currentBackoff))s before retry \(attempt + 1)/\(configuration.maxRetries)")
+                    sleep(forTimeInterval: currentBackoff)
+                    currentBackoff *= configuration.backoffMultiplier
+                    lastError = error
+
+                case .rateLimitExceeded:
+                    // Do not retry, exit immediately
+                    throw error
+                }
+            } catch {
+                // Other errors: do not retry
+                throw error
+            }
+        }
+
+        // All retries exhausted
+        if let lastError = lastError {
+            throw lastError
+        }
+        throw RateLimitError.timeout
+    }
+
 }
 
 private extension URLSessionTask {
@@ -71,3 +144,20 @@ private extension URLSessionTask {
     }
 
 }
+
+/// Sleeps for the specified interval while keeping the RunLoop responsive.
+/// Uses RunLoop when possible to process pending callbacks, with Thread.sleep
+/// fallback when RunLoop has no active sources (prevents immediate return).
+/// On Linux, uses Thread.sleep directly as RunLoop behavior differs.
+private func sleep(forTimeInterval interval: TimeInterval) {
+    #if os(Linux)
+    Thread.sleep(forTimeInterval: interval)
+    #else
+    let limitDate = Date(timeIntervalSinceNow: interval)
+    while Date() < limitDate {
+        if !RunLoop.current.run(mode: .default, before: limitDate) {
+            Thread.sleep(forTimeInterval: 0.1)
+        }
+    }
+    #endif
+}

Sources/FigmaAPI/FigmaClient.swift

@@ -1,17 +1,43 @@
+// ABOUTME: FigmaClient is the main API client for Figma REST API
+// ABOUTME: Supports automatic retry with exponential backoff for rate limiting
+
 import Foundation
 #if os(Linux)
 import FoundationNetworking
 #endif
 
 final public class FigmaClient: BaseClient {
-    
+
     private let baseURL = URL(string: "https://api.figma.com/v1/")!
-    
-    public init(accessToken: String, timeout: TimeInterval?) {
+    private let retryConfiguration: RetryConfiguration
+
+    public init(
+        accessToken: String,
+        timeout: TimeInterval?,
+        retryConfiguration: RetryConfiguration = .default,
+        requestDelay: TimeInterval? = nil
+    ) {
+        // If requestDelay is explicitly provided, override the configuration value
+        if let requestDelay = requestDelay {
+            self.retryConfiguration = RetryConfiguration(
+                maxRetries: retryConfiguration.maxRetries,
+                maxRetryAfterSeconds: retryConfiguration.maxRetryAfterSeconds,
+                initialBackoffSeconds: retryConfiguration.initialBackoffSeconds,
+                backoffMultiplier: retryConfiguration.backoffMultiplier,
+                requestDelaySeconds: requestDelay
+            )
+        } else {
+            self.retryConfiguration = retryConfiguration
+        }
         let config = URLSessionConfiguration.ephemeral
         config.httpAdditionalHeaders = ["X-Figma-Token": accessToken]
         config.timeoutIntervalForRequest = timeout ?? 30
         super.init(baseURL: baseURL, config: config)
     }
 
+    /// Convenience method that uses the client's default retry configuration
+    public func requestWithRetry<T>(_ endpoint: T) throws -> T.Content where T: Endpoint {
+        return try requestWithRetry(endpoint, configuration: retryConfiguration)
+    }
+
 }