Package.swift

// swift-tools-version: 6.1

import CompilerPluginSupport
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: "OpenCoreGraphics")
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

let isXcodeEnv = Context.environment["__CFBundleIdentifier"] == "com.apple.dt.Xcode"
let development = envBoolValue("DEVELOPMENT")

let coreGraphicsCondition = envBoolValue("COREGRAPHICS", default: buildForDarwinPlatform)
let warningsAsErrorsCondition = envBoolValue("WERROR", default: isXcodeEnv && development)
let libraryEvolutionCondition = envBoolValue("LIBRARY_EVOLUTION", default: buildForDarwinPlatform)

var sharedSwiftSettings: [SwiftSetting] = [
    .swiftLanguageMode(.v6),
    .enableUpcomingFeature("InternalImportsByDefault"),
]

if coreGraphicsCondition {
    sharedSwiftSettings.append(.define("OPENCOREGRAPHICS_COREGRAPHICS"))
}

if warningsAsErrorsCondition {
    sharedSwiftSettings.append(.unsafeFlags(["-warnings-as-errors"]))
}

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"]))
}

let package = Package(
    name: "OpenCoreGraphics",
    products: [
        .library(name: "OpenCoreGraphics", targets: ["OpenCoreGraphics"]),
        .library(name: "OpenCoreGraphicsShims", targets: ["OpenCoreGraphicsShims"]),
        .library(name: "OpenQuartzCore", targets: ["OpenQuartzCore"]),
        .library(name: "OpenQuartzCoreShims", targets: ["OpenQuartzCoreShims"]),
    ],
    dependencies: [
        .package(url: "https://github.com/apple/swift-numerics", from: "1.0.3"),
    ],
    targets: [
        .target(
            name: "OpenCoreGraphics",
            swiftSettings: sharedSwiftSettings
        ),
        .target(
            name: "OpenCoreGraphicsShims",
            dependencies: ["OpenCoreGraphics"],
            swiftSettings: sharedSwiftSettings,
            linkerSettings: [
                .linkedFramework("CoreGraphics", .when(platforms: .darwinPlatforms)),
            ]
        ),
        .testTarget(
            name: "OpenCoreGraphicsShimsTests",
            dependencies: [
                "OpenCoreGraphicsShims",
                .product(name: "Numerics", package: "swift-numerics"),
            ],
            swiftSettings: sharedSwiftSettings
        ),

        .target(
            name: "OpenQuartzCore",
            dependencies: ["OpenCoreGraphics"],
            swiftSettings: sharedSwiftSettings
        ),
        .target(
            name: "OpenQuartzCoreShims",
            dependencies: ["OpenQuartzCore"],
            swiftSettings: sharedSwiftSettings,
            linkerSettings: [
                .linkedFramework("QuartzCore", .when(platforms: .darwinPlatforms)),
            ]
        ),
        .testTarget(
            name: "OpenQuartzCoreShimsTests",
            dependencies: [
                "OpenQuartzCoreShims",
                .product(name: "Numerics", package: "swift-numerics"),
            ],
            swiftSettings: sharedSwiftSettings
        ),
    ]
)

extension [Platform] {
    static var darwinPlatforms: [Platform] {
        [.iOS, .macOS, .tvOS, .watchOS, .visionOS, .macCatalyst]
    }

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