@amazon-devices/expo-image 2.0.1758683737

package/ios/Blurhash.swift

@@ -0,0 +1,326 @@
+// The blurhash algorithm was entirely created by Wolt Enterprises.
+// This implementation was inspired by:
+// - https://github.com/woltapp/blurhash/blob/master/Swift/BlurHashDecode.swift
+// - https://github.com/woltapp/blurhash/blob/master/Swift/BlurHashEncode.swift
+// See https://blurha.sh for more details about the blurhash.
+
+import UIKit
+
+// swiftlint:disable force_unwrapping
+
+internal func image(fromBlurhash blurhash: String, size: CGSize, punch: Float = 1.0) -> CGImage? {
+  guard blurhash.count >= 6 else {
+    return nil
+  }
+
+  let sizeFlag = decode83(String(blurhash[0]))
+  let numY = (sizeFlag / 9) + 1
+  let numX = (sizeFlag % 9) + 1
+
+  let quantisedMaximumValue = decode83(String(blurhash[1]))
+  let maximumValue = Float(quantisedMaximumValue + 1) / 166
+
+  guard blurhash.count == 4 + 2 * numX * numY else {
+    return nil
+  }
+
+  let colors: [(Float, Float, Float)] = (0 ..< numX * numY).map { i in
+    if i == 0 {
+      let value = decode83(String(blurhash[2 ..< 6]))
+      return decodeDC(value)
+    } else {
+      let value = decode83(String(blurhash[4 + i * 2 ..< 4 + i * 2 + 2]))
+      return decodeAC(value, maximumValue: maximumValue * punch)
+    }
+  }
+
+  let width = Int(size.width)
+  let height = Int(size.height)
+  let bytesPerRow = width * 3
+
+  guard let data = CFDataCreateMutable(kCFAllocatorDefault, bytesPerRow * height) else {
+    return nil
+  }
+
+  CFDataSetLength(data, bytesPerRow * height)
+
+  guard let pixels = CFDataGetMutableBytePtr(data) else {
+    return nil
+  }
+
+  for y in 0 ..< height {
+    for x in 0 ..< width {
+      var r: Float = 0
+      var g: Float = 0
+      var b: Float = 0
+
+      for j in 0 ..< numY {
+        for i in 0 ..< numX {
+          let basis = cos(Float.pi * Float(x) * Float(i) / Float(width)) * cos(Float.pi * Float(y) * Float(j) / Float(height))
+          let color = colors[i + j * numX]
+          r += color.0 * basis
+          g += color.1 * basis
+          b += color.2 * basis
+        }
+      }
+
+      let intR = UInt8(linearTosRGB(r))
+      let intG = UInt8(linearTosRGB(g))
+      let intB = UInt8(linearTosRGB(b))
+
+      pixels[3 * x + 0 + y * bytesPerRow] = intR
+      pixels[3 * x + 1 + y * bytesPerRow] = intG
+      pixels[3 * x + 2 + y * bytesPerRow] = intB
+    }
+  }
+
+  let bitmapInfo = CGBitmapInfo(rawValue: CGImageAlphaInfo.none.rawValue)
+
+  guard let provider = CGDataProvider(data: data), let cgImage = CGImage(
+    width: width,
+    height: height,
+    bitsPerComponent: 8,
+    bitsPerPixel: 24,
+    bytesPerRow: bytesPerRow,
+    space: CGColorSpaceCreateDeviceRGB(),
+    bitmapInfo: bitmapInfo,
+    provider: provider,
+    decode: nil,
+    shouldInterpolate: true,
+    intent: .defaultIntent
+  ) else {
+    return nil
+  }
+
+  return cgImage
+}
+
+internal func blurhash(fromImage image: UIImage, numberOfComponents components: (Int, Int)) -> String? {
+  let size = image.size
+  let scale = image.scale
+
+  let pixelWidth = Int(round(size.width * scale))
+  let pixelHeight = Int(round(size.height * scale))
+
+  let context = CGContext(
+    data: nil,
+    width: pixelWidth,
+    height: pixelHeight,
+    bitsPerComponent: 8,
+    bytesPerRow: pixelWidth * 4,
+    space: CGColorSpace(name: CGColorSpace.sRGB)!,
+    bitmapInfo: CGImageAlphaInfo.premultipliedLast.rawValue
+  )!
+  context.scaleBy(x: scale, y: -scale)
+  context.translateBy(x: 0, y: -size.height)
+
+  UIGraphicsPushContext(context)
+  image.draw(at: .zero)
+  UIGraphicsPopContext()
+
+  guard let cgImage = context.makeImage(),
+    let dataProvider = cgImage.dataProvider,
+    let data = dataProvider.data,
+    let pixels = CFDataGetBytePtr(data) else {
+    assertionFailure("Unexpected error!")
+    return nil
+  }
+
+  let width = cgImage.width
+  let height = cgImage.height
+  let bytesPerRow = cgImage.bytesPerRow
+
+  var factors: [(Float, Float, Float)] = []
+  for y in 0 ..< components.1 {
+    for x in 0 ..< components.0 {
+      let normalisation: Float = (x == 0 && y == 0) ? 1 : 2
+      let factor = multiplyBasisFunction(
+        pixels: pixels,
+        width: width,
+        height: height,
+        bytesPerRow: bytesPerRow,
+        bytesPerPixel: cgImage.bitsPerPixel / 8,
+        pixelOffset: 0
+      ) {
+        normalisation * cos(Float.pi * Float(x) * $0 / Float(width)) as Float * cos(Float.pi * Float(y) * $1 / Float(height)) as Float
+      }
+      factors.append(factor)
+    }
+  }
+
+  let dc = factors.first!
+  let ac = factors.dropFirst()
+
+  var hash = ""
+
+  let sizeFlag = (components.0 - 1) + (components.1 - 1) * 9
+  hash += encode83(sizeFlag, length: 1)
+
+  let maximumValue: Float
+  if !ac.isEmpty {
+    let actualMaximumValue = ac.map({ max(abs($0.0), abs($0.1), abs($0.2)) }).max()!
+    let quantisedMaximumValue = Int(max(0, min(82, floor(actualMaximumValue * 166 - 0.5))))
+    maximumValue = Float(quantisedMaximumValue + 1) / 166
+    hash += encode83(quantisedMaximumValue, length: 1)
+  } else {
+    maximumValue = 1
+    hash += encode83(0, length: 1)
+  }
+
+  hash += encode83(encodeDC(dc), length: 4)
+
+  for factor in ac {
+    hash += encode83(encodeAC(factor, maximumValue: maximumValue), length: 2)
+  }
+
+  return hash
+}
+
+internal func isBlurhash(_ str: String) -> Bool {
+  return str.allSatisfy { char in decodeCharacters[char] != nil }
+}
+
+// MARK: - Encode
+
+// swiftlint:disable:next function_parameter_count
+private func multiplyBasisFunction(
+  pixels: UnsafePointer<UInt8>,
+  width: Int,
+  height: Int,
+  bytesPerRow: Int,
+  bytesPerPixel: Int,
+  pixelOffset: Int,
+  basisFunction: (Float, Float) -> Float
+) -> (Float, Float, Float) {
+  var r: Float = 0
+  var g: Float = 0
+  var b: Float = 0
+
+  let buffer = UnsafeBufferPointer(start: pixels, count: height * bytesPerRow)
+
+  for x in 0 ..< width {
+    for y in 0 ..< height {
+      let basis = basisFunction(Float(x), Float(y))
+      r += basis * sRGBToLinear(buffer[bytesPerPixel * x + pixelOffset + 0 + y * bytesPerRow])
+      g += basis * sRGBToLinear(buffer[bytesPerPixel * x + pixelOffset + 1 + y * bytesPerRow])
+      b += basis * sRGBToLinear(buffer[bytesPerPixel * x + pixelOffset + 2 + y * bytesPerRow])
+    }
+  }
+
+  let scale = 1 / Float(width * height)
+
+  return (r * scale, g * scale, b * scale)
+}
+
+private let encodeCharacters: [Character] = Array("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz#$%*+,-.:;=?@[]^_{|}~")
+
+private func encodeDC(_ value: (Float, Float, Float)) -> Int {
+  let roundedR = linearTosRGB(value.0)
+  let roundedG = linearTosRGB(value.1)
+  let roundedB = linearTosRGB(value.2)
+  return (roundedR << 16) + (roundedG << 8) + roundedB
+}
+
+private func encodeAC(_ value: (Float, Float, Float), maximumValue: Float) -> Int {
+  let quantR = Int(max(0, min(18, floor(signPow(value.0 / maximumValue, 0.5) * 9 + 9.5))))
+  let quantG = Int(max(0, min(18, floor(signPow(value.1 / maximumValue, 0.5) * 9 + 9.5))))
+  let quantB = Int(max(0, min(18, floor(signPow(value.2 / maximumValue, 0.5) * 9 + 9.5))))
+
+  return quantR * 19 * 19 + quantG * 19 + quantB
+}
+
+private func encode83(_ value: Int, length: Int) -> String {
+  var result = ""
+  for i in 1 ... length {
+    let digit = (value / pow(83, length - i)) % 83
+    result += String(encodeCharacters[Int(digit)])
+  }
+  return result
+}
+
+// MARK: - Decode
+
+private func decodeDC(_ value: Int) -> (Float, Float, Float) {
+  let intR = value >> 16
+  let intG = (value >> 8) & 255
+  let intB = value & 255
+  return (sRGBToLinear(intR), sRGBToLinear(intG), sRGBToLinear(intB))
+}
+
+private func decodeAC(_ value: Int, maximumValue: Float) -> (Float, Float, Float) {
+  let quantR = value / (19 * 19)
+  let quantG = (value / 19) % 19
+  let quantB = value % 19
+
+  let rgb = (
+    signPow((Float(quantR) - 9) / 9, 2) * maximumValue,
+    signPow((Float(quantG) - 9) / 9, 2) * maximumValue,
+    signPow((Float(quantB) - 9) / 9, 2) * maximumValue
+  )
+
+  return rgb
+}
+
+private let decodeCharacters: [Character: Int] = {
+  var dict: [Character: Int] = [:]
+  for (index, character) in encodeCharacters.enumerated() {
+    dict[character] = index
+  }
+  return dict
+}()
+
+private func decode83(_ str: String) -> Int {
+  var value: Int = 0
+  for character in str {
+    if let digit = decodeCharacters[character] {
+      value = value * 83 + digit
+    }
+  }
+  return value
+}
+
+// MARK: - Helpers
+
+private func signPow(_ value: Float, _ exp: Float) -> Float {
+  return copysign(pow(abs(value), exp), value)
+}
+
+private func linearTosRGB(_ value: Float) -> Int {
+  let v = max(0, min(1, value))
+  if v <= 0.0031308 {
+    return Int(v * 12.92 * 255 + 0.5)
+  } else {
+    return Int((1.055 * pow(v, 1 / 2.4) - 0.055) * 255 + 0.5)
+  }
+}
+
+private func sRGBToLinear<Type: BinaryInteger>(_ value: Type) -> Float {
+  let v = Float(Int64(value)) / 255
+  if v <= 0.04045 {
+    return v / 12.92
+  } else {
+    return pow((v + 0.055) / 1.055, 2.4)
+  }
+}
+
+private func pow(_ base: Int, _ exponent: Int) -> Int {
+  return (0 ..< exponent).reduce(1) { value, _ in value * base }
+}
+
+private extension String {
+  subscript (offset: Int) -> Character {
+    return self[index(startIndex, offsetBy: offset)]
+  }
+
+  subscript (bounds: CountableClosedRange<Int>) -> Substring {
+    let start = index(startIndex, offsetBy: bounds.lowerBound)
+    let end = index(startIndex, offsetBy: bounds.upperBound)
+    return self[start...end]
+  }
+
+  subscript (bounds: CountableRange<Int>) -> Substring {
+    let start = index(startIndex, offsetBy: bounds.lowerBound)
+    let end = index(startIndex, offsetBy: bounds.upperBound)
+    return self[start..<end]
+  }
+}

package/ios/BlurhashLoader.swift

@@ -0,0 +1,52 @@
+import SDWebImage
+import ExpoModulesCore
+
+class BlurhashLoader: NSObject, SDImageLoader {
+  // MARK: - SDImageLoader
+
+  func canRequestImage(for url: URL?) -> Bool {
+    return url?.scheme == "blurhash"
+  }
+
+  func requestImage(
+    with url: URL?,
+    options: SDWebImageOptions = [],
+    context: [SDWebImageContextOption: Any]?,
+    progress progressBlock: SDImageLoaderProgressBlock?,
+    completed completedBlock: SDImageLoaderCompletedBlock? = nil
+  ) -> SDWebImageOperation? {
+    guard let url = url else {
+      let error = makeNSError(description: "URL provided to BlurhashLoader is missing")
+      completedBlock?(nil, nil, error, false)
+      return nil
+    }
+    guard let source = context?[ImageView.contextSourceKey] as? ImageSource else {
+      let error = makeNSError(description: "Image source was not provided to the context")
+      completedBlock?(nil, nil, error, false)
+      return nil
+    }
+
+    // The URI looks like this: blurhash:/WgF}G?az0fs.x[jat7xFRjNHt6s.4;oe-:RkVtkCi^Nbo|xZRjWB
+    // Which means that the `pathComponents[0]` is `/` and we need to skip it to get the hash.
+    let blurhash = url.pathComponents[1]
+    let size = CGSize(width: source.width, height: source.height)
+
+    DispatchQueue.global(qos: .userInitiated).async {
+      if let image = image(fromBlurhash: blurhash, size: size) {
+        DispatchQueue.main.async {
+          completedBlock?(UIImage(cgImage: image), nil, nil, true)
+        }
+      } else {
+        let error = makeNSError(description: "Unable to generate an image from the given blurhash")
+        completedBlock?(nil, nil, error, false)
+      }
+    }
+    return nil
+  }
+
+  func shouldBlockFailedURL(with url: URL, error: Error) -> Bool {
+    // If the algorithm failed to generate an image from the url,
+    // it's not possible that next time it will work :)
+    return true
+  }
+}

package/ios/ContentFit.swift

@@ -0,0 +1,55 @@
+import ExpoModulesCore
+
+/**
+ Describes how the image should be resized to fit its container.
+ - Note: It mirrors the CSS [`object-fit`](https://developer.mozilla.org/en-US/docs/Web/CSS/object-fit) property.
+ */
+enum ContentFit: String, Enumerable {
+  /**
+   The image is scaled to maintain its aspect ratio while fitting within the container's box.
+   The entire image is made to fill the box, while preserving its aspect ratio,
+   so the image will be "letterboxed" if its aspect ratio does not match the aspect ratio of the box.
+   */
+  case contain
+
+  /**
+   The image is sized to maintain its aspect ratio while filling the element's entire content box.
+   If the image's aspect ratio does not match the aspect ratio of its box, then the object will be clipped to fit.
+   */
+  case cover
+
+  /**
+   The image is sized to fill the element's content box. The entire object will completely fill the box.
+   If the image's aspect ratio does not match the aspect ratio of its box, then the image will be stretched to fit.
+   */
+  case fill
+
+  /**
+   The image is not resized and is centered by default.
+   When specified, the exact position can be controlled with `ContentPosition`.
+   */
+  case none
+
+  /**
+   The image is sized as if `none` or `contain` were specified,
+   whichever would result in a smaller concrete image size.
+   */
+  case scaleDown = "scale-down"
+
+  /**
+   `ContentFit` cases can be directly translated to the native `UIView.ContentMode`
+   except `scaleDown` that needs to be handled differently at the later step of rendering.
+   */
+  func toContentMode() -> UIView.ContentMode {
+    switch self {
+    case .contain:
+      return .scaleAspectFit
+    case .cover:
+      return .scaleAspectFill
+    case .fill:
+      return .scaleToFill
+    case .none, .scaleDown:
+      return .center
+    }
+  }
+}

package/ios/ContentPosition.swift

@@ -0,0 +1,108 @@
+import ExpoModulesCore
+
+/**
+ Represents a position value that might be either `Double` or `String`.
+ */
+typealias ContentPositionValue = Either<Double, String>
+
+/**
+ Specifies the alignment of the image within the container's box.
+ - Note: Its intention is to behave like the CSS [`object-position`](https://developer.mozilla.org/en-US/docs/Web/CSS/object-position) property.
+ */
+struct ContentPosition: Record {
+  static let center = Self()
+
+  @Field
+  var top: ContentPositionValue?
+
+  @Field
+  var bottom: ContentPositionValue?
+
+  @Field
+  var right: ContentPositionValue?
+
+  @Field
+  var left: ContentPositionValue?
+
+  /**
+   Returns a horizontal content offset based on the `left` or `right` field.
+   */
+  func offsetX(contentWidth: Double, containerWidth: Double) -> Double {
+    let diff = containerWidth - contentWidth
+
+    if let leftDistance = distance(from: left) {
+      return -diff / 2 + leftDistance
+    }
+    if let rightDistance = distance(from: right) {
+      return diff / 2 - rightDistance
+    }
+    if let factor = factor(from: left) {
+      return -diff / 2 + diff * factor
+    }
+    if let factor = factor(from: right) {
+      return diff / 2 - diff * factor
+    }
+    return 0
+  }
+
+  /**
+   Returns a vertical content offset based on the `top` or `bottom` field.
+   */
+  func offsetY(contentHeight: Double, containerHeight: Double) -> Double {
+    let diff = containerHeight - contentHeight
+
+    if let topDistance = distance(from: top) {
+      return -diff / 2 + topDistance
+    }
+    if let bottomDistance = distance(from: bottom) {
+      return diff / 2 - bottomDistance
+    }
+    if let factor = factor(from: top) {
+      return -diff / 2 + diff * factor
+    }
+    if let factor = factor(from: bottom) {
+      return diff / 2 - diff * factor
+    }
+    return 0
+  }
+
+  /**
+   A `CGPoint` with horizontal and vertical content offsets.
+   */
+  func offset(contentSize: CGSize, containerSize: CGSize) -> CGPoint {
+    return CGPoint(
+      x: offsetX(contentWidth: contentSize.width, containerWidth: containerSize.width),
+      y: offsetY(contentHeight: contentSize.height, containerHeight: containerSize.height)
+    )
+  }
+}
+
+/**
+ Returns a static offset from the given position value or `nil` when it cannot be cast to a `Double`.
+ */
+private func distance(from value: ContentPositionValue?) -> Double? {
+  if let value: Double = value?.get() {
+    return value
+  }
+  if let value: String = value?.get() {
+    return Double(value)
+  }
+  return nil
+}
+
+/**
+ Returns a factor from the percentage value from the given position.
+ The value must be a string containing a number and `%` character, or equal to `"center"` which is an equivalent to `50%`.
+ */
+private func factor(from value: ContentPositionValue?) -> Double? {
+  guard let value: String = value?.get() else {
+    return nil
+  }
+  if value == "center" {
+    return 0.5
+  }
+  guard value.contains("%"), let percentage = Double(value.replacingOccurrences(of: "%", with: "")) else {
+    return nil
+  }
+  return percentage / 100
+}

package/ios/ExpoImage.podspec

@@ -0,0 +1,30 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoImage'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platform       = :ios, '13.0'
+  s.swift_version  = '5.4'
+  s.source         = { git: 'https://github.com/expo/expo.git' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'SDWebImage', '~> 5.17.0'
+  s.dependency 'SDWebImageWebPCoder', '~> 0.13.0'
+  s.dependency 'SDWebImageAVIFCoder', '~> 0.10.1'
+  s.dependency 'SDWebImageSVGCoder', '~> 1.7.0'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,swift}"
+end

package/ios/ImageCachePolicy.swift

@@ -0,0 +1,24 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import SDWebImage
+import ExpoModulesCore
+
+enum ImageCachePolicy: String, Enumerable {
+  case none = "none"
+  case disk = "disk"
+  case memory = "memory"
+  case memoryAndDisk = "memory-disk"
+
+  func toSdCacheType() -> SDImageCacheType {
+    switch self {
+    case .none:
+      return .none
+    case .disk:
+      return .disk
+    case .memory:
+      return .memory
+    case .memoryAndDisk:
+      return .all
+    }
+  }
+}

package/ios/ImageCacheType.swift

@@ -0,0 +1,21 @@
+// Copyright 2022-present 650 Industries. All rights reserved.
+
+import SDWebImage
+import ExpoModulesCore
+
+enum ImageCacheType: String, Enumerable {
+  case none
+  case disk
+  case memory
+
+  static func fromSdCacheType(_ sdImageCacheType: SDImageCacheType) -> ImageCacheType {
+    switch sdImageCacheType {
+    case .none:
+      return .none
+    case .disk, .all:
+      return .disk
+    case .memory:
+      return .memory
+    }
+  }
+}