KotlinViteExec¶

@CacheableTask
abstract class KotlinViteExec @Inject constructor(
    process: ExecOperations, 
    targetName: String, 
    targetType: String
) : ViteExec, RequiresNpmDependencies

A specialization of ViteExec that uses the Kotlin Gradle Plugin to download Vite.

Constructors¶

KotlinViteExec¶

@Inject
constructor(
    process: ExecOperations, 
    targetName: String, 
    targetType: String
)

Properties¶

`actions`¶

open var actions: List<Action<in Task?>?>?

`ant`¶

open val ant: AntBuilder?

`arguments`¶

@get:Input
abstract val arguments: ListProperty<String>

`asDynamicObject`¶

@get:Internal
open val asDynamicObject: DynamicObject

`command`¶

@get:Input
@get:Optional
abstract val command: Property<String>

compilation¶

@get:Internal
open override val compilation: KotlinJsIrCompilation

`config`¶

abstract val config: ViteConfig

`configurationFile`¶

@get:InputFile
@get:PathSensitive(value = PathSensitivity.RELATIVE)
abstract val configurationFile: RegularFileProperty

`dependsOn`¶

open val dependsOn: Set<Any?>?

`description`¶

open var description: @Nullable String?

`destroyables`¶

open val destroyables: TaskDestroyables?

`didWork`¶

open var didWork: Boolean

`enabled`¶

open var enabled: Boolean

`extensions`¶

open val extensions: ExtensionContainer?

`finalizedBy`¶

open val finalizedBy: TaskDependency?

`group`¶

open var group: @Nullable String?

`identityPath`¶

open val identityPath: Path?

`impliesSubProjects`¶

open var impliesSubProjects: Boolean

`inputs`¶

open val inputs: TaskInputsInternal?

`isCompatibleWithConfigurationCache`¶

open val isCompatibleWithConfigurationCache: Boolean

`isEnabled`¶

@get:Internal
open var isEnabled: Boolean

`isHasCustomActions`¶

open val isHasCustomActions: Boolean

`lifecycleDependencies`¶

@get:Internal
open val lifecycleDependencies: TaskDependencyInternal?

`localState`¶

open val localState: TaskLocalState?

`logger`¶

open val logger: Logger?

`logging`¶

open val logging: LoggingManager?

`mustRunAfter`¶

open val mustRunAfter: TaskDependency?

`name`¶

open val name: String?

`nodePath`¶

@get:Internal
abstract val nodePath: RegularFileProperty

`onlyIf`¶

open val onlyIf: Spec<in TaskInternal?>?

`outputs`¶

open val outputs: TaskOutputsInternal?

`path`¶

@get:Internal
open override val path: String

`project`¶

open val project: Project?

`reasonNotToTrackState`¶

open val reasonNotToTrackState: Optional<String?>?

`reasonsNotToTrackState`¶

open val reasonsNotToTrackState: Set<String?>?

`reasonTaskIsIncompatibleWithConfigurationCache`¶

open val reasonTaskIsIncompatibleWithConfigurationCache: Optional<String?>?

requiredNpmDependencies¶

@get:Internal
open override val requiredNpmDependencies: Set<RequiredKotlinJsDependency>

`requiredServices`¶

open val requiredServices: TaskRequiredServices?

`sharedResources`¶

open val sharedResources: List<ResourceLock?>?

`shouldRunAfter`¶

open val shouldRunAfter: TaskDependency?

`standardOutputCapture`¶

open val standardOutputCapture: StandardOutputCapture?

`state`¶

open val state: TaskStateInternal?

`taskActions`¶

open val taskActions: List<InputChangesAwareTaskAction?>?

`taskDependencies`¶

open val taskDependencies: TaskDependencyInternal?

`taskIdentity`¶

open val taskIdentity: TaskIdentity<*>?

`temporaryDir`¶

open val temporaryDir: File?

`temporaryDirFactory`¶

open val temporaryDirFactory: Factory<File?>?

`timeout`¶

open val timeout: Property<Duration?>?

`vitePath`¶

@get:InputFile
@get:PathSensitive(value = PathSensitivity.RELATIVE)
abstract val vitePath: RegularFileProperty

`workingDirectory`¶

@get:Input
abstract val workingDirectory: Property<String>

Functions¶

`acceptServiceReferences`¶

open fun acceptServiceReferences(serviceReferences: Set<ServiceReferenceSpec?>?)

`appendParallelSafeAction`¶

open fun appendParallelSafeAction(action: Action<in Task?>?)

`compareTo`¶

open operator fun compareTo(otherTask: Task?): Int

`config`¶

fun config(block: ViteConfig.() -> Unit): ViteConfig

`configure`¶

open fun configure(closure: Closure<*>?): Task?

`dependsOn`¶

open fun dependsOn(vararg paths: Any?): Task?

`doFirst`¶

open fun doFirst(action: Closure<*>?): Task?

open fun doFirst(action: Action<in Task?>?): Task?

open fun doFirst(actionName: String?, action: Action<in Task?>?): Task?

`doLast`¶

open fun doLast(action: Closure<*>?): Task?

open fun doLast(action: Action<in Task?>?): Task?

open fun doLast(actionName: String?, action: Action<in Task?>?): Task?

`doNotTrackState`¶

open fun doNotTrackState(reasonNotToTrackState: String?)

`doNotTrackStateIf`¶

open fun doNotTrackStateIf(reason: String?, spec: Spec<in TaskInternal?>?)

`execute`¶

fun execute()

`finalizedBy`¶

open fun finalizedBy(vararg paths: Any?): Task?

`getPath`¶

@Internal
open fun getPath(): String

`hasProperty`¶

open fun hasProperty(propertyName: String?): Boolean

`hasTaskActions`¶

open fun hasTaskActions(): Boolean

`mustRunAfter`¶

open fun mustRunAfter(vararg paths: Any?): Task?

`notCompatibleWithConfigurationCache`¶

open fun notCompatibleWithConfigurationCache(reason: String?)

`onlyIf`¶

open fun onlyIf(onlyIfClosure: Closure<*>?)

open fun onlyIf(spec: Spec<in Task?>?)

open fun onlyIf(onlyIfReason: String?, spec: Spec<in Task?>?)

`prependParallelSafeAction`¶

open fun prependParallelSafeAction(action: Action<in Task?>?)

`property`¶

open fun property(propertyName: String?): Any?

`restoreOnlyIf`¶

open fun restoreOnlyIf(onlyIf: Spec<in TaskInternal?>?)

`restoreTaskActions`¶

open fun restoreTaskActions(taskActions: List<InputChangesAwareTaskAction?>?)

`setDependsOn`¶

open fun setDependsOn(dependsOn: Iterable<*>?)

`setFinalizedBy`¶

open fun setFinalizedBy(finalizedByTasks: Iterable<*>?)

`setMustRunAfter`¶

open fun setMustRunAfter(mustRunAfterTasks: Iterable<*>?)

`setOnlyIf`¶

open fun setOnlyIf(onlyIfClosure: Closure<*>?)

open fun setOnlyIf(spec: Spec<in Task?>?)

open fun setOnlyIf(onlyIfReason: String?, spec: Spec<in Task?>?)

`setProperty`¶

open fun setProperty(name: String?, value: Any?)

`setShouldRunAfter`¶

open fun setShouldRunAfter(shouldRunAfterTasks: Iterable<*>?)

`shouldRunAfter`¶

open fun shouldRunAfter(vararg paths: Any?): TaskDependency?

`usesService`¶

open fun usesService(service: Provider<out BuildService<*>?>?)