// swift-tools-version: 5.6
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "MyAppDependencies",
    platforms: [
        // Specify platforms to build
        .iOS(.v14),
    ],
    products: [],
    dependencies: [
        // Add dependencies
        .package(url: "https://github.com/onevcat/APNGKit.git", exact: "2.2.1"),
    ],
    targets: [
        .target(
            name: "MyAppDependency",
            dependencies: [
                // List all dependencies to build
                .product(name: "APNGKit", package: "APNGKit"),
            ]),
    ]
)

// swift-tools-version: 5.8
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "my-build-tool",
    platforms: [
        .macOS(.v12)
    ],
    dependencies: [
        .package(
            url: "https://github.com/giginet/Scipio.git", 
            revision: "0.15.0" // Use the latest version
        ),
    ],
    targets: [
        .executableTarget(
            name: "my-build-tool", 
            dependencies: [
                .product(name: "ScipioKit", package: "Scipio"),
            ],
            path: "Sources"
        ),
    ]
)

import Foundation
import ScipioKit

@main
struct EntryPoint {
    private static let myPackageDirectory = URL(fileURLWithPath: "/path/to/MyPackage")

    static func main() async throws {
        let runner = Runner(
            mode: .prepareDependencies,
            options: .init(
                baseBuildOptions: .init(
                    buildConfiguration: .release,
                    isSimulatorSupported: true
                )
            )
        )

        try await runner.run(
            packageDirectory: myPackageDirectory,
            frameworkOutputDir: .default
        )
    }
}

// SwiftUI view			
Section {
  Text("Change locale").font(.title)
  Text("Will be overwrite by host app!").foregroundColor(.pink)
  Button(action: {
    viewModel.locale = Locale(identifier: Language.en.rawValue)
  }, label: {
    Text("Change locale english")
  })
  Button(action: {
    viewModel.locale = Locale(identifier: Language.zh_Hans.rawValue)
  }, label: {
    Text("Change locale chinese simplified")
  })
  Text(LocalizedStringKey(R.string.localizable.hello_world.key.description))
} header: {
  Text("Change locale")
}
.environment(\.locale, viewModel.locale)

class AppLocale {
  let preferredLanguage = CurrentValueSubject<Language, Never>(.en)
  var preferredString: _R.string {
    R.string(preferredLanguages: [preferredLanguage.value.rawValue])
  }

  static var shared = AppLocale()
  private init() {}
} 			

// SwiftUI view
Section {
  Text("Preferred Languages \(viewModel.preferredLanguage.displayTitle)")
  Picker("Preferred Languages", selection: $viewModel.preferredLanguage) {
    ForEach(Language.allCases) {
      Text($0.displayTitle)
    }
  }
  .pickerStyle(.segmented)
  Text(AppLocale.shared.preferredString.localizable.hello_world)
} header: {
  Text("Change R.string Preferred Languages")
}

class HomeViewModel: ObservableObject {
  init() {
  AppLocale.shared.preferredLanguage
    .removeDuplicates()
    .sink(receiveValue: { _ in
				guard let self else { return }
        self.objectWillChange.send()
    })
    .store(in: &cancelables)
  }
}

struc HomeView: View {
  @StateObject var viewModel = HomeViewModel()
  
  var body: some View {
     Text(AppLocale.shared.preferredString.localizable.hello_world)
  }
}

// 1. Add the xcstrings-tool Package dependency
.package(url: "https://github.com/liamnichols/xcstrings-tool.git", from: "0.1.0")
// 2. Or use the repo is essentially a mirror of the main repository however the xcstrings-tool command line interface is a binary dependency that significantly simplifies your build graph and improves compile times.
.package(url: "https://github.com/liamnichols/xcstrings-tool-plugin.git", from: "0.1.0")

var evaluators: [String: ServerTrustEvaluating] = [:]

let evaluators: [String: ServerTrustEvaluating] = [
        "*.yourdomain.com": PinnedCertificatesTrustEvaluator()
    ]
// 白名单 allHostsMustBeEvaluated: true
let serverTrust = ServerTrustManager(allHostsMustBeEvaluated: true,
                                     evaluators: evaluators)

session = Alamofire.Session(configuration: configuration,
                            serverTrustManager: serverTrust)

func evaluate(_ trust: SecTrust, forHost host: String) throws

let evaluators: [String: ServerTrustEvaluating] = [
    // 默认情况下，应用程序捆绑包中包含的证书会自动固定。
    "cert.example.com": PinnedCertificatesTrustEvaluator(),
    // 默认情况下，会自动使用应用程序包中包含的证书中的公钥。
    "keys.example.com": PublicKeysTrustEvaluator(),
]

let manager = ServerTrustManager(evaluators: evaluators)

private enum TestCertificates {
    static let rootCA = TestCertificates.certificate(filename: "expired.badssl.com-root-ca")
    static let intermediateCA1 = TestCertificates.certificate(filename: "expired.badssl.com-intermediate-ca-1")
    static let intermediateCA2 = TestCertificates.certificate(filename: "expired.badssl.com-intermediate-ca-2")
    static let leaf = TestCertificates.certificate(filename: "expired.badssl.com-leaf")

		// 从给定的文件名创建证书：SecCertificate对象。
    static func certificate(filename: String) -> SecCertificate {
        let filePath = Bundle.test.path(forResource: filename, ofType: "cer")!
        let data = try! Data(contentsOf: URL(fileURLWithPath: filePath))
        let certificate = SecCertificateCreateWithData(nil, data as CFData)!

        return certificate
    }
}

func testThatExpiredCertificateRequestFailsWhenPinningLeafPublicKeyWithCertificateChainValidation() {
        // Given
				// 这里直接从证书提取公钥
        let keys = [TestCertificates.leaf].af.publicKeys
        let evaluators = [expiredHost: PublicKeysTrustEvaluator(keys: keys)]

        let manager = Session(configuration: configuration,
                              serverTrustManager: ServerTrustManager(evaluators: evaluators))

        let expectation = expectation(description: "\(expiredURLString)")
        var error: AFError?

        // When
        manager.request(expiredURLString)
            .response { resp in
                error = resp.error
                expectation.fulfill()
            }

        waitForExpectations(timeout: timeout)

        // Then
        XCTAssertNotNil(error, "error should not be nil")
        XCTAssertEqual(error?.isServerTrustEvaluationError, true)

        if case let .serverTrustEvaluationFailed(reason)? = error {
            if #available(iOS 12, macOS 10.14, tvOS 12, watchOS 5, *) {
                XCTAssertTrue(reason.isTrustEvaluationFailed, "should be .trustEvaluationFailed")
            } else {
                XCTAssertTrue(reason.isDefaultEvaluationFailed, "should be .defaultEvaluationFailed")
            }
        } else {
            XCTFail("error should be .serverTrustEvaluationFailed")
        }
    }

import PackageDescription

let package = Package(
    name: "Common",
    platforms: [
        .iOS(.v14)
    ],
    products: [
        .library(
            name: "Core",
           // type: .dynamic,
            targets: ["Core"]
        ),
    ],

// .package(url: "https://github.com/relatedcode/ProgressHUD.git", from: "13.7.2")
.package(url: "https://github.com/gewill/ProgressHUD.git", branch: "devlop")

private class BundleFinder {}

class AppCommomsBundle {
    static var module: Bundle = {
        // Bundle name should be like this "ProductName_TargetName"
        let bundleName = "AppCommoms_AppCommoms"
        let candidates = [
            // Bundle should be present here when the package is linked into an App.
            Bundle.main.resourceURL,
            
            // Bundle should be present here when the package is linked into a framework.
            Bundle(for: BundleFinder.self).resourceURL,
            
            // SwiftUI Preview
            Bundle(for: BundleFinder.self).resourceURL?.deletingLastPathComponent().deletingLastPathComponent(),
            
            // For command-line tools.
            Bundle.main.bundleURL
        ] + Bundle.allBundles.map { $0.bundleURL }
        
        for candidate in candidates {
            let bundlePath = candidate?.appendingPathComponent(bundleName + ".bundle")
            if let bundle = bundlePath.flatMap(Bundle.init(url:)) {
                return bundle
            }
        }
        return Bundle(for: BundleFinder.self)
//        fatalError("unable to find bundle named \(bundleName)")
    }()
}

import class Foundation.Bundle
import class Foundation.ProcessInfo
import struct Foundation.URL

private class BundleFinder {}

extension Foundation.Bundle {
    /// Returns the resource bundle associated with the current Swift module.
    static let module: Bundle = {
        let bundleName = "Onboarding_Onboarding"

        let overrides: [URL]
        #if DEBUG
        // The 'PACKAGE_RESOURCE_BUNDLE_PATH' name is preferred since the expected value is a path. The
        // check for 'PACKAGE_RESOURCE_BUNDLE_URL' will be removed when all clients have switched over.
        // This removal is tracked by rdar://107766372.
        if let override = ProcessInfo.processInfo.environment["PACKAGE_RESOURCE_BUNDLE_PATH"]
                       ?? ProcessInfo.processInfo.environment["PACKAGE_RESOURCE_BUNDLE_URL"] {
            overrides = [URL(fileURLWithPath: override)]
        } else {
            overrides = []
        }
        #else
        overrides = []
        #endif

        let candidates = overrides + [
            // Bundle should be present here when the package is linked into an App.
            Bundle.main.resourceURL,

            // Bundle should be present here when the package is linked into a framework.
            Bundle(for: BundleFinder.self).resourceURL,

            // For command-line tools.
            Bundle.main.bundleURL,
        ]

        for candidate in candidates {
            let bundlePath = candidate?.appendingPathComponent(bundleName + ".bundle")
            if let bundle = bundlePath.flatMap(Bundle.init(url:)) {
                return bundle
            }
        }
        fatalError("unable to find bundle named Onboarding_Onboarding")
    }()
}