@granite-js/image 0.1.34 → 1.0.1

package/ios/GraniteImageModule.swift

@@ -0,0 +1,107 @@
+import Foundation
+import React
+
+@objc(GraniteImageModule)
+class GraniteImageModule: NSObject {
+
+    @objc static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    @objc func preload(_ sourcesJson: String,
+                       resolve: @escaping RCTPromiseResolveBlock,
+                       reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[GraniteImageModule] preload called with: \(sourcesJson)")
+
+        guard let jsonData = sourcesJson.data(using: .utf8),
+              let sources = try? JSONSerialization.jsonObject(with: jsonData) as? [[String: Any]] else {
+            reject("PARSE_ERROR", "Failed to parse sources JSON", nil)
+            return
+        }
+
+        guard let provider = GraniteImageRegistry.shared.provider else {
+            reject("NO_PROVIDER", "No provider registered, cannot preload", nil)
+            return
+        }
+
+        DispatchQueue.global(qos: .default).async {
+            let group = DispatchGroup()
+            var successCount = 0
+            var failCount = 0
+            let countLock = NSLock()
+
+            for source in sources {
+                guard let uri = source["uri"] as? String else { continue }
+
+                let headers = source["headers"] as? [String: String]
+                let priorityStr = source["priority"] as? String
+                let cacheStr = source["cache"] as? String
+
+                var priority: GraniteProviderPriority = .normal
+                if priorityStr == "high" {
+                    priority = .high
+                } else if priorityStr == "low" {
+                    priority = .low
+                }
+
+                var cachePolicy: GraniteProviderCachePolicy = .disk
+                if cacheStr == "cacheOnly" {
+                    cachePolicy = .disk
+                } else if cacheStr == "web" {
+                    cachePolicy = .none
+                }
+
+                NSLog("[GraniteImageModule] Preloading: \(uri)")
+
+                // Use extended loading if available
+                group.enter()
+                if let loadImageExtended = provider.loadImage(withURL:into:contentMode:headers:priority:cachePolicy:defaultSource:progress:completion:) {
+                    loadImageExtended(
+                        uri,
+                        nil,
+                        .scaleAspectFill,
+                        headers,
+                        priority,
+                        cachePolicy,
+                        nil,
+                        nil,
+                        { image, error, imageSize in
+                            countLock.lock()
+                            if image != nil {
+                                NSLog("[GraniteImageModule] Preloaded successfully: \(uri) (\(Int(imageSize.width))x\(Int(imageSize.height)))")
+                                successCount += 1
+                            } else {
+                                NSLog("[GraniteImageModule] Preload failed for \(uri): \(error?.localizedDescription ?? "Unknown error")")
+                                failCount += 1
+                            }
+                            countLock.unlock()
+                            group.leave()
+                        }
+                    )
+                } else {
+                    NSLog("[GraniteImageModule] Provider does not support preloading without view")
+                    group.leave()
+                }
+            }
+
+            group.notify(queue: .main) {
+                NSLog("[GraniteImageModule] Preload completed: \(successCount) succeeded, \(failCount) failed")
+                resolve(nil)
+            }
+        }
+    }
+
+    @objc func clearMemoryCache(_ resolve: @escaping RCTPromiseResolveBlock,
+                                 reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[GraniteImageModule] clearMemoryCache called")
+        URLCache.shared.removeAllCachedResponses()
+        resolve(nil)
+    }
+
+    @objc func clearDiskCache(_ resolve: @escaping RCTPromiseResolveBlock,
+                               reject: @escaping RCTPromiseRejectBlock) {
+        NSLog("[GraniteImageModule] clearDiskCache called")
+        URLCache.shared.removeAllCachedResponses()
+        resolve(nil)
+    }
+}

package/ios/GraniteImageModuleBridge.m

@@ -0,0 +1,15 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(GraniteImageModule, NSObject)
+
+RCT_EXTERN_METHOD(preload:(NSString *)sourcesJson
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearMemoryCache:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(clearDiskCache:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/GraniteImageProvider.swift

@@ -0,0 +1,70 @@
+import UIKit
+
+/// Priority levels for image loading
+@objc public enum GraniteProviderPriority: Int {
+    case low = 0
+    case normal = 1
+    case high = 2
+}
+
+/// Cache policy for image loading
+@objc public enum GraniteProviderCachePolicy: Int {
+    case memory = 0
+    case disk = 1
+    case none = 2
+}
+
+/// Progress callback block
+public typealias GraniteImageProgressBlock = (_ loaded: Int64, _ total: Int64) -> Void
+
+/// Completion callback block
+public typealias GraniteImageCompletionBlock = (_ image: UIImage?, _ error: Error?, _ imageSize: CGSize) -> Void
+
+/// Protocol that defines the interface for image loading providers.
+/// Implementations can use any image loading library (URLSession, SDWebImage, Kingfisher, etc.)
+@objc public protocol GraniteImageProvidable: AnyObject {
+
+    /// Creates and returns a new UIView that will be used to display the image.
+    /// The returned view should be capable of displaying images (typically UIImageView).
+    @objc func createImageView() -> UIView
+
+    /// Loads an image from the given URL into the provided view.
+    /// - Parameters:
+    ///   - url: The URL string of the image to load
+    ///   - view: The view returned from createImageView where the image should be displayed
+    ///   - contentMode: The content mode to use when displaying the image
+    @objc func loadImage(withURL url: String, into view: UIView, contentMode: UIView.ContentMode)
+
+    /// Cancels any ongoing image load for the given view.
+    /// - Parameter view: The view whose image load should be cancelled
+    @objc func cancelLoad(with view: UIView)
+
+    /// Loads an image with full options support including headers, priority, cache policy, and callbacks.
+    /// - Parameters:
+    ///   - url: The URL string of the image to load
+    ///   - view: The view returned from createImageView where the image should be displayed (can be nil for preloading)
+    ///   - contentMode: The content mode to use when displaying the image
+    ///   - headers: Optional HTTP headers to include in the request
+    ///   - priority: The loading priority
+    ///   - cachePolicy: The cache policy to use
+    ///   - defaultSource: Optional placeholder image URL or asset name to show while loading
+    ///   - progress: Optional closure called with loading progress
+    ///   - completion: Optional closure called when loading completes
+    @objc optional func loadImage(
+        withURL url: String,
+        into view: UIView?,
+        contentMode: UIView.ContentMode,
+        headers: [String: String]?,
+        priority: GraniteProviderPriority,
+        cachePolicy: GraniteProviderCachePolicy,
+        defaultSource: String?,
+        progress: GraniteImageProgressBlock?,
+        completion: GraniteImageCompletionBlock?
+    )
+
+    /// Applies a tint color to the image view
+    /// - Parameters:
+    ///   - tintColor: The color to apply
+    ///   - view: The view to tint
+    @objc optional func applyTintColor(_ tintColor: UIColor, to view: UIView)
+}

package/ios/GraniteImageRegistry.swift

@@ -0,0 +1,30 @@
+import Foundation
+
+/// Singleton registry for managing the current GraniteImageProvidable.
+/// Applications should register their provider implementation at app startup.
+@objc public class GraniteImageRegistry: NSObject {
+
+    /// Shared singleton instance
+    @objc public static let shared = GraniteImageRegistry()
+
+    /// The currently registered image provider.
+    /// If nil, GraniteImage will display an error state.
+    @objc public var provider: GraniteImageProvidable?
+
+    private override init() {
+        super.init()
+    }
+
+    /// Registers an image provider to be used by all GraniteImage instances.
+    /// - Parameter provider: The provider implementation to register
+    @objc public func register(provider: GraniteImageProvidable) {
+        self.provider = provider
+        NSLog("[GraniteImageRegistry] Provider registered: \(type(of: provider))")
+    }
+
+    /// Clears the currently registered provider.
+    @objc public func clearProvider() {
+        self.provider = nil
+        NSLog("[GraniteImageRegistry] Provider cleared")
+    }
+}

package/ios/Providers/SDWebImageProvider.swift

@@ -0,0 +1,175 @@
+#if GRANITE_IMAGE_DEFAULT_PROVIDER
+
+import UIKit
+import SDWebImage
+
+@objc public class SDWebImageProvider: NSObject, GraniteImageProvidable {
+
+    @objc public func createImageView() -> UIView {
+        let imageView = UIImageView()
+        imageView.backgroundColor = .lightGray
+        return imageView
+    }
+
+    @objc public func loadImage(withURL url: String, into view: UIView, contentMode: UIView.ContentMode) {
+        guard let imageView = view as? UIImageView else {
+            NSLog("[SDWebImageProvider] View is not UIImageView")
+            return
+        }
+
+        imageView.contentMode = contentMode
+
+        guard let imageURL = URL(string: url) else {
+            NSLog("[SDWebImageProvider] Invalid URL: \(url)")
+            return
+        }
+
+        imageView.sd_setImage(
+            with: imageURL,
+            placeholderImage: nil,
+            options: .retryFailed
+        ) { _, error, cacheType, _ in
+            if let error = error {
+                NSLog("[SDWebImageProvider] Error loading image: \(error.localizedDescription)")
+            } else {
+                let cacheTypeStr: String
+                switch cacheType {
+                case .none: cacheTypeStr = "Network"
+                case .disk: cacheTypeStr = "Disk"
+                case .memory: cacheTypeStr = "Memory"
+                default: cacheTypeStr = "Unknown"
+                }
+                NSLog("[SDWebImageProvider] Loaded with SDWebImage (\(cacheTypeStr)): \(url)")
+            }
+        }
+    }
+
+    @objc public func cancelLoad(with view: UIView) {
+        guard let imageView = view as? UIImageView else { return }
+        imageView.sd_cancelCurrentImageLoad()
+    }
+
+    @objc public func loadImage(
+        withURL url: String,
+        into view: UIView?,
+        contentMode: UIView.ContentMode,
+        headers: [String: String]?,
+        priority: GraniteProviderPriority,
+        cachePolicy: GraniteProviderCachePolicy,
+        defaultSource: String?,
+        progress progressBlock: GraniteImageProgressBlock?,
+        completion completionBlock: GraniteImageCompletionBlock?
+    ) {
+        // Allow nil view for preloading
+        var imageView: UIImageView? = nil
+        if let view = view {
+            guard let iv = view as? UIImageView else {
+                NSLog("[SDWebImageProvider] View is not UIImageView")
+                completionBlock?(nil, NSError(domain: "SDWebImageProvider", code: -1, userInfo: [NSLocalizedDescriptionKey: "View is not UIImageView"]), .zero)
+                return
+            }
+            imageView = iv
+            imageView?.contentMode = contentMode
+        }
+
+        guard let imageURL = URL(string: url),
+              let scheme = imageURL.scheme?.lowercased(),
+              scheme == "http" || scheme == "https" else {
+            NSLog("[SDWebImageProvider] Invalid URL: \(url)")
+            completionBlock?(nil, NSError(domain: "SDWebImageProvider", code: -1, userInfo: [NSLocalizedDescriptionKey: "Invalid URL"]), .zero)
+            return
+        }
+
+        // Load placeholder image if provided
+        var placeholderImage: UIImage? = nil
+        if let defaultSource = defaultSource, !defaultSource.isEmpty {
+            placeholderImage = UIImage(named: defaultSource)
+        }
+
+        // Build options
+        var options: SDWebImageOptions = .retryFailed
+        switch priority {
+        case .low:
+            options.insert(.lowPriority)
+        case .high:
+            options.insert(.highPriority)
+        case .normal:
+            break
+        }
+
+        // Build context with headers
+        var context: [SDWebImageContextOption: Any]? = nil
+        if let headers = headers, !headers.isEmpty {
+            let modifier = SDWebImageDownloadRequestModifier { request in
+                var mutableRequest = request
+                for (key, value) in headers {
+                    mutableRequest.setValue(value, forHTTPHeaderField: key)
+                }
+                return mutableRequest
+            }
+            context = [.downloadRequestModifier: modifier]
+        }
+
+        if let imageView = imageView {
+            imageView.sd_setImage(
+                with: imageURL,
+                placeholderImage: placeholderImage,
+                options: options,
+                context: context,
+                progress: { receivedSize, expectedSize, _ in
+                    progressBlock?(Int64(receivedSize), Int64(expectedSize))
+                },
+                completed: { image, error, cacheType, _ in
+                    if let error = error {
+                        NSLog("[SDWebImageProvider] Error loading image: \(error.localizedDescription)")
+                        completionBlock?(nil, error, .zero)
+                    } else {
+                        let cacheTypeStr: String
+                        switch cacheType {
+                        case .none: cacheTypeStr = "Network"
+                        case .disk: cacheTypeStr = "Disk"
+                        case .memory: cacheTypeStr = "Memory"
+                        default: cacheTypeStr = "Unknown"
+                        }
+                        NSLog("[SDWebImageProvider] Loaded with SDWebImage (\(cacheTypeStr)): \(url)")
+                        completionBlock?(image, nil, image?.size ?? .zero)
+                    }
+                }
+            )
+        } else {
+            // Preload without view
+            SDWebImageManager.shared.loadImage(
+                with: imageURL,
+                options: options,
+                context: context,
+                progress: { receivedSize, expectedSize, _ in
+                    progressBlock?(Int64(receivedSize), Int64(expectedSize))
+                },
+                completed: { image, _, error, cacheType, _, _ in
+                    if let error = error {
+                        NSLog("[SDWebImageProvider] Error preloading image: \(error.localizedDescription)")
+                        completionBlock?(nil, error, .zero)
+                    } else {
+                        let cacheTypeStr: String
+                        switch cacheType {
+                        case .none: cacheTypeStr = "Network"
+                        case .disk: cacheTypeStr = "Disk"
+                        case .memory: cacheTypeStr = "Memory"
+                        default: cacheTypeStr = "Unknown"
+                        }
+                        NSLog("[SDWebImageProvider] Preloaded with SDWebImage (\(cacheTypeStr)): \(url)")
+                        completionBlock?(image, nil, image?.size ?? .zero)
+                    }
+                }
+            )
+        }
+    }
+
+    @objc public func applyTintColor(_ tintColor: UIColor, to view: UIView) {
+        guard let imageView = view as? UIImageView else { return }
+        imageView.image = imageView.image?.withRenderingMode(.alwaysTemplate)
+        imageView.tintColor = tintColor
+    }
+}
+
+#endif

package/package.json

@@ -1,53 +1,92 @@
 {
   "name": "@granite-js/image",
-  "version": "0.1.34",
+  "version": "1.0.1",
+  "description": "A pluggable React Native image component that lets you use your existing native image loading infrastructure",
+  "type": "module",
+  "main": "./dist/module/index.js",
+  "types": "./dist/typescript/index.d.ts",
+  "react-native": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/typescript/index.d.ts",
+      "react-native": "./src/index.ts",
+      "default": "./dist/module/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "src",
+    "dist",
+    "android",
+    "ios",
+    "*.podspec",
+    "react-native.config.js"
+  ],
   "scripts": {
     "prepack": "yarn build",
+    "example": "yarn workspace @granite-js/image-example",
+    "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
     "typecheck": "tsc --noEmit",
     "lint": "eslint .",
-    "build": "tsdown"
+    "build": "bob build && tsc --project tsconfig.build.json"
   },
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "keywords": [
+    "react-native",
+    "image",
+    "fast-image",
+    "ios",
+    "android",
+    "brownfield",
+    "kingfisher",
+    "glide",
+    "coil",
+    "sdwebimage"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toss/granite.git",
     "directory": "packages/image"
   },
-  "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      },
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      }
-    },
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist"
-  ],
+  "author": "Toss <platform@toss.im>",
+  "homepage": "https://github.com/toss/granite/tree/main/packages/image#readme",
+  "license": "MIT",
   "devDependencies": {
-    "@granite-js/native": "0.1.34",
-    "@types/react": "18.3.3",
+    "@types/react": "19.2.0",
+    "del-cli": "^6.0.0",
     "eslint": "^9.7.0",
-    "react": "18.2.0",
-    "react-native": "0.72.6",
-    "tsdown": "^0.16.5",
-    "typescript": "5.8.3"
+    "react": "19.2.3",
+    "react-native": "0.84.0-rc.5",
+    "react-native-builder-bob": "0.40.17",
+    "typescript": "5.9.3"
   },
   "peerDependencies": {
-    "@granite-js/native": "*",
-    "@types/react": "*",
     "react": "*",
     "react-native": "*"
   },
-  "dependencies": {
-    "react-simplikit": "^0.0.40"
+  "codegenConfig": {
+    "name": "GraniteImageSpec",
+    "type": "components",
+    "jsSrcsDir": "src",
+    "android": {
+      "javaPackageName": "com.facebook.react.viewmanagers"
+    },
+    "ios": {
+      "componentProvider": {
+        "GraniteImage": "GraniteImageComponentView"
+      }
+    }
   },
-  "sideEffects": false
+  "sideEffects": false,
+  "react-native-builder-bob": {
+    "source": "src",
+    "output": "dist",
+    "targets": [
+      [
+        "module",
+        {
+          "esm": true
+        }
+      ]
+    ]
+  }
 }