Swift Package Manager with Kotlin Multiplatform

https://spmforkmp.eu
Admin
SPM For KMP is a Gradle plugin that integrates Swift Package Manager with Kotlin Multiplatform,...
Tokens:17,930
Snippets:257
Trust Score:7.5
Update:5 months ago
Show doc for...
Tokens:
Raw
### Add User Setup Hint for Linker Errors

Source: https://spmforkmp.eu/references/swiftPackageConfig

Provides a custom message appended to linker errors to guide users toward the fix.

```kotlin
userSetupHint = "Add the XYZ framework to your Xcode project's linked libraries."

```

--------------------------------

### Example Usage of includeProduct

Source: https://spmforkmp.eu/references/exportedPackageConfig

Demonstrates how to use `includeProduct` within `swiftPackageConfig` to manually include specific products like 'KeychainAccess' from a remote package. Note the build output warning about adding dependencies to Xcode projects.

```kotlin
kotlin {
    iosArm64 {
        swiftPackageConfig {
            // Manually include the KeychainAccess library
            exportedPackageSettings { includeProduct = listOf("KeychainAccess") }
            dependency {
                remotePackageBranch(
                    url = URI("https://github.com/krzyzanowskim/CryptoSwift.git"),
                    branch = "main",
                    products = {
                        add(
                            ProductName(
                                "CryptoSwift"
                            ), // will not be included inside the exported package
                        )
                    },
                )
                remotePackageBranch(
                    url =
                        URI(
                            "https://github.com/kishikawakatsumi/KeychainAccess.git"
                        ), // will be included inside the exported package
                    products = { add("KeychainAccess") },
                    branch = "master",
                )
            }
        }
    }
}

```

--------------------------------

### Minimal Bridge Setup (Kotlin DSL)

Source: https://spmforkmp.eu/bridge

Configure the bridge for Kotlin targets, specifying a cinterop name. This setup does not include external dependencies.

```kotlin
kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
        // and more Apple targets...
    ).forEach {
        target ->
        target.swiftPackageConfig(cinteropName = "[cinteropName]") {
        }
    }
}

```

--------------------------------

### Swift Bridge for CryptoSwift MD5

Source: https://spmforkmp.eu/bridgeWithDependencies

Implement a Swift class annotated with `@objcMembers` and `public` to expose functionality to Kotlin. This example shows how to use the CryptoSwift library to compute an MD5 hash.

```swift
import Foundation
import CryptoSwift

@objcMembers public class MySwiftBridge: NSObject {
    public func toMD5(value: String) -> String {
        return value.md5()
    }
}

```

--------------------------------

### Configure Package Registry (with Username and Password)

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configures a Swift package registry with authentication using a username and password. This is an alternative to Git-based package sources for dependency resolution.

```kotlin
registry(
    url = uri("https://registry.example.com"),
    username = "user",
    password = "secret",
)

```

--------------------------------

### Configure Package Registry (with Token)

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configures a Swift package registry using an authentication token. This is an alternative to Git-based package sources for dependency resolution.

```kotlin
registry(
    url = uri("https://registry.example.com"),
    token = "my-token",
)

```

--------------------------------

### Add Products by String Names

Source: https://spmforkmp.eu/references/dependency/productPackageConfig

Adds one or more products to the product package configuration using their string representations. Optionally specify if products should be exported to Kotlin.

```kotlin
fun add(
    vararg names: String,
    exportToKotlin: Boolean = false,
)
```

--------------------------------

### Configure Package Registry (with Token File)

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configures a Swift package registry using a token stored in a file. This is an alternative to Git-based package sources for dependency resolution.

```kotlin
registry(
    url = uri("https://registry.example.com"),
    tokenFile = file("/path/to/token.txt"),
)

```

--------------------------------

### Configure Swift Package for iOS Targets

Source: https://spmforkmp.eu/references/swiftPackageConfig

Set up Swift package configuration for iOS targets, specifying the cinterop name and minimum deployment version.

```kotlin
kotlin {
    listOf(iosArm64(), iosSimulatorArm64()).forEach {
        target ->
        target.swiftPackageConfig(cinteropName = "nativeBridge") {
            minIos = "16.0"
            debug = false
            dependency { ... }
        }
    }
}

```

--------------------------------

### Add Products by ProductName

Source: https://spmforkmp.eu/references/dependency/productPackageConfig

Adds one or more products to the product package configuration using ProductName objects. Optionally specify if products should be exported to Kotlin.

```kotlin
fun add(
    vararg products: ProductName,
    exportToKotlin: Boolean = false,
)
```

--------------------------------

### Configure C Build Settings

Source: https://spmforkmp.eu/references/bridgeSettingsConfig

Configure C build settings for a target, including defines, header search paths, and unsafe flags.

```kotlin
public fun cSetting(setting: CSettingConfig.() -> Unit)
```

--------------------------------

### Legacy Swift Package Configuration (Pre 1.1.0)

Source: https://spmforkmp.eu/setup

Legacy configuration for Swift Package using `cinterops.create` and `swiftPackageConfig.create` in `build.gradle.kts`.

```kotlin
kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
        // and more Apple targets...
    ).forEach {
        it.compilations {
            val main by getting {
                cinterops.create("[cinteropName]")
            }
        }
    }
}
```

```kotlin
swiftPackageConfig {
    create("[cinteropName]") { // must match cinterops.create name
    }
}
```

--------------------------------

### Configure Swift Package Registry Dependency

Source: https://spmforkmp.eu/usages/packageRegistry

Add the server configuration and dependency details for importing a package from a registry. Ensure your server URL and credentials are correct.

```kotlin
iosArm64 {
    swiftPackageConfig {
        registry(
            url = uri("https://your/server/configuration")
            token = "YourCredential",
        )
        dependency {
            registryPackage(
                id = "spm.dummy",
                version = "1.0.1",
                products = {
                    add("registrydummy")
                },
            )
        }
    }
}

```

--------------------------------

### Add Local Binary Dependency

Source: https://spmforkmp.eu/bridgeWithDependencies

Configure a local binary framework by providing its path. This is for pre-compiled frameworks located on your local file system.

```kotlin
localBinary(
    path = "/path/to/LocalFramework.xcframework",
    packageName = "LocalFramework",
)

```

--------------------------------

### Add by ProductName

Source: https://spmforkmp.eu/references/dependency/productPackageConfig

Adds one or more products to the product package configuration using ProductName objects. Products can be configured for export to Kotlin.

```APIDOC
## Add by ProductName

Adds one or more products to the product package configuration.

### Parameters

* **products** The products to be added. Each product is represented by a [ProductName], which includes details such as the name and an optional alias.
* **exportToKotlin** Determines whether the added products should be exported to Kotlin. Defaults to `false` if not specified.

### Function Signature

```kotlin
fun add(
    vararg products: ProductName,
    exportToKotlin: Boolean = false,
)
```
```

--------------------------------

### Add by Names

Source: https://spmforkmp.eu/references/dependency/productPackageConfig

Adds one or more product names to the product package configuration using their string representations. Products can be configured for export to Kotlin.

```APIDOC
## Add by Names

Adds one or more product names to the product package configuration using their string representation.

### Parameters

* **names** The string representations of the product names to be added. Each string corresponds to the name of the product within the Swift package ecosystem.
* **exportToKotlin** Determines whether the added products should be exported to Kotlin. Defaults to `false` if not specified.

### Function Signature

```kotlin
fun add(
    vararg names: String,
    exportToKotlin: Boolean = false,
)
```
```

--------------------------------

### Configure Swift Bridge Settings

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configure compiler and linker settings for building the Swift bridge, including unsafe flags for experimental features.

```kotlin
bridgeSettings {
    swiftSettings {
        unsafeFlags("-enable-experimental-feature", "StrictConcurrency")
    }
}

```

--------------------------------

### Legacy Swift Package Configuration

Source: https://spmforkmp.eu/usages/multiTarget

Define Swift package configurations for iOS and macOS using legacy syntax. This method is for build systems prior to version 1.1.0.

```kotlin
swiftPackageConfig {
    create("nativeIosShared") {
        // your embedded swift is inside the folder src/swift/nativeIosShared
        // your config for iOS
    }
    create("nativeMacosShared") {
        // your embedded swift is inside the folder src/swift/nativeMacosShared
        // your config for macOS
    }
}
```

--------------------------------

### Configure Gradle for xcFramework Import

Source: https://spmforkmp.eu/usages/importCLangFramework

Use this Gradle configuration to download and import the HevSocks5Tunnel xcFramework. Ensure `isCLang` is set to true for C-based frameworks.

```gradle
remoteBinary(
    url = uri("https://github.com/wanliyunyan/HevSocks5Tunnel/releases/download/2.10.0/HevSocks5Tunnel.xcframework.zip"),
    packageName = "HevSocks5Tunnel",
    exportToKotlin = true,
    checksum = "f66fc314edbdb7611c5e8522bc50ee62e7930f37f80631b8d08b2a40c81a631a",
    isCLang = true, // Required
)

```

--------------------------------

### Configure Linker Settings

Source: https://spmforkmp.eu/references/bridgeSettingsConfig

Configure linker settings for a target, including linked frameworks, linked libraries, and unsafe flags.

```kotlin
public fun linkerSetting(setting: LinkerSettingConfig.() -> Unit)
```

--------------------------------

### Configure Bridge Build Settings

Source: https://spmforkmp.eu/references/bridgeSettingsConfig

Use this block to configure C, C++, Swift, and linker settings for a target. It allows defining preprocessor macros, search paths, unsafe flags, linked frameworks/libraries, and Swift-specific features.

```kotlin
bridgeSettings {
    cSetting {
        defines = listOf(Pair("C_DEBUG", "2"))
        headerSearchPath = listOf("./includes/")
        unsafeFlags = listOf("-W")
    }
    cxxSetting {
        defines = listOf(Pair("CXX_DEBUG", "1"))
        headerSearchPath = listOf("./includes/")
        unsafeFlags = listOf("-W")
    }
    linkerSetting {
        linkedFramework = listOf("UIKit")
        linkedLibrary = listOf("-W")
        unsafeFlags = listOf("-W")
    }
    swiftSettings {
        defines = listOf("CUSTOM_DEFINE")
        enableExperimentalFeature = "CImplementation"
        enableUpcomingFeature = "ExistentialAny"
        interoperabilityMode = "Cxx"
    }
}

```

--------------------------------

### Apply SPM for KMP Plugin

Source: https://spmforkmp.eu/setup

Apply the plugin in your `build.gradle.kts` file. Replace `[version]` with the latest available version.

```kotlin
plugins {
    id("org.jetbrains.kotlin.multiplatform")
    id("io.github.frankois944.spmForKmp") version "[version]"
}
```

--------------------------------

### Configure Package Registry (URL only)

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configures a Swift package registry using only its URL. This is an alternative to Git-based package sources for dependency resolution.

```kotlin
registry(url = uri("https://registry.example.com"))

```

--------------------------------

### Configure C++ Build Settings

Source: https://spmforkmp.eu/references/bridgeSettingsConfig

Configure C++ build settings for a target, including defines, header search paths, and unsafe flags.

```kotlin
public fun cxxSetting(setting: CxxSettingConfig.() -> Unit)
```

--------------------------------

### Add ExoPlayer Dependencies for Android

Source: https://spmforkmp.eu/usages/distribution

Includes ExoPlayer and related libraries in the Android build for media playback.

```kotlin
androidMain.dependencies {
    implementation(libs.media3.exoplayer)
    implementation(libs.media3.exoplayer.dash)
    implementation(libs.media3.ui)
}
```

--------------------------------

### Legacy Bridge Configuration (< 1.1.0)

Source: https://spmforkmp.eu/bridge

This is the older way to configure the bridge using the swiftPackageConfig block.

```kotlin
swiftPackageConfig {
    create("[cinteropName]") {
    }
}

```

--------------------------------

### Add Remote Binary Dependency

Source: https://spmforkmp.eu/bridgeWithDependencies

Configure a remote binary framework by providing its URL and checksum. The plugin will download and include the specified binary framework.

```kotlin
remoteBinary(
    url = uri("https://.../RemoteBinaryFramework.xcframework.zip"),
    checksum = "[checksum]",
    packageName = "RemoteBinaryFramework",
)

```

--------------------------------

### Configure Swift Package for Multiple Targets

Source: https://spmforkmp.eu/setup

Configure `swiftPackageConfig` for multiple Apple targets in `build.gradle.kts`. Use `cinteropName` to share a single bridge across targets.

```kotlin
kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
        // and more Apple targets...
    ).forEach { target ->
        target.swiftPackageConfig(cinteropName = "[cinteropName]") {
            // creates src/swift/[cinteropName]/
        }
    }
}
```

--------------------------------

### Configure Swift Package for iOS Targets

Source: https://spmforkmp.eu/usages/multiTarget

Set up Swift package configurations for iOS ARM64 and simulator ARM64 targets. This is useful for managing embedded Swift code specific to these platforms.

```kotlin
kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
    ).forEach { target ->
        target.swiftPackageConfig(cinteropName = "nativeIosShared") {
            // your embedded swift is inside the folder src/swift/nativeIosShared
            // your config for iOS
        }
    }
}
```

--------------------------------

### Configure Swift Build Settings

Source: https://spmforkmp.eu/references/bridgeSettingsConfig

Configure Swift build settings for a target, including defines, experimental features, upcoming features, and interoperability mode.

```kotlin
public fun swiftSettings(setting: SwiftSettingConfig.() -> Unit)
```

--------------------------------

### Gradle Configuration for Local Swift Package

Source: https://spmforkmp.eu/usages/largebridge

Configures the Kotlin Multiplatform project to include a local Swift package. Specify the absolute path to the package and optionally which products to export to Kotlin.

```kotlin
kotlin {
    iosArm64 {
        swiftPackageConfig {
            localPackage(
                // absolute path to your Local Package
                path = "$projectDir/../MyStripeSDK",
                packageName = "MyStripeSDK",
                products = {
                    // Export to Kotlin for use in shared Kotlin code, false by default
                    add("MyStripeSDK", exportToKotlin = true)
                }
            )
        }
    }
}

```

--------------------------------

### Enable SPM Fork KMP Tracing

Source: https://spmforkmp.eu/section-help/tips

Add this flag to your `gradle.properties` file to enable detailed tracing for debugging.

```properties
spmforkmp.enableTracing=true

```

--------------------------------

### Implement KmpPlayer for Android

Source: https://spmforkmp.eu/usages/distribution

Provides the Android-specific implementation of the KmpPlayer using ExoPlayer.

```kotlin
@Composable
public actual fun KmpPlayer(modifier: Modifier, url: String) {

    val context = LocalContext.current

    // Initialize ExoPlayer
    val exoPlayer = ExoPlayer.Builder(context).build()

    val mediaSource = remember(url) {
        MediaItem.fromUri(url)
    }


    LaunchedEffect(url) {
        exoPlayer.setMediaItem(mediaSource)
        exoPlayer.prepare()
    }

    // Manage lifecycle events
    DisposableEffect(Unit) {
        onDispose {
            exoPlayer.release()
        }
    }

    AndroidView(
        factory = { ctx ->
            PlayerView(ctx).apply {
                player = exoPlayer
            }
        },
        modifier = modifier
    )
}
```

--------------------------------

### Configure Custom Swift Binary Path in build.gradle

Source: https://spmforkmp.eu/section-help/tips

Specify a custom path to the Swift binary if you need to use specific Swift toolchains or older Xcode versions. This is useful when managing multiple Swift versions with tools like `swiftly`.

```gradle
spm {
    // ...
    swiftBinPath = "/path/to/.swiftly/bin/swift"
}

```

--------------------------------

### Set Minimum iOS Deployment Target

Source: https://spmforkmp.eu/references/swiftPackageConfig

Define the minimum iOS deployment target for your Swift package. Setting this to null removes it from the manifest.

```kotlin
minIos = "16.0"

```

--------------------------------

### Configure Remote Package Version

Source: https://spmforkmp.eu/references/dependency/productPackageConfig

Define a remote package version with specified products. Use ProductName for explicit product identification.

```kotlin
remotePackageVersion(
    url = URI("https://github.com/appmetrica/appmetrica-sdk-ios"),
    version = "5.0.0",
    products = {
        add("AppMetricaCore", exportToKotlin = true)
    },
)
// or
remotePackageVersion(
    url = URI("https://github.com/appmetrica/appmetrica-sdk-ios"),
    version = "5.0.0",
    products = {
        add(ProductName("AppMetricaCore"), exportToKotlin = true)
    },
)
```

--------------------------------

### Configure Gradle Properties

Source: https://spmforkmp.eu/setup

Add `kotlin.mpp.enableCInteropCommonization=true` to your `gradle.properties` file to enable C interop commonization.

```properties
kotlin.mpp.enableCInteropCommonization=true
```

--------------------------------

### Set Minimum macOS Deployment Target

Source: https://spmforkmp.eu/references/swiftPackageConfig

Define the minimum macOS deployment target for your Swift package. Setting this to null removes it from the manifest.

```kotlin
minMacos = "12.0"

```

--------------------------------

### Swift Package Manifest Configuration

Source: https://spmforkmp.eu/usages/largebridge

Defines the structure, dependencies, and products of a Swift package. Ensure the Swift tools version and platform compatibility are correctly set.

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

import PackageDescription

let package = Package(
    name: "MyStripeSDK",
    platforms: [.iOS(.v14)],
    products: [
        // Products define the executables and libraries a package produces, making them visible to other packages.
        .library(
            name: "MyStripeSDK",
            targets: ["MyStripeSDK"]),
    ],
    dependencies: [
        .package(url: "https://github.com/stripe/stripe-ios-spm", .upToNextMajor(from: "24.5.0")),
    ],
    targets: [
        // Targets are the basic building blocks of a package, defining a module or a test suite.
        // Targets can depend on other targets in this package and products from dependencies.
        .target(
            name: "MyStripeSDK",
            dependencies: [
                .product(name: "Stripe", package: "stripe-ios-spm"),
                .product(name: "StripePaymentSheet", package: "stripe-ios-spm")
            ]),
        .testTarget(
            name: "MyStripeSDKTests",
            dependencies: [
                "MyStripeSDK"
            ]
        ),
    ]
)

```

--------------------------------

### enableExperimentalFeature

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Enable an experimental feature with the given name. Accepts a string.

```APIDOC
## enableExperimentalFeature

### Description
Enable an experimental feature with the given name.

### Type
String?
```

--------------------------------

### Configure Swift Package for macOS Target

Source: https://spmforkmp.eu/usages/multiTarget

Define Swift package configurations specifically for the macOS ARM64 target. This allows for platform-specific Swift code management on macOS.

```kotlin
kotlin {
    macosArm64 {
        swiftPackageConfig {
            // your embedded swift is inside the folder src/swift/macosArm64
            // your config for macOS
        }
    }
}
```

--------------------------------

### linkedFramework

Source: https://spmforkmp.eu/references/targetSettingsConfigs/LinkerSettingConfig

Declares linkage to a system framework. Accepts a list of framework names.

```APIDOC
## linkedFramework

Declares linkage to a system framework.

```swift
var linkedFramework: List<String>
```
```

--------------------------------

### Configure Swift Package Dependency for iOS

Source: https://spmforkmp.eu/usages/distribution

Sets up the Swift Package dependency for KSPlayer in the Kotlin project's Gradle configuration.

```kotlin
kotlin {
    iosArm64 {
        swiftPackageConfig(cinteropName = "appleDeps") {
            minIos = "13.0"
            minMacos = "10.15"
            minTvos = "13.0"
            minWatchos = "2.0"
            dependency {
                remotePackageBranch(
                    url = URI("https://github.com/kingslay/KSPlayer"),
                    products = {
                        add("KSPlayer")
                    },
                    branch = "main"
                )
            }
        }
    }
}
```

--------------------------------

### Enable Experimental Feature

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Use `enableExperimentalFeature` to enable an experimental feature by its name.

```swift
var enableExperimentalFeature: String?
```

--------------------------------

### Legacy Gradle Configuration for Exporting Dependencies

Source: https://spmforkmp.eu/exportingDependencies

Use this legacy Gradle configuration for exporting dependencies if you are on a version prior to 1.1.0. It achieves the same result of exporting specified products to Kotlin.

```kotlin
swiftPackageConfig {
    create("[cinteropName]") {
        dependency {
            remotePackageVersion(
                url = uri("https://github.com/firebase/firebase-ios-sdk"),
                version = "11.8.0",
                products = {
                    add("FirebaseAnalytics", exportToKotlin = true)
                    add("FirebaseCore")
                },
            )
        }
    }
}

```

--------------------------------

### Legacy macOS CInterop Configuration

Source: https://spmforkmp.eu/usages/multiTarget

Set up cinterop for macOS targets with legacy syntax. This is applicable for older build system versions (< 1.1.0).

```kotlin
listOf(
    macosArm64(),
).forEach {
    it.compilations {
        val main by getting {
            cinterops.create("nativeMacosShared") // a config for macos
        }
    }
}
```

--------------------------------

### Enable Debug Builds for Swift Package

Source: https://spmforkmp.eu/references/swiftPackageConfig

Build the Swift package in debug configuration instead of release. This is useful for development to include debug symbols, though release builds are faster.

```kotlin
debug = true

```

--------------------------------

### Set Minimum watchOS Deployment Target

Source: https://spmforkmp.eu/references/swiftPackageConfig

Define the minimum watchOS deployment target for your Swift package. Setting this to null removes it from the manifest.

```kotlin
minWatchos = "7.0"

```

--------------------------------

### Configure Shared SPM Config Path

Source: https://spmforkmp.eu/references/swiftPackageConfig

Sets the path for the shared Swift Package Manager configuration. This maps to the `--config-path` flag for the `swift package` command.

```kotlin
sharedConfigPath = "/path/to/shared/spm-config"

```

--------------------------------

### Set Minimum tvOS Deployment Target

Source: https://spmforkmp.eu/references/swiftPackageConfig

Define the minimum tvOS deployment target for your Swift package. Setting this to null removes it from the manifest.

```kotlin
minTvos = "16.0"

```

--------------------------------

### localPackage

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a local Swift package dependency. Use this for packages located on your local file system.

```APIDOC
## localPackage

### Description
Represents a local Swift package dependency.

### Parameters
#### Path Parameters
- **path** (String) - Required - The local file URL (file://...) to the local Swift package folder.
- **packageName** (String) - Optional - The name of the package, by default the first product name.
- **products** (ProductPackageConfig.() -> Unit) - Required - A list of the product's package used during dependency configuration.
```

--------------------------------

### Header Search Path Configuration

Source: https://spmforkmp.eu/references/targetSettingsConfigs/CSettingConfig

Specifies header search paths relative to the target's directory. Use for including header files.

```swift
var headerSearchPath: List<String>
```

--------------------------------

### Add Remote Package Version Dependency

Source: https://spmforkmp.eu/bridgeWithDependencies

Configure a remote Swift package by version in your `build.gradle.kts` file. Ensure the product name matches the library you intend to use.

```kotlin
kotlin {
    listOf(
        iosArm64(),
        iosSimulatorArm64()
        // and more Apple targets...
    ).forEach {
        target.swiftPackageConfig(cinteropName = "[cinteropName]") {
            dependency {
                remotePackageVersion(
                    url = uri("https://github.com/krzyzanowskim/CryptoSwift.git"),
                    version = "1.8.4",
                    products = {
                        add("CryptoSwift")
                    },
                )
                // more dependencies...
            }
        }
    }
}

```

--------------------------------

### Import xcFramework in Swift

Source: https://spmforkmp.eu/usages/importCLangFramework

This Swift code shows how to import the HevSocks5Tunnel framework and call its C functions. It uses `@objc` to make the class available for Objective-C interoperability.

```swift
import HevSocks5Tunnel
@objc public class MySwiftClass: NSObject {
    public func cMethod() {
        hev_socks5_tunnel_quit()
    }
}

```

--------------------------------

### Define Remote Swift Package by Version

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a specific version of a remote Swift package. Requires the Git repository URL, package name, and the specific version string. Products can be configured using a lambda.

```kotlin
fun remotePackageVersion(
    url: URI,
    packageName: String = "",
    version: String,
    products: ProductPackageConfig.() -> Unit,
)

```

--------------------------------

### Update Xcode Build Settings

Source: https://spmforkmp.eu/migration/migrateFromCocoapods

Configure Xcode's Build Settings by setting 'Other Linker Flags' to `-framework shared` and 'Framework Search Paths' to `$(SRCROOT)/../build/xcode-frameworks/$(CONFIGURATION)/$(SDK_NAME)`.

```text
Other Linker Flags | -framework shared
Framework Search Paths | $(SRCROOT)/../build/xcode-frameworks/$(CONFIGURATION)/$(SDK_NAME)
```

--------------------------------

### Configure Swift Package for Single Target

Source: https://spmforkmp.eu/setup

Configure `swiftPackageConfig` for a single target in `build.gradle.kts`. `cinteropName` is optional and defaults to the target name.

```kotlin
kotlin {
    iosArm64 {
        swiftPackageConfig {
            // creates src/swift/iosArm64/
        }
    }
}
```

--------------------------------

### Define Compilation Conditions

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Use `defines` to specify compilation conditions as a list of strings.

```swift
var defines: List<String>
```

--------------------------------

### enableUpcomingFeature

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Enable an upcoming feature with the given name. Accepts a string.

```APIDOC
## enableUpcomingFeature

### Description
Enable an upcoming feature with the given name.

### Type
String?
```

--------------------------------

### Configure Remote Package Version

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Use this to specify a remote Swift package with a specific version. Ensure the URL points to a Git repository and the version is valid.

```kotlin
dependency {
    remotePackageVersion(
        url = URI("https://github.com/appmetrica/appmetrica-sdk-ios"),
        version = "5.0.0",
        products = {
            add("AppMetricaCore", exportToKotlin = true)
        },
    )
}

```

--------------------------------

### Specify Swift Binary Path

Source: https://spmforkmp.eu/references/swiftPackageConfig

Set the path to the `swift` binary used for compiling the bridge. This allows overriding to use a specific Swift version or custom toolchain.

```kotlin
swiftBinPath = "/path/to/custom/swift"

```

--------------------------------

### Implement KmpPlayer for iOS

Source: https://spmforkmp.eu/usages/distribution

Provides the iOS-specific implementation of the KmpPlayer using a Swift bridge to KSPlayer.

```kotlin
import appleDeps.MEPlayerController

@Composable
public actual fun KmpPlayer(modifier: Modifier, url: String) {

    val playerController = MEPlayerController()

    val mediaSource = remember(url) {
        NSURL.URLWithString(url)
    }

    LaunchedEffect(url) {
        if (mediaSource == null) {
            throw Exception("Bad input URL")
        }
        playerController.setMediaItemWithVideoUrl(videoUrl = mediaSource)
    }

    DisposableEffect(Unit) {
        onDispose {
            playerController.releasePlayer()
        }
    }

    UIKitView(
        factory = {
            playerController.playerView() as UIView
        },
        modifier = modifier,
        update = {
        }
    )
}
```

--------------------------------

### Inspect Generated Module Maps

Source: https://spmforkmp.eu/section-help/faq

Use these paths to inspect the generated module maps during compilation. This helps verify if a product has an Objective-C compatible interface.

```bash
# Framework-based products
[project]/build/spmKmpPlugin/[cinteropName]/scratch/release/[product].framework/Modules/module.modulemap

# Static library products
[project]/build/spmKmpPlugin/[cinteropName]/scratch/release/[product].build/module.modulemap
```

--------------------------------

### Define Dummy Swift Classes for Objective-C Type Mapping

Source: https://spmforkmp.eu/section-help/tips

When cinterop struggles to recognize Objective-C types, create dummy Swift classes or use NSObject as a bridge to force inclusion and improve type mapping.

```swift
import UIKit

// Option 1: Force cinterop to include `platform.UIKit.UIView` via a dummy class
@objcMembers public class MyDummyView: UIView {}

// Option 2: Use inheritance or explicit NSObject mapping
@objcMembers public class TestClass: NSObject {

    // Simply returning `UIView` may not always be enough for cinterop
    public func getView() -> UIView {
        return UIView()
    }

    // Using NSObject can sometimes be more reliable for mapping
    public func getViewWithNSObject() -> NSObject {
        return UIView()
    }
}

```

```kotlin
import platform.UIKit.UIView

// In your Kotlin code:
fun getView(): UIView = TestClass().getView()

// Or with explicit casting if using the NSObject approach:
fun getViewCasted(): UIView = TestClass().getViewWithNSObject() as UIView

```

--------------------------------

### Define ProductName Data Class

Source: https://spmforkmp.eu/references/dependency/productName

Defines a data class for ProductName with a required name and an optional alias. Use this to represent product identifiers.

```kotlin
data class ProductName(
    val name: String,
    val alias: String? = null,
) : Serializable
```

--------------------------------

### Configure Shared SPM Security Path

Source: https://spmforkmp.eu/references/swiftPackageConfig

Sets the path for the shared Swift Package Manager security data. This maps to the `--security-path` flag for the `swift package` command.

```kotlin
sharedSecurityPath = "/path/to/shared/spm-security"

```

--------------------------------

### Add Remote Package Version Dependency (Legacy)

Source: https://spmforkmp.eu/bridgeWithDependencies

For older versions (< 1.1.0), configure a remote Swift package by version using the legacy `swiftPackageConfig` block in `build.gradle.kts`.

```kotlin
swiftPackageConfig {
    create("[cinteropName]") {
        dependency {
            remotePackageVersion(
                url = uri("https://github.com/krzyzanowskim/CryptoSwift.git"),
                version = "1.8.4",
                products = {
                    add("CryptoSwift")
                },
            )
        }
    }
}

```

--------------------------------

### Add Local Package Dependency

Source: https://spmforkmp.eu/bridgeWithDependencies

Configure a local Swift package by providing its absolute path. This is useful for developing or using local packages that are not yet published.

```kotlin
localPackage(
    path = "/absolute/path/to/local/package",
    packageName = "LocalSourceDummyFramework",
    products = {
        add("LocalSourceDummyFramework")
    },
)

```

--------------------------------

### registryPackage

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a dependency from a package registry. Use this for dependencies published to a registry.

```APIDOC
## registryPackage

### Description
Represents a registry-based dependency.

### Parameters
#### Path Parameters
- **id** (String) - Required - The unique identifier of the registry.
- **version** (String) - Required - The version of the dependency.
- **products** (ProductPackageConfig.() -> Unit) - Required - A list of the product's package used during dependency configuration.
```

--------------------------------

### Update Root build.gradle.kts

Source: https://spmforkmp.eu/migration/migrateFromCocoapods

In the root `build.gradle.kts`, apply the `spmForKmp` plugin and remove the `kotlinCocoapods` plugin.

```gradle
plugins {
    // this is necessary to avoid the plugins to be loaded multiple times
    // in each subproject's classloader
    alias(libs.plugins.kotlinMultiplatform) apply false
    -- alias(libs.plugins.kotlinCocoapods).apply(false)
    ++ alias(libs.plugins.spmForKmp).apply(false)
    alias(libs.plugins.composeMultiplatform).apply(false)
    alias(libs.plugins.composeCompiler).apply(false)
}
```

--------------------------------

### Declare includeProduct Variable

Source: https://spmforkmp.eu/references/exportedPackageConfig

Declare a variable to hold a list of product names to be manually included in the exported local package.

```kotlin
var includeProduct: List<String> = emptyList()
```

--------------------------------

### localBinary

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a local binary dependency. Use this to include local xcFrameworks as dependencies.

```APIDOC
## localBinary

### Description
Represents a local binary dependency.

### Parameters
#### Path Parameters
- **path** (String) - Required - The local file URL (file://...) to the xcFramework.
- **packageName** (String) - Required - The name of the package associated with this binary.
- **exportToKotlin** (Boolean) - Optional - Defines whether the dependency should be exported for use in Kotlin code. Defaults to false.
- **isCLang** (Boolean) - Optional - Specify if the binary is a C language framework. Defaults to false.
```

--------------------------------

### linkedLibrary

Source: https://spmforkmp.eu/references/targetSettingsConfigs/LinkerSettingConfig

Declares linkage to a system library. Accepts a list of library names.

```APIDOC
## linkedLibrary

Declares linkage to a system library.

```swift
var linkedLibrary: List<String>
```
```

--------------------------------

### Accessing Bundled Resources in Swift

Source: https://spmforkmp.eu/bridge

Retrieve resources bundled with the bridge using `Bundle.module`. Ensure resources are placed in the correct `Resources-` folder (e.g., `Resources-process`).

```swift
let url = Bundle.module.url(forResource: "bridgeString", withExtension: "txt")

```

--------------------------------

### Set Package Dependency Product Name Prefix

Source: https://spmforkmp.eu/references/swiftPackageConfig

Apply a prefix to all dependency product names when imported into Kotlin. This is useful for avoiding name collisions or restoring the `cocoapods.` prefix style.

```kotlin
// Without prefix:  import FirebaseCore.FIRApp
// With prefix:     import myPrefix.FirebaseCore.FIRApp
packageDependencyPrefix = "myPrefix"

```

--------------------------------

### Add Linker Flags for Cinterop

Source: https://spmforkmp.eu/references/swiftPackageConfig

Provide additional linker flags that will be passed during cinterop processing.

```kotlin
linkerOpts = listOf("-lz", "-framework", "Security")

```

--------------------------------

### Set Custom Swift Bridge Source Path

Source: https://spmforkmp.eu/references/swiftPackageConfig

Specify a custom directory for Swift bridge source files. The plugin copies and compiles these files into the build directory.

```kotlin
swiftPackageConfig(cinteropName = "nativeBridge") {
    customPackageSourcePath = "src/custom/swift"
}

```

--------------------------------

### interoperabilityMode

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Enable Swift interoperability with a given language. Available values are C, Cxx. Accepts a string.

```APIDOC
## interoperabilityMode

### Description
Enable Swift interoperability with a given language.
available values : C, Cxx

### Type
String?
```

--------------------------------

### Define Local Binary Dependency

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a local binary dependency. Provide the path to the xcFramework, package name, and optionally specify if it should be exported for Kotlin or if it's a C language framework.

```kotlin
fun localBinary(
    path: String,
    packageName: String,
    exportToKotlin: Boolean = false,
    isCLang: Boolean = false,
)

```

--------------------------------

### Define Local Swift Package Dependency

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a local Swift package dependency. Specify the local file path to the package folder and the package name. Products can be configured using a lambda.

```kotlin
fun localPackage(
    path: String,
    packageName: String = "",
    products: ProductPackageConfig.() -> Unit,
)

```

--------------------------------

### Legacy iOS CInterop Configuration

Source: https://spmforkmp.eu/usages/multiTarget

Configure cinterop for iOS targets using legacy syntax. This approach is for older versions of the build system (< 1.1.0).

```kotlin
listOf(
    iosX64(),
    iosSimulatorArm64(),
).forEach {
    it.compilations {
        val main by getting {
            cinterops.create("nativeIosShared") // a config for iOS
        }
    }
}
```

--------------------------------

### Configure Shared SPM Cache Path

Source: https://spmforkmp.eu/references/swiftPackageConfig

Sets the path for the shared Swift Package Manager cache. This maps to the `--cache-path` flag for the `swift package` command, useful for sharing SPM state across modules.

```kotlin
sharedCachePath = "/path/to/shared/spm-cache"

```

--------------------------------

### Override Minimum OS Version for Swift Concurrency in iOS Tests

Source: https://spmforkmp.eu/section-help/tips

If KMP tests fail due to Swift Concurrency (`libswift_Concurrency.dylib`), override the minimum deployment target for your test binaries to iOS 15.0 or higher.

```kotlin
kotlin {
    iosSimulatorArm64().binaries.getTest("debug").apply {
        freeCompilerArgs += listOf(
            "-Xoverride-konan.properties=osVersionMin.ios_simulator_arm64=16.0",
        )
    }
}

```

--------------------------------

### Enable Upcoming Feature

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Use `enableUpcomingFeature` to enable an upcoming feature by its name.

```swift
var enableUpcomingFeature: String?
```

--------------------------------

### Define Remote Swift Package by Commit

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a remote Swift dependency based on a specific commit hash. Requires the Git repository URL, the commit revision, and package name. Products can be configured using a lambda.

```kotlin
fun remotePackageCommit(
    url: URI,
    packageName: String = "",
    revision: String,
    products: ProductPackageConfig.() -> Unit,
)

```

--------------------------------

### Update Gradle Versions Catalog

Source: https://spmforkmp.eu/migration/migrateFromCocoapods

Add the `spmForKmp` plugin to your `libs.versions.toml` file and remove the `kotlinCocoapods` plugin.

```toml
++ spmForKmp = "1.0.4"

[plugins]
composeMultiplatform = { id = "org.jetbrains.compose", version.ref = "compose-multiplatform" }
composeCompiler = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
kotlinMultiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
-- kotlinCocoapods = { id = "org.jetbrains.kotlin.native.cocoapods", version.ref = "kotlin" }
++ spmForKmp = { id = "io.github.frankois944.spmForKmp", version.ref = "spmForKmp" }
```

--------------------------------

### remoteBinary

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a remote binary dependency as a zipped xcFramework. Use this for dependencies hosted remotely.

```APIDOC
## remoteBinary

### Description
Represents a remote binary dependency as a zipped xcFramework.

### Parameters
#### Path Parameters
- **url** (URI) - Required - The URL pointing to the remote binary artifact.
- **packageName** (String) - Required - The name of the package associated with this binary dependency.
- **exportToKotlin** (Boolean) - Optional - Defines whether this dependency should be exported for use in Kotlin code. Defaults to false.
- **checksum** (String) - Required - The checksum of the remote binary to verify its integrity.
- **isCLang** (Boolean) - Optional - Specify if the binary is a C language framework. Defaults to false.
```

--------------------------------

### Set Swift Tools Version

Source: https://spmforkmp.eu/references/swiftPackageConfig

Specify the Swift tools version for the `Package.swift` manifest header. This controls available SPM features and manifest APIs.

```kotlin
toolsVersion = "5.9"

```

--------------------------------

### Exported Package Settings for Xcode

Source: https://spmforkmp.eu/references/swiftPackageConfig

Configures the local Swift package generated for Xcode integration. Use this to expose bridge dependencies to your Xcode app target.

```kotlin
exportedPackageSettings {
    includeProduct("FirebaseCore")
}

```

--------------------------------

### Disable Gradle Caching

Source: https://spmforkmp.eu/section-help/issues

Workaround for 'Failed to Store Cache Entry' by disabling Gradle's build and configuration caching. Add these lines to your `gradle.properties` file.

```properties
org.gradle.caching=false
org.gradle.configuration-cache=false

```

--------------------------------

### Create Objective-C Bridge for KSPlayer

Source: https://spmforkmp.eu/usages/distribution

A Swift class to bridge Kotlin/Swift interactions with the native KSPlayer library.

```swift
import Foundation
import KSPlayer

@objcMembers public class MEPlayerController: NSObject {
     private let player = IOSVideoPlayerView()

    override init() {
       super.init()
       KSOptions.secondPlayerType = KSMEPlayer.self
       player.delegate = self
       player.autoresizingMask = [.flexibleWidth, .flexibleHeight]
       player.contentMode = .scaleAspectFill
    }

    public func setMediaItem(videoUrl: URL) {
       player.set(
          url: videoUrl,
          options: KSOptions()
      )
    }

    public var playerView: NSObject {
       player
    }

    public func releasePlayer() {
       player.resetPlayer()
       player.removeFromSuperview()
    }
}
```

--------------------------------

### HevSocks5Tunnel C Headers

Source: https://spmforkmp.eu/usages/importCLangFramework

These are the header files for the HevSocks5Tunnel library, defining the functions and structures used by the C framework.

```c
/*
============================================================================
Name        : hev-main.h
Author      : hev <r@hev.cc>
Copyright   : Copyright (c) 2019 - 2023 hev
Description : Main
============================================================================
*/

#ifndef __HEV_MAIN_H__
#define __HEV_MAIN_H__

#include <stddef.h>

#ifdef __cplusplus
extern "C" {
#endif

/**
* hev_socks5_tunnel_main:
* @config_path: config file path
* @tun_fd: tunnel file descriptor
*
* Start and run the socks5 tunnel, this function will blocks until the
* hev_socks5_tunnel_quit is called or an error occurs.
*
* Returns: returns zero on successful, otherwise returns -1.
*
* Since: 2.4.6
*/
int hev_socks5_tunnel_main (const char *config_path, int tun_fd);

/**
* hev_socks5_tunnel_main_from_file:
* @config_path: config file path
* @tun_fd: tunnel file descriptor
*
* Start and run the socks5 tunnel, this function will blocks until the
* hev_socks5_tunnel_quit is called or an error occurs.
*
* Returns: returns zero on successful, otherwise returns -1.
*
* Since: 2.6.7
*/
int hev_socks5_tunnel_main_from_file (const char *config_path, int tun_fd);

/**
* hev_socks5_tunnel_main_from_str:
* @config_str: string config
* @config_len: the byte length of string config
* @tun_fd: tunnel file descriptor
*
* Start and run the socks5 tunnel, this function will blocks until the
* hev_socks5_tunnel_quit is called or an error occurs.
*
* Returns: returns zero on successful, otherwise returns -1.
*
* Since: 2.6.7
*/
int hev_socks5_tunnel_main_from_str (const unsigned char *config_str,
unsigned int config_len, int tun_fd);

/**
* hev_socks5_tunnel_quit:
*
* Stop the socks5 tunnel.
*
* Since: 2.4.6
*/
void hev_socks5_tunnel_quit (void);

/**
* hev_socks5_tunnel_stats:
* @tx_packets (out): transmitted packets
* @tx_bytes (out): transmitted bytes
* @rx_packets (out): received packets
* @rx_bytes (out): received bytes
*
* Retrieve tunnel interface traffic statistics.
*
* Since: 2.6.5
*/
void hev_socks5_tunnel_stats (size_t *tx_packets, size_t *tx_bytes,
size_t *rx_packets, size_t *rx_bytes);

#ifdef __cplusplus
}
#endif

#endif /* __HEV_MAIN_H__ */

```

--------------------------------

### Add SPM Run Script Phase in Xcode

Source: https://spmforkmp.eu/migration/migrateFromCocoapods

Add a new 'Run Script' phase to your Xcode project's Build Phases, place it at the top, and paste the provided script to embed and sign the Apple framework.

```bash
cd "$SRCROOT/../../"
./gradlew :shared:embedAndSignAppleFrameworkForXcode

```

--------------------------------

### Define KmpPlayer Interface

Source: https://spmforkmp.eu/usages/distribution

Defines the cross-platform interface for the KmpPlayer component.

```kotlin
@Composable
public expect fun KmpPlayer(modifier: Modifier = Modifier, url: String)
```

--------------------------------

### Define Registry Package Dependency

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a dependency from a package registry. Requires the registry ID, version, and configuration for products.

```kotlin
public fun registryPackage(
    id: String,
    version: String,
    products: ProductPackageConfig.() -> Unit,
)

```

--------------------------------

### Define Remote Swift Package by Branch

Source: https://spmforkmp.eu/references/dependency/dependencyConfig

Represents a remote Swift dependency based on a specific branch. Requires the Git repository URL, branch name, and package name. Products can be configured using a lambda.

```kotlin
fun remotePackageBranch(
    url: URI,
    packageName: String = "",
    branch: String,
    products: ProductPackageConfig.() -> Unit,
)

```

--------------------------------

### Declare Linkage to a System Framework

Source: https://spmforkmp.eu/references/targetSettingsConfigs/LinkerSettingConfig

Use `linkedFramework` to declare linkage to a system framework. This property expects a list of strings, where each string is the name of a framework.

```swift
var linkedFramework: List<String>
```

--------------------------------

### Call C Function from Kotlin

Source: https://spmforkmp.eu/usages/importCLangFramework

This Kotlin code demonstrates how to call the `hev_socks5_tunnel_quit` function from the imported C framework. Ensure the `kotlinx.cinterop.ExperimentalForeignApi` annotation is used.

```kotlin
import HevSocks5Tunnel.hev_socks5_tunnel_quit

@OptIn(kotlinx.cinterop.ExperimentalForeignApi::class)
fun test() {
    hev_socks5_tunnel_quit()
}

```

--------------------------------

### Swift Code for KMP Integration

Source: https://spmforkmp.eu/usages/largebridge

Swift code intended for use in a Kotlin Multiplatform project must be marked with `@objc` or `@objcMembers` and have `public` visibility to be exported correctly.

```swift
import StripePaymentSheet

@objcMembers public class MyStripeSDK: NSObject {

    private var paymentSheet: PaymentSheet?
    private var paymentIntentClientSecret: String
    private let backendCheckoutUrl = URL(string: "Your backend endpoint/payment-sheet")

    public init(paymentIntentClientSecret: String) {
        self.paymentIntentClientSecret = paymentIntentClientSecret
    }

    public func doStripeJob() {
        var configuration = PaymentSheet.Configuration()
        configuration.merchantDisplayName = "Example, Inc."
        self.paymentSheet = PaymentSheet(paymentIntentClientSecret: self.paymentIntentClientSecret,
                                         configuration: configuration)
    }
}

```

--------------------------------

### Declare name Variable

Source: https://spmforkmp.eu/references/exportedPackageConfig

Declare an optional string variable to set the exported product name. Defaults to `exported[cinteropName]`.

```kotlin
var name: String? = null
```

--------------------------------

### Specify Swift Toolchain

Source: https://spmforkmp.eu/references/swiftPackageConfig

Set the Swift toolchain identifier to use when building the package. Refer to Custom Swift Versions & Toolchains for more details.

```kotlin
toolchain = "swift-DEVELOPMENT-SNAPSHOT-2024-01-01"

```

--------------------------------

### Defines Macro Values

Source: https://spmforkmp.eu/references/targetSettingsConfigs/CSettingConfig

Defines a list of key-value pairs for macros. Use when setting preprocessor macros.

```swift
var defines: List<Pair<String, String?>>
```

--------------------------------

### Configure SPM Working Path in build.gradle.kts

Source: https://spmforkmp.eu/section-help/tips

Change the default location of SPM working files to prevent them from being deleted during `./gradlew clean`. This can also improve IDE responsiveness by excluding the folder from indexing.

```kotlin
swiftPackageConfig {
    // ...
    spmWorkingPath = "${projectDir.resolve("SPM")}"
}

```

--------------------------------

### headerSearchPath

Source: https://spmforkmp.eu/references/targetSettingsConfigs/CxxSettingConfig

Provides a header search path relative to the target's directory. This allows specifying directories where the compiler should look for header files.

```APIDOC
## headerSearchPath

### Description
Provides a header search path relative to the target’s directory.

### Type
`List<String>`
```

--------------------------------

### Unsafe Flags for Build Tools

Source: https://spmforkmp.eu/references/targetSettingsConfigs/CSettingConfig

Sets unsafe flags to pass arbitrary command-line flags to the build tool. Use with caution for advanced configurations.

```swift
var unsafeFlags: List<String>
```

--------------------------------

### Enable New Publication Interoperability

Source: https://spmforkmp.eu/references/swiftPackageConfig

Enables the experimental C/Objective-C interoperability mode introduced in Kotlin 2.3.20. This applies to both the bridge and exported products. Do not publish KMP libraries compiled with this mode enabled as it is not yet stable for distribution.

```kotlin
newPublicationInteroperability = true

```

--------------------------------

### defines

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Defines a compilation condition. Accepts a list of strings.

```APIDOC
## defines

### Description
Defines a compilation condition.

### Type
List<String>
```

--------------------------------

### headerSearchPath

Source: https://spmforkmp.eu/references/targetSettingsConfigs/CSettingConfig

Provides a header search path relative to the target's directory. This property accepts a list of strings, where each string is a path to a directory containing header files.

```APIDOC
## headerSearchPath

### Description
Provides a header search path relative to the target’s directory.

### Type
List<String>
```

--------------------------------

### Add Remote Package Commit Dependency

Source: https://spmforkmp.eu/bridgeWithDependencies

Configure a remote Swift package by specifying a specific commit hash. This ensures reproducible builds by using an exact version of the package.

```kotlin
remotePackageCommit(
    url = uri("https://github.com/krzyzanowskim/CryptoSwift.git"),
    revision = "729e01bc9b9dab466ac85f21fb9ee2bc1c61b258",
    products = {
        add("CryptoSwift")
    },
)

```

--------------------------------

### unsafeFlags

Source: https://spmforkmp.eu/references/targetSettingsConfigs/SwiftSettingConfig

Set unsafe flags to pass arbitrary command-line flags to the corresponding build tool. Accepts a list of strings.

```APIDOC
## unsafeFlags

### Description
Set unsafe flags to pass arbitrary command-line flags to the corresponding build tool.

### Type
List<String>
```
Tokens:
Raw