plugins {
    id 'ru.vyarus.teavm' version '1.2.0'
}

buildscript {
    repositories {
        gradlePluginPortal()
    }
    dependencies {
        classpath 'ru.vyarus:gradle-teavm-plugin:1.2.0'
    }
}
apply plugin: 'ru.vyarus.teavm'

ext {
  teavm = '0.9.0-dev-15'
}
repositories { 
  mavenCentral()
  maven { url "https://teavm.org/maven/repository" }
}
dependencies {
    implementation "org.teavm:teavm-classlib:$teavm"
    implementation "org.teavm:teavm-jso-apis:$teavm"
}

teavm {
  dev = false
  mainClass = 'com.foo.Client'
}

tasks.register('buildWebapp', Copy) {
    from('src/main/webapp')
    from(compileTeavm) {
        into 'js'
    }
    into 'build/webapp'
}

teavm {
  targetDir = 'build/webapp'
}

tasks.register('buildWebapp', Copy) {
    from('src/main/webapp')   
    into 'build/webapp'
}

{
    /**
     * Enables dev mode: use options from "devOptions" configuration.
     */
    dev = false
    /**
     * Prints plugin debug information: used paths, dependencies, resolved sources and complete teavm stats.
     */
    debug = false
    /**
     * Configures processResources task to load resources from java/kotlin/scala directories (ignoring compiled
     * sources). Useful for flavour when html templates stored near source files.
     */
    mixedResources = false
    /**
     * Detect teavm version from classpath (see "configurations") in order to use the same version for compilation.
     * When enabled, "version" option is ignored.
     */
    autoVersion = true
    /**
     * Teavm version to use. Ignored when "autoVersion" enabled.
     */
    version = "0.9.0"

    /**
     * Source sets to compile js from. By default, java, kotlin and scala supported.
     */
    sourceSets = ["main", "kotlin", "scala"]
    /**
     * Configurations with required dependencies (by default, runtimeClasspath). There is no alternative for direct
     * dependency jars specification - local jar files could always be configured in configuration.
     */
    configurations = ["runtimeClasspath"]
    /**
     * Additional directories with compiled classes. Normally, this should not be needed as "sourceSets"
     * already describe required directories. Could be useful only for specific cases.
     * Values: strings with absolute or relative directories locations. 
     */
    extraClassDirs = []
    /**
     * Additional source directories (used only when "sourceFilesCopied" enabled). Normally, this should not
     * be needed as sources already described with "sourceSets" and dependencies sources are resolved
     * from "configurations".
     * All jars contained in configured directories (1st level) would be also added.
     * Values: strings with absolute or relative directories locations. 
     */
    extraSourceDirs = []
    /**
     * Target compilation directory. By default, "build/teavm".
     */
    targetDir = 'build/teavm'
    /**
     * Teavm cache directory. By default, "build/teavm-cache".
     */
    cacheDir = 'build/teavm-cache'

    /**
     * Main application class (required).
     */
    mainClass
    /**
     * Entry point name (entry static method).
     */
    entryPointName = "main"
    /**
     * Output file name. By default, empty to let teavm automatically select file name by compilation target:
     * classes.js, classes.wasm, etc. (see org.teavm.tooling.TeaVMTool#getResolvedTargetFileName()).
     */
    targetFileName = ""
    /**
     * Compilation target: js by default. Values: JAVASCRIPT, WEBASSEMBLY, WEBASSEMBLY_WASI, C
     */
    targetType = JAVASCRIPT
    /**
     * Javascript module type: UMD by default. Values: COMMON_JS, UMD, NONE, ES2015
     */
    jsModuleType = UMD
    /**
     * Target wasm version (only for compilation to WASM). Values: V_0x1
     */
    wasmVersion = V_0x1

    /**
     * Fail on compilation error.
     */
    stopOnErrors = true
    /**
     * Minify files. Should be enabled for production, but disabled for dev.
     */
    obfuscated = true
    /**
     * Strict teavm mode.
     */
    strict = false
    /**
     * Copy java sources into generated folder so they could be loaded in browser through source maps (see
     * "sourceMapsGenerated").
     */
    sourceFilesCopied = false
    /*
     * Put links to local source files instead of copying them. Do nothing when "sourceFilesCopied" disabled.
     * Make sense only for local development.
     */
    sourceFilesCopiedAsLocalLinks = false
    /**
     * Incremental compilation speeds up compilation, but limits some optimizations and so should be used only
     * in dev mode.
     */
    incremental = false
    /**
     * Generate debug information required for debug server (started from IDE).
     */
    debugInformationGenerated = false
    /**
     * Generate source maps. In oder to be able to debug sources in browser enable "sourceFilesCopied".
     */
    sourceMapsGenerated = false
    /**
     * Short file names. ONLY for C target.
     */
    shortFileNames = false
    /**
     * Heap dump. ONLY for C target.
     */
    heapDump = false
    /**
     * Fast dependency analysis. Probably, could speed up compilation. ONLY for development! (option disables
     * "optimizationLevel" setting).
     */
    fastDependencyAnalysis = false
    /**
     * Remove assertions.
     */
    assertionsRemoved = false        

    /**
     * Top-level names limit. ONLY for JS target.
     */
    maxTopLevelNames = 80000
    /**
     * Minimal heap size (in mb). ONLY for WASM and C targets.
     */
    minHeapSize = 4
    /**
     * Maximum heap size (in mb). ONLY for WASM and C targets.
     */
    maxHeapSize = 128
    /**
     * Output optimization level.
     * SIMPLE – perform only basic optimizations, remain friendly to the debugger (recommended for development).
     * ADVANCED – perform more optimizations, sometimes may stuck debugger (recommended for production).
     * FULL – perform aggressive optimizations, increase compilation time, sometimes can make code even slower
     * (recommended for WebAssembly).
     */
    optimizationLevel = ADVANCED
    /**
     * An array of fully qualified class names. Each class must implement
     * "org.teavm.model.ClassHolderTransformer" interface and have a public no-argument constructor. These
     * transformers are used to transform ClassHolders, that are SSA-based representation of JVM classes. Transformers
     * run right after parsing JVM classes and producing SSA representation.
     */
    transformers = []
    /**
     * Properties passed to all TeaVM plugins (usage examples unknown).
     * Values: map of strings (key and value) 
     */
    properties = [:]
    /**
     * Fully qualified class names to preserve (probably, to avoid remove by dependency analysis).
     */
    classesToPreserve=[]

teavm {
  devOptions {
    obfuscated = false
    strict = false
    sourceFilesCopied = true
    sourceFilesCopiedAsLocalLinks = true
    incremental = false
    debugInformationGenerated = true
    sourceMapsGenerated = true
    fastDependencyAnalysis = false
    assertionsRemoved = false
    optimizationLevel = SIMPLE
    
    // C target ONLY
    shortFileNames = false
    heapDump = false
  }
}

teavm.sourceSets = ["main", "kotlin", "scala"]

teavm {
  extraClassDirs = ['/path/to/classes']
  extraSourceDirs = ['/path/to/sources']
}

teavm.debug = true

tasks.register('myTeavm', TeavmCompileTask) {
  ...
}

  debug = false
  classPath = 
  dependencies =
  sources = 
  sourceDependencies =  
  targetDir = 
  cacheDir =
  mainClass = 
  entryPointName =  
  targetFileName =
  targetType = 
  jsModuleType =
  wasmVersion =
  stopOnErrors = 
  obfuscated = 
  strict =
  sourceFilesCopied =
  incremental =   
  debugInformationGenerated =   
  sourceMapsGenerated =  
  shortFileNames =
  heapDump =
  fastDependencyAnalysis =
  assertionsRemoved =        
  maxTopLevelNames =
  minHeapSize =
  maxHeapSize =
  optimizationLevel =
  transformers =
  properties =  
  classesToPreserve =        

tasks.register('myTeavm', TeavmCompileTask) {
  // list of dirs with compiled classes
  classPath = [layout.buildDirectory.dir('generated-source')]
  // all required jars
  dependencies = configurations.findByName('custom')   
  // sources required ONLY when sourceFilesCopied = true 
  sources = [layout.projectDirectory.dir('src/main/java')]
}