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: "OpenAttributeGraph")
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 warningsAsErrorsCondition = envBoolValue("WERROR", default: isXcodeEnv && development)

let swiftCheckoutPath = "\(Context.packageDirectory)/Checkouts/swift"
let swiftCorelibsPath = envStringValue("LIB_SWIFT_PATH") ?? "\(Context.packageDirectory)/Sources/SwiftCorelibs/include"

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

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

let useLocalDeps = envBoolValue("USE_LOCAL_DEPS")
let computeCondition = envBoolValue("OPENATTRIBUTESHIMS_COMPUTE", default: false)
let attributeGraphCondition = envBoolValue("OPENATTRIBUTESHIMS_ATTRIBUTEGRAPH", default: false)

// MARK: - Shared Settings

var sharedCSettings: [CSetting] = [
    .define("NDEBUG", .when(configuration: .release)),
    // Rewrite malloc() to malloc_type_malloc() for type-isolated allocation buckets (xzone malloc).
    .unsafeFlags(["-ftyped-memory-operations"], .when(platforms: .darwinPlatforms)),
]

var sharedCxxSettings: [CXXSetting] = [
    .define("NDEBUG", .when(configuration: .release)),
    // Rewrite malloc() to malloc_type_malloc() for type-isolated allocation buckets (xzone malloc).
    .unsafeFlags(["-ftyped-memory-operations"], .when(platforms: .darwinPlatforms)),
    // Rewrite operator new/delete to typed variants (operator new(size_t, std::__type_descriptor_t)).
    .unsafeFlags(["-ftyped-cxx-new-delete"], .when(platforms: .darwinPlatforms)),
]

var sharedSwiftSettings: [SwiftSetting] = [
    .enableUpcomingFeature("InternalImportsByDefault"),
    .enableExperimentalFeature("Extern"),
    .swiftLanguageMode(.v5),

    .define("OPENATTRIBUTEGRAPH_RELEASE_\(releaseVersion)"),
]

sharedCSettings.append(
    .unsafeFlags([
        "-isystem", "\(swiftCheckoutPath)/include",
        "-isystem", "\(swiftCheckoutPath)/stdlib/include",
        "-isystem", "\(swiftCheckoutPath)/stdlib/public/SwiftShims",
    ])
)
sharedCxxSettings.append(
    .unsafeFlags([
        "-isystem", "\(swiftCheckoutPath)/include",
        "-isystem", "\(swiftCheckoutPath)/stdlib/include",
        "-isystem", "\(swiftCheckoutPath)/stdlib/public/SwiftShims",
    ])
)
sharedCSettings.append(
    .unsafeFlags(
        ["-isystem", swiftCorelibsPath],
        .when(platforms: .nonDarwinPlatforms)
    )
)
sharedCxxSettings.append(
    .unsafeFlags(
        ["-isystem", swiftCorelibsPath],
        .when(platforms: .nonDarwinPlatforms)
    )
)
if releaseVersion >= 2021 {
    for year in 2021 ... releaseVersion {
        sharedSwiftSettings.append(.define("OPENATTRIBUTEGRAPH_SUPPORT_\(year)_API"))
    }
}
if warningsAsErrorsCondition {
    sharedSwiftSettings.append(.unsafeFlags(["-warnings-as-errors"]))
}

if libraryEvolutionCondition {
    // NOTE: -enable-library-evolution will cause module verify failure for `swift build`.
    // Either set OPENATTRIBUTEGRAPH_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 !(compatibilityTestCondition && buildForDarwinPlatform) {
    sharedCSettings.append(.define("OPENATTRIBUTEGRAPH"))
    sharedCxxSettings.append(.define("OPENATTRIBUTEGRAPH"))
    sharedSwiftSettings.append(.define("OPENATTRIBUTEGRAPH"))
}

// MARK: - Extension

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

    func addComputeSettings() {
        dependencies.append(
            "Compute",
        )
        var swiftSettings = swiftSettings ?? []
        swiftSettings.append(.define("OPENATTRIBUTEGRAPH_COMPUTE"))
        self.swiftSettings = swiftSettings

        var linkerSettings = linkerSettings ?? []
        linkerSettings.append(.linkedLibrary("swiftDemangle", .when(platforms: .darwinPlatforms)))
        self.linkerSettings = linkerSettings
    }
}

extension [Platform] {
    static var darwinPlatforms: [Platform] {
        [.macOS, .iOS, .tvOS, .watchOS, .visionOS, .macCatalyst]
    }
    static var nonDarwinPlatforms: [Platform] {
        [.linux, .android, .wasi, .openbsd, .windows]
    }
}

extension [SwiftSetting] {
    // C++ interop test targets need .interoperabilityMode(.Cxx) but must not use
    // -warnings-as-errors, because Swift's Clang importer emits unavoidable warnings
    // for C++ stdlib types (e.g., 'import_owned' ignored on 'basic_string').
    func addCxxInterop() -> [SwiftSetting] {
        var settings = filter { setting in
            "\(setting)" != "\(SwiftSetting.unsafeFlags(["-warnings-as-errors"]))"
        }
        settings.append(.interoperabilityMode(.Cxx))
        return settings
    }
}

// MARK: - Targets

let platformTarget = Target.target(
    name: "Platform",
    path: "Sources/Platform",
    cSettings: sharedCSettings + [
        .define("_GNU_SOURCE", .when(platforms: [.linux])),
    ]
)
let utilitiesTarget = Target.target(
    name: "Utilities",
    dependencies: [
        .target(name: platformTarget.name),
    ],
    path: "Sources/Utilities",
    cxxSettings: sharedCxxSettings
)
// FIXME: Merge into one target
// OpenAttributeGraph is a C++ & Swift mix target.
// The SwiftPM support for such usage is still in progress.
let openAttributeGraphCxxTarget = Target.target(
    name: "OpenAttributeGraphCxx",
    dependencies: [
        .target(name: platformTarget.name),
        .target(name: utilitiesTarget.name),
    ],
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    linkerSettings: [
        .linkedLibrary("z"),
    ],
    plugins: []
)
let openAttributeGraphTarget = Target.target(
    name: "OpenAttributeGraph",
    dependencies: [
        .target(name: openAttributeGraphCxxTarget.name),
    ],
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    swiftSettings: sharedSwiftSettings
)
let openAttributeGraphShimsTarget = Target.target(
    name: "OpenAttributeGraphShims",
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    swiftSettings: sharedSwiftSettings
)

// MARK: - Test Targets

let utilitiesTestsTarget = Target.testTarget(
    name: "UtilitiesTests",
    dependencies: [
        .target(name: utilitiesTarget.name),
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings + [.define("SWIFT_TESTING")],
    cxxSettings: sharedCxxSettings + [.define("SWIFT_TESTING")],
    swiftSettings: sharedSwiftSettings.addCxxInterop()
)
let openAttributeGraphCxxTestsTarget = Target.testTarget(
    name: "OpenAttributeGraphCxxTests",
    dependencies: [
        .target(name: openAttributeGraphCxxTarget.name),
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings + [.define("SWIFT_TESTING")],
    cxxSettings: sharedCxxSettings + [.define("SWIFT_TESTING")],
    swiftSettings: sharedSwiftSettings.addCxxInterop()
)
let openAttributeGraphShimsTestsTarget = Target.testTarget(
    name: "OpenAttributeGraphShimsTests",
    dependencies: [
        .target(name: openAttributeGraphShimsTarget.name),
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    swiftSettings: sharedSwiftSettings
)
let openAttributeGraphCompatibilityTestsTarget = Target.testTarget(
    name: "OpenAttributeGraphCompatibilityTests",
    dependencies: [
        .product(name: "Numerics", package: "swift-numerics"),
    ],
    exclude: ["README.md"],
    cSettings: sharedCSettings,
    cxxSettings: sharedCxxSettings,
    swiftSettings: sharedSwiftSettings
)

// MARK: - Package

let package = Package(
    name: "OpenAttributeGraph",
    products: [
        .library(
            name: "OpenAttributeGraphShims",
            targets: [openAttributeGraphShimsTarget.name]
        )
    ],
    targets: [openAttributeGraphShimsTarget],
    cxxLanguageStandard: .cxx20
)

private var hasSetupDPFDependency = false

@MainActor
func setupDPFDependency() {
    guard !hasSetupDPFDependency else { return }
    hasSetupDPFDependency = true
    let privateFrameworkRepo: Package.Dependency
    if useLocalDeps {
        privateFrameworkRepo = Package.Dependency.package(path: "../DarwinPrivateFrameworks")
    } else {
        privateFrameworkRepo = Package.Dependency.package(url: "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git", branch: "main")
    }
    package.dependencies.append(privateFrameworkRepo)

    let agVersion = EnvManager.shared.withDomain("DarwinPrivateFrameworks") {
        envIntValue("TARGET_RELEASE", default: 2024)
    }
    package.platforms = switch agVersion {
        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
    }
}

if computeCondition {
    let computeBinary = envBoolValue("OPENATTRIBUTESHIMS_COMPUTE_USE_BINARY", default: false)
    if computeBinary {
        let version = envStringValue("OPENATTRIBUTESHIMS_COMPUTE_BINARY_VERSION", default: "0.1.0")
        let url = envStringValue("OPENATTRIBUTESHIMS_COMPUTE_BINARY_URL", default: "https://github.com/jcmosc/Compute/releases/download/\(version)/Compute.xcframework.zip")
        let checksum = envStringValue("OPENATTRIBUTESHIMS_COMPUTE_USE_BINARY_CHECKSUM", default: "e32dd27fa4df4928be69d4171bcb3d47192bebb467f70bfd728cca56d44682d6")
        package.targets.append(
            .binaryTarget(
                name: "Compute",
                url: url,
                checksum: checksum
            )
        )
    } else {
        let computeRepo: Package.Dependency
        if useLocalDeps {
            computeRepo = Package.Dependency.package(path: "../Compute")
        } else {
            computeRepo = Package.Dependency.package(url: "https://github.com/jcmosc/Compute", exact: "0.1.0")
        }
        package.dependencies.append(computeRepo)
    }
    openAttributeGraphShimsTarget.addComputeSettings()
    package.platforms = [.iOS(.v18), .macOS(.v15), .macCatalyst(.v18), .tvOS(.v18), .watchOS(.v10), .visionOS(.v2)]
} else if attributeGraphCondition, buildForDarwinPlatform {
    setupDPFDependency()
    openAttributeGraphShimsTarget.addAGSettings()
} else {
    let oagBinary = envBoolValue("OPENATTRIBUTESHIMS_OAG_USE_BINARY", default: false)
    if oagBinary {
        let version = envStringValue("OPENATTRIBUTESHIMS_OAG_BINARY_VERSION", default: "0.5.0")
        let url = envStringValue("OPENATTRIBUTESHIMS_OAG_BINARY_URL", default: "https://github.com/OpenSwiftUIProject/OpenAttributeGraph/releases/download/\(version)/OpenAttributeGraph.xcframework.zip")
        let checksum = envStringValue("OPENATTRIBUTESHIMS_OAG_BINARY_CHECKSUM", default: "ac7d8cb7cfd917b9f1768dc18dfea74b1ed64ce96d2424ba8c557e70736674ff")
        let target = Target.binaryTarget(
            name: openAttributeGraphTarget.name,
            url: url,
            checksum: checksum
        )
        package.targets.append(target)
        package.products.append(
            .library(name: "OpenAttributeGraph", targets: [openAttributeGraphTarget.name])
        )
    } else {
        package.targets.append(contentsOf: [
            platformTarget,
            utilitiesTarget,
            openAttributeGraphTarget,
            openAttributeGraphCxxTarget,
        ])
        package.products.append(
            .library(name: "OpenAttributeGraph", targets: [openAttributeGraphTarget.name, openAttributeGraphCxxTarget.name])
        )
    }
    openAttributeGraphShimsTarget.dependencies.append(.target(name: openAttributeGraphTarget.name))

    package.targets.append(openAttributeGraphCompatibilityTestsTarget)
    package.dependencies.append(
        .package(url: "https://github.com/apple/swift-numerics", from: "1.1.1")
    )

    if compatibilityTestCondition, buildForDarwinPlatform {
        setupDPFDependency()
        openAttributeGraphCompatibilityTestsTarget.addAGSettings()
    } else {
        openAttributeGraphCompatibilityTestsTarget.dependencies.append(
            .target(name: openAttributeGraphTarget.name)
        )
        if !oagBinary {
            package.targets += [
                utilitiesTestsTarget,
                openAttributeGraphCxxTestsTarget,
                openAttributeGraphShimsTestsTarget,
            ]
        }
        package.platforms = [.iOS(.v13), .macOS(.v10_15), .macCatalyst(.v13), .tvOS(.v13), .watchOS(.v5)]
    }
}