Package.swift

// swift-tools-version: 6.1

import Foundation
import PackageDescription

// MARK: - EnvManager

/* GENERATED BY SPMManifestTool BEGIN */
/* DO NOT EDIT */

public protocol EnvironmentProvider {
    func value(forKey key: String) -> String?
}

import PackageDescription
public struct PackageContextEnvironmentProvider: EnvironmentProvider {
    public init() {}

    public func value(forKey key: String) -> String? {
        Context.environment[key]
    }
}

public final class EnvManager {
    nonisolated(unsafe) public static let shared = EnvManager()

    private var domains: [String] = []
    private var environmentProvider: EnvironmentProvider

    /// When true, append raw key as fallback when searching in domains
    public var includeFallbackToRawKey: Bool = false

    private init() {
        self.environmentProvider = PackageContextEnvironmentProvider()
    }

    /// Set a custom environment provider (useful for testing)
    public func setEnvironmentProvider(_ provider: EnvironmentProvider) {
        self.environmentProvider = provider
    }

    /// Reset domains and environment provider (useful for testing)
    public func reset() {
        domains.removeAll()
        includeFallbackToRawKey = false
        self.environmentProvider = PackageContextEnvironmentProvider()
    }

    public func register(domain: String) {
        domains.append(domain)
    }

    public func withDomain<T>(_ domain: String, perform: () throws -> T) rethrows -> T {
        domains.append(domain)
        defer { domains.removeAll { $0 == domain } }
        return try perform()
    }

    private func envValue<T>(rawKey: String, default defaultValue: T?, searchInDomain: Bool, parser: (String) -> T?) -> T? {
        func parseEnvValue(_ key: String) -> (String, T)? {
            guard let value = environmentProvider.value(forKey: key),
                  let result = parser(value) else { return nil }
            return (value, result)
        }
        var keys: [String] = searchInDomain ? domains.map { "\($0.uppercased())_\(rawKey)" } : []
        if !searchInDomain || includeFallbackToRawKey {
            keys.append(rawKey)
        }
        for key in keys {
            if let (value, result) = parseEnvValue(key) {
                print("[Env] \(key)=\(value) -> \(result)")
                return result
            }
        }
        let primaryKey = keys.first ?? rawKey
        if let defaultValue {
            print("[Env] \(primaryKey) not set -> \(defaultValue)(default)")
        }
        return defaultValue
    }

    public func envBoolValue(rawKey: String, default defaultValue: Bool? = nil, searchInDomain: Bool) -> Bool? {
        envValue(rawKey: rawKey, default: defaultValue, searchInDomain: searchInDomain) { value in
            switch value {
            case "1": true
            case "0": false
            default: nil
            }
        }
    }

    public func envIntValue(rawKey: String, default defaultValue: Int? = nil, searchInDomain: Bool) -> Int? {
        envValue(rawKey: rawKey, default: defaultValue, searchInDomain: searchInDomain) { Int($0) }
    }

    public func envStringValue(rawKey: String, default defaultValue: String? = nil, searchInDomain: Bool) -> String? {
        envValue(rawKey: rawKey, default: defaultValue, searchInDomain: searchInDomain) { $0 }
    }
}

public func envBoolValue(_ key: String, default defaultValue: Bool = false, searchInDomain: Bool = true) -> Bool {
    EnvManager.shared.envBoolValue(rawKey: key, default: defaultValue, searchInDomain: searchInDomain)!
}

public func envIntValue(_ key: String, default defaultValue: Int = 0, searchInDomain: Bool = true) -> Int {
    EnvManager.shared.envIntValue(rawKey: key, default: defaultValue, searchInDomain: searchInDomain)!
}

public func envStringValue(_ key: String, default defaultValue: String, searchInDomain: Bool = true) -> String {
    EnvManager.shared.envStringValue(rawKey: key, default: defaultValue, searchInDomain: searchInDomain)!
}

public func envStringValue(_ key: String, searchInDomain: Bool = true) -> String? {
    EnvManager.shared.envStringValue(rawKey: key, searchInDomain: searchInDomain)
}

/* GENERATED BY SPMManifestTool END */
EnvManager.shared.register(domain: "OpenRenderBox")
EnvManager.shared.register(domain: "OpenSwiftUI")

// MARK: - Env and config

#if os(macOS)
// NOTE: #if os(macOS) check is not accurate if we are cross compiling for Linux platform. So we add an env key to specify it.
let buildForDarwinPlatform = envBoolValue("BUILD_FOR_DARWIN_PLATFORM", default: true)
#else
let buildForDarwinPlatform = envBoolValue("BUILD_FOR_DARWIN_PLATFORM")
#endif

// https://github.com/SwiftPackageIndex/SwiftPackageIndex-Server/issues/3061#issuecomment-2118821061
// By-pass https://github.com/swiftlang/swift-package-manager/issues/7580
let isSPIDocGenerationBuild = envBoolValue("SPI_GENERATE_DOCS", searchInDomain: false)
let isSPIBuild = envBoolValue("SPI_BUILD", searchInDomain: false)

let isXcodeEnv = envStringValue("__CFBundleIdentifier", searchInDomain: false) == "com.apple.dt.Xcode"
let development = envBoolValue("DEVELOPMENT", default: false)

let releaseVersion = envIntValue("TARGET_RELEASE", default: 2024)

let libSwiftPath = {
    // From Swift toolchain being installed or from Swift SDK.
    guard let libSwiftPath = envStringValue("LIB_SWIFT_PATH") else {
        // Fallback when LIB_SWIFT_PATH is not set
        let swiftBinPath = envStringValue("BIN_SWIFT_PATH") ?? envStringValue("_", searchInDomain: false) ?? "/usr/bin/swift"
        let swiftBinURL = URL(fileURLWithPath: swiftBinPath)
        let SDKPath = swiftBinURL.deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent().path
        return SDKPath.appending("/usr/lib/swift")
    }
    return libSwiftPath
}()

let libraryEvolutionCondition = envBoolValue("LIBRARY_EVOLUTION", default: buildForDarwinPlatform)
let compatibilityTestCondition = envBoolValue("COMPATIBILITY_TEST", default: false)

let useLocalDeps = envBoolValue("USE_LOCAL_DEPS")
let renderBoxCondtion = envBoolValue("RENDERBOX", default: buildForDarwinPlatform && !isSPIBuild)

/// CGFloat and CGRect def in CFCGTypes.h will conflict with Foundation's CGSize/CGRect def on Linux.
/// macOS: true -> no issue
/// macOS: false -> use Swift implementation with OpenCoreGraphics Swift CGPath
/// Linux: true + No CGPathRef support in ORBPath -> confilict with Foundation def
/// Linux: false -> use Swift implementation with OpenCoreGraphics Swift CGPath
let cfCGTypes = envBoolValue("CF_CGTYPES", default: buildForDarwinPlatform)

// MARK: - Shared Settings

var sharedCSettings: [CSetting] = [
    .unsafeFlags(["-I", libSwiftPath], .when(platforms: .nonDarwinPlatforms)),
    // .unsafeFlags(["-fmodules"]),
    .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
]
var sharedCxxSettings: [CXXSetting] = [
    .unsafeFlags(["-I", libSwiftPath], .when(platforms: .nonDarwinPlatforms)),
    // .unsafeFlags(["-fcxx-modules"]),
    .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
]
var sharedSwiftSettings: [SwiftSetting] = [
    .swiftLanguageMode(.v5),
    .enableUpcomingFeature("InternalImportsByDefault"),
]
if libraryEvolutionCondition {
    // NOTE: -enable-library-evolution will cause module verify failure for `swift build`.
    // Either set LIBRARY_EVOLUTION=0 or add `-Xswiftc -no-verify-emitted-module-interface` after `swift build`
    sharedSwiftSettings.append(.unsafeFlags(["-enable-library-evolution", "-no-verify-emitted-module-interface"]))
}

if cfCGTypes {
    sharedCSettings.append(.define("OPENRENDERBOX_CF_CGTYPES"))
    sharedCxxSettings.append(.define("OPENRENDERBOX_CF_CGTYPES"))
    sharedSwiftSettings.append(.define("OPENRENDERBOX_CF_CGTYPES"))
}

// MARK: - Extension

extension Target {
    func addRBSettings() {
        dependencies.append(
            .product(name: "RenderBox", package: "DarwinPrivateFrameworks")
        )
        var swiftSettings = swiftSettings ?? []
        swiftSettings.append(.define("OPENRENDERBOX_RENDERBOX"))
        self.swiftSettings = swiftSettings
    }
}

extension [Platform] {
    static var nonDarwinPlatforms: [Platform] {
        [.linux, .android, .wasi, .openbsd, .windows]
    }
}

// MARK: - Targets

let openRenderBoxTarget = Target.target(
    name: "OpenRenderBox",
    dependencies: [
        "OpenRenderBoxCxx",
        .product(name: "OpenCoreGraphicsShims", package: "OpenCoreGraphics"),
    ],
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    swiftSettings: sharedSwiftSettings
)
// FIXME: Merge into one target
// OpenRenderBox is a C++ & Swift mix target.
// The SwiftPM support for such usage is still in progress.
let openRenderBoxCxxTarget = Target.target(
    name: "OpenRenderBoxCxx",
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings
)
let openRenderBoxShimsTarget = Target.target(
    name: "OpenRenderBoxShims",
    swiftSettings: sharedSwiftSettings
)
let openRenderBoxTestsTarget = Target.testTarget(
    name: "OpenRenderBoxTests",
    dependencies: [
        "OpenRenderBox",
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings + [.define("SWIFT_TESTING")],
    cxxSettings: sharedCxxSettings + [.define("SWIFT_TESTING")],
    swiftSettings: sharedSwiftSettings + [.interoperabilityMode(.Cxx)]
)
let openRenderBoxCompatibilityTestTarget = Target.testTarget(
    name: "OpenRenderBoxCompatibilityTests",
    dependencies: [
        .product(name: "Numerics", package: "swift-numerics"),
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings + [.define("SWIFT_TESTING")],
    cxxSettings: sharedCxxSettings + [.define("SWIFT_TESTING")],
    swiftSettings: sharedSwiftSettings
)

// MARK: - Package

let libraryType: Product.Library.LibraryType?
switch envStringValue("LIBRARY_TYPE") {
case "dynamic":
    libraryType = .dynamic
case "static":
    libraryType = .static
default:
    libraryType = nil
}

let package = Package(
    name: "OpenRenderBox",
    products: [
        .library(name: "OpenRenderBox", type: libraryType, targets: ["OpenRenderBox", "OpenRenderBoxCxx"]),
        .library(name: "OpenRenderBoxShims", type: libraryType, targets: ["OpenRenderBoxShims"]),
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-numerics", from: "1.1.1"),
    ],
    targets: [
        openRenderBoxTarget,
        openRenderBoxCxxTarget,
        openRenderBoxShimsTarget,
        openRenderBoxTestsTarget,
        openRenderBoxCompatibilityTestTarget,
    ],
    cxxLanguageStandard: .cxx20
)

if renderBoxCondtion {
    openRenderBoxShimsTarget.addRBSettings()
}

if renderBoxCondtion {
    let release = EnvManager.shared.withDomain("DarwinPrivateFrameworks") {
        envIntValue("TARGET_RELEASE", default: 2024)
    }
    package.platforms = switch release {
        case 2024: [.iOS(.v18), .macOS(.v15), .macCatalyst(.v18), .tvOS(.v18), .watchOS(.v10), .visionOS(.v2)]
        case 2021: [.iOS(.v15), .macOS(.v12), .macCatalyst(.v15), .tvOS(.v15), .watchOS(.v7)]
        default: nil
    }
} else {
    openRenderBoxShimsTarget.dependencies.append("OpenRenderBox")
}

if useLocalDeps {
    var dependencies: [Package.Dependency] = [
        .package(path: "../OpenCoreGraphics"),
    ]
    if renderBoxCondtion {
        dependencies.append(.package(path: "../DarwinPrivateFrameworks"))
    }
    package.dependencies += dependencies
} else {
    var dependencies: [Package.Dependency] = [
        .package(url: "https://github.com/OpenSwiftUIProject/OpenCoreGraphics", branch: "main"),
    ]
    if renderBoxCondtion {
        dependencies.append(.package(url: "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git", branch: "main"))
    }
    package.dependencies += dependencies
}

if compatibilityTestCondition && renderBoxCondtion {
    openRenderBoxCompatibilityTestTarget.addRBSettings()
    var swiftSettings: [SwiftSetting] = (openRenderBoxCompatibilityTestTarget.swiftSettings ?? [])
    swiftSettings.append(.define("OPENRENDERBOX_COMPATIBILITY_TEST"))
    openRenderBoxCompatibilityTestTarget.swiftSettings = swiftSettings
} else {
    openRenderBoxCompatibilityTestTarget.dependencies.append("OpenRenderBox")
}