JSweetTranspiler (JSweet transpiler 2.2.0-SNAPSHOT API)

java.lang.Object
- org.jsweet.transpiler.JSweetTranspiler

All Implemented Interfaces:

JSweetOptions
```
public class JSweetTranspiler
extends Object
implements JSweetOptions
```
The actual JSweet transpiler.
Instantiate this class to transpile Java to TypeScript (phase 1), and TypeScript to JavaScript (phase 2).
There are 2 phases in JSweet transpilation:
1. Java to TypeScript
2. TypeScript to JavaScript
In phase 1, JSweet delegates to Javac and applies the Java2TypeScriptTranslator AST visitor to print out the TypeScript code. Before printing out the code, the transpiler first applies AST visitors: GlobalBeforeTranslationScanner, StaticInitilializerAnalyzer, and TypeChecker. All external referenced classes must be in the classpath for this phase to succeed. Note that this generation is fully customizable with the org.jsweet.transpiler.extension API.
In phase 2, JSweet delegates to tsc (TypeScript). TypeScript needs to have a TypeScript typing definition for all external classes. Existing JSweet candies (http://www.jsweet.org/jsweet-candies/) are Maven artifacts that come both with the compiled Java implementation/definition in a Jar, and the associated TypeScript definitions for phase 2.
Author:

Renaud Pawlak

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`EXPORTED_VAR_BEGIN` A constant that is used for exporting variables.
`static String`	`EXPORTED_VAR_END` A constant that is used for exporting variables.
`static Pattern`	`EXPORTED_VAR_REGEXP`
`static String`	`TMP_WORKING_DIR_NAME` The constant for the name of the directory that stores temporary files.
`static String`	`TSC_VERSION` The TypeScript version to be installed/used with this version of JSweet (WARNING: so far, having multiple JSweet versions for the same user account may lead to performance issues - could be fixed if necessary).
`static String`	`TSCROOTFILE` Deprecated. Use `TypeScript2JavaScriptWithTscTranspiler.TSCROOTFILE` instead

Fields inherited from interface org.jsweet.transpiler.JSweetOptions
candiesJsOut, declaration, disableSinglePrecisionFloats, dtsout, enableAssertions, extraSystemPath, header, ignoreDefinitions, jsout, module, sourceMap, targetVersion, tsOnly, tsout

Constructor Summary

Constructors
Constructor and Description
`JSweetTranspiler(File baseDirectory, File configurationFile, JSweetFactory factory, File workingDir, File tsOutputDir, File jsOutputDir, File extractedCandiesJavascriptDir, String classPath)` Creates a JSweet transpiler.
`JSweetTranspiler(File configurationFile, JSweetFactory factory, File workingDir, File tsOutputDir, File jsOutputDir, File extractedCandiesJavascriptDir, String classPath)` Creates a JSweet transpiler.
`JSweetTranspiler(JSweetFactory factory)` Creates a JSweet transpiler, with the default values.
`JSweetTranspiler(JSweetFactory factory, File workingDir, File tsOutputDir, File jsOutputDir, File extractedCandiesJavascriptDir, String classPath)` Creates a JSweet transpiler.
`JSweetTranspiler(JSweetFactory factory, File tsOutputDir, File jsOutputDir, File extractedCandiesJavascriptDir, String classPath)` Creates a JSweet transpiler.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addJsLibFiles(File... files)` Add JavaScript libraries that are used for the JavaScript evaluation.
`void`	`addTsDefDir(File tsDefDir)` Adds a directory that contains TypeScript definition files (sub-directories are scanned recursively to find all .d.ts files).
`void`	`clearJsLibFiles()` Clears JavaScript libraries that are used for the JavaScript evaluation.
`void`	`clearTsDefDirs()` Undo previous calls to `setTsDefDirs(File...)` and `addTsDefDir(File)`.
`EvaluationResult`	`eval(String engineName, TranspilationHandler transpilationHandler, SourceFile... sourceFiles)` Evaluates the given source files with the given evaluation engine.
`EvaluationResult`	`eval(TranspilationHandler transpilationHandler, SourceFile... sourceFiles)` Evaluates the given Java source files with the default JavaScript engine (Nashorn).
`List<String>`	`getAdapters()` A list of adapter class names (fully qualified) to be used to extend the transpiler behavior.
`CandyProcessor`	`getCandiesProcessor()` Gets the candies processor.
`String`	`getClassPath()`
`Map<String,Object>`	`getConfiguration()` Returns the configuration from the configuration file.
`File`	`getConfigurationFile()` The configuration file, which is by default the `jsweetconfig.json` file in the current project.
`JSweetContext`	`getContext()`
`File`	`getDeclarationsOutputDir()` Gets the current .d.ts output directory (only if the declaration option is set).
`EcmaScriptComplianceLevel`	`getEcmaTargetVersion()` The targeted ECMAScript version.
`static EcmaScriptComplianceLevel`	`getEcmaTargetVersion(String targetVersion)` Gets the target version from a user-friendly descriptive string.
`String`	`getEncoding()` Gets the expected Java source code encoding.
`File`	`getExtractedCandyJavascriptDir()` The directory where the transpiler should put the extracted JavaScript files from candies.
`File`	`getHeaderFile()` Gets the file containing the header to be added to the generated files.
`File`	`getJsOutputDir()` Gets the current JavaScript output directory.
`ModuleKind`	`getModuleKind()` Gets the module kind when transpiling to code using JavaScript modules.
`ModuleResolution`	`getModuleResolution()` Determines how modules get resolved.
`com.sun.tools.javac.util.Options`	`getOptions()`
`File`	`getSourceRoot()` Gets the source root for the source map files.
`File`	`getTsOutputDir()` Gets the current TypeScript output directory.
`SourceFile`	`getWatchedFile(File javaFile)` Gets the watched files that corresponds to the given Java file.
`SourceFile[]`	`getWatchedFiles()` Returns the watched files when the transpiler is in watch mode.
`File`	`getWorkingDirectory()` Gets this transpiler working directory (where the temporary files are stored).
`void`	`initNode(TranspilationHandler transpilationHandler)`
`boolean`	`isBundle()` Tells if this transpiler generates JavaScript bundles for running in a Web browser.
`boolean`	`isDebugMode()` If true, the transpiler generates code that can be debugged with JavaScript.
`boolean`	`isDisableSinglePrecisionFloats()` By default, for a target version >=ES5, JSweet will force Java floats to be mapped to JavaScript numbers that will be constrained with the Math.fround function.
`boolean`	`isGenerateDeclarations()` Generates d.ts files along with the js files.
`boolean`	`isGenerateDefinitions()` Generated definitions from def.* packages in d.ts files.
`boolean`	`isGenerateJsFiles()` Tells if the JavaScript generation is enabled/disabled.
`boolean`	`isGenerateSourceMaps()` Tells if the transpiler generates js.map files for Java debugging.
`boolean`	`isGenerateTsFiles()` If false, do not generate TypeScript output (just validate the Java source code and do not transpile anything).
`boolean`	`isIgnoreAssertions()` Tells if the transpiler should ignore the 'assert' statements or generate appropriate code.
`boolean`	`isIgnoreCandiesTypeScriptDefinitions()`
`boolean`	`isIgnoreJavaErrors()` If true, JSweet will ignore any message reported by Java (including error).
`boolean`	`isIgnoreJavaFileNameError()` Generates output code even if the main class is not placed within a file of the same name.
`boolean`	`isIgnoreTypeScriptErrors()` If true, JSweet will ignore any message reported by TypeScript (including error) and the compilation will be successful if no Java error is raised.
`boolean`	`isNoRootDirectories()` Tells if this transpiler skips the root directories (packages annotated with @jsweet.lang.Root) so that the generated file hierarchy starts at the root directories rather than including the entire directory structure.
`boolean`	`isPreserveSourceLineNumbers()` Deprecated.
`boolean`	`isSkipTypeScriptChecks()`
`boolean`	`isTscWatchMode()` Tells if this transpiler is using a Tsc watch process to automatically regenerate the javascript when one of the source file changes.
`boolean`	`isUsingModules()` Tells if this transpiler transpiles to code using JavaScript modules.
`boolean`	`isVerbose()` If true, JSweet has been launched in verbose mode.
`void`	`resetTscWatchMode()` Resets the watch mode (clears the watched files and restarts the Tsc process on the next invocation of `transpile(TranspilationHandler, SourceFile...)`).
`void`	`setAdapters(List<String> adapters)`
`void`	`setBundle(boolean bundle)` Sets this transpiler to generate JavaScript bundles for running in a Web browser.
`void`	`setDebugMode(boolean debugMode)`
`void`	`setDeclarationsOutputDir(File declarationsOutputDir)`
`void`	`setDisableSinglePrecisionFloats(boolean disableSinglePrecisionFloats)`
`void`	`setEcmaTargetVersion(EcmaScriptComplianceLevel ecmaTargetVersion)` Sets target ECMA script version for generated JavaScript
`void`	`setEncoding(String encoding)` Sets the expected Java source code encoding.
`void`	`setGenerateDeclarations(boolean generateDeclarations)`
`void`	`setGenerateDefinitions(boolean generateDefinitions)`
`void`	`setGenerateJsFiles(boolean generateJsFiles)` Sets the flag to enable/disable JavaScript generation.
`void`	`setGenerateSourceMaps(boolean generateSourceMaps)` Sets the flag that tells if the transpiler allows for Java debugging through js.map files.
`void`	`setGenerateTsFiles(boolean generateTsFiles)`
`void`	`setHeaderFile(File headerFile)`
`void`	`setIgnoreAssertions(boolean ignoreAssertions)` Sets the transpiler to ignore the 'assert' statements or generate appropriate code.
`void`	`setIgnoreCandiesTypeScriptDefinitions(boolean ignoreCandiesTypeScriptDefinitions)`
`void`	`setIgnoreJavaErrors(boolean ignoreJavaErrors)`
`void`	`setIgnoreJavaFileNameError(boolean ignoreJavaFileNameError)`
`void`	`setIgnoreTypeScriptErrors(boolean ignoreTypeScriptErrors)`
`void`	`setJsOutputDir(File jsOutputDir)` Sets the current JavaScript output directory.
`void`	`setModuleKind(ModuleKind moduleKind)` Sets the module kind when transpiling to code using JavaScript modules.
`void`	`setModuleResolution(ModuleResolution moduleResolution)` Sets the module strategy when transpiling to code using JavaScript modules.
`void`	`setNoRootDirectories(boolean noRootDirectories)` Sets this transpiler to skip the root directories (packages annotated with @jsweet.lang.Root) so that the generated file hierarchy starts at the root directories rather than including the entire directory structure.
`void`	`setPreserveSourceLineNumbers(boolean preserveSourceLineNumbers)` Deprecated. use `setGenerateSourceMaps(boolean)` instead
`void`	`setSkipTypeScriptChecks(boolean skipTypeScriptChecks)` Tells tsc to skip some checks in order to reduce load time, useful in unit tests where transpiler is invoked many times
`void`	`setSourceRoot(File sourceRoot)`
`void`	`setTscWatchMode(boolean tscWatchMode)` Enables or disable this transpiler watch mode.
`void`	`setTsDefDirs(File... tsDefDirs)` Sets one or more directories that contain TypeScript definition files (sub-directories are scanned recursively to find all .d.ts files).
`void`	`setTsOutputDir(File tsOutputDir)` Sets the current TypeScript output directory.
`com.sun.tools.javac.util.List<com.sun.tools.javac.tree.JCTree.JCCompilationUnit>`	`setupCompiler(List<File> files, ErrorCountTranspilationHandler transpilationHandler)`
`void`	`setUseTsserver(boolean useTsserver)`
`void`	`setUsingJavaRuntime(boolean usingJavaRuntime)` Manually sets the transpiler to use (or not use) a Java runtime.
`void`	`setVerbose(boolean verbose)`
`String`	`toString()`
`String`	`transpile(ErrorCountTranspilationHandler handler, com.sun.tools.javac.tree.JCTree tree, String targetFileName)` Transpiles the given Java AST.
`void`	`transpile(TranspilationHandler transpilationHandler, SourceFile... files)` Transpiles the given Java source files.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - TSC_VERSION
```
public static final String TSC_VERSION
```
    The TypeScript version to be installed/used with this version of JSweet (WARNING: so far, having multiple JSweet versions for the same user account may lead to performance issues - could be fixed if necessary).
    
    See Also:
    
    Constant Field Values
  - TMP_WORKING_DIR_NAME
```
public static final String TMP_WORKING_DIR_NAME
```
    The constant for the name of the directory that stores temporary files.
    
    See Also:
    
    Constant Field Values
  - EXPORTED_VAR_BEGIN
```
public static final String EXPORTED_VAR_BEGIN
```
    A constant that is used for exporting variables.
    
    See Also:
    
    TraceBasedEvaluationResult, eval(TranspilationHandler, SourceFile...), Constant Field Values
  - EXPORTED_VAR_END
```
public static final String EXPORTED_VAR_END
```
    A constant that is used for exporting variables.
    
    See Also:
    
    TraceBasedEvaluationResult, eval(TranspilationHandler, SourceFile...), Constant Field Values
  - EXPORTED_VAR_REGEXP
```
public static Pattern EXPORTED_VAR_REGEXP
```
  - TSCROOTFILE
```
public static final String TSCROOTFILE
```
    Deprecated. Use TypeScript2JavaScriptWithTscTranspiler.TSCROOTFILE instead
    
    The name of the file generated in the root package to avoid the TypeScript compiler to skip empty directories.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - JSweetTranspiler
```
public JSweetTranspiler(JSweetFactory factory)
```
    Creates a JSweet transpiler, with the default values.
    TypeScript and JavaScript output directories are set to System.getProperty("java.io.tmpdir"). The classpath is set to System.getProperty("java.class.path").
    
    Parameters:
    
    factory - the factory used to create the transpiler objects
  - JSweetTranspiler
```
public JSweetTranspiler(JSweetFactory factory,
                        File tsOutputDir,
                        File jsOutputDir,
                        File extractedCandiesJavascriptDir,
                        String classPath)
```
    Creates a JSweet transpiler.
    
    Parameters:
    
    factory - the factory used to create the transpiler objects
    
    tsOutputDir - the directory where TypeScript files are written
    
    jsOutputDir - the directory where JavaScript files are written
    
    extractedCandiesJavascriptDir - see getExtractedCandyJavascriptDir()
    
    classPath - the classpath as a string (check out system-specific requirements for Java classpathes)
  - JSweetTranspiler
```
public JSweetTranspiler(JSweetFactory factory,
                        File workingDir,
                        File tsOutputDir,
                        File jsOutputDir,
                        File extractedCandiesJavascriptDir,
                        String classPath)
```
    Creates a JSweet transpiler.
    
    Parameters:
    
    factory - the factory used to create the transpiler objects
    
    workingDir - the working directory (uses default one if null)
    
    tsOutputDir - the directory where TypeScript files are written
    
    jsOutputDir - the directory where JavaScript files are written
    
    extractedCandiesJavascriptDir - see getExtractedCandyJavascriptDir()
    
    classPath - the classpath as a string (check out system-specific requirements for Java classpaths)
  - JSweetTranspiler
```
public JSweetTranspiler(File configurationFile,
                        JSweetFactory factory,
                        File workingDir,
                        File tsOutputDir,
                        File jsOutputDir,
                        File extractedCandiesJavascriptDir,
                        String classPath)
```
    Creates a JSweet transpiler.
    
    Parameters:
    
    configurationFile - the configurationFile (uses default one if null)
    
    factory - the factory used to create the transpiler objects
    
    workingDir - the working directory (uses default one if null)
    
    tsOutputDir - the directory where TypeScript files are written
    
    jsOutputDir - the directory where JavaScript files are written
    
    extractedCandiesJavascriptDir - see getExtractedCandyJavascriptDir()
    
    classPath - the classpath as a string (check out system-specific requirements for Java classpaths)
  - JSweetTranspiler
```
public JSweetTranspiler(File baseDirectory,
                        File configurationFile,
                        JSweetFactory factory,
                        File workingDir,
                        File tsOutputDir,
                        File jsOutputDir,
                        File extractedCandiesJavascriptDir,
                        String classPath)
```
    Creates a JSweet transpiler.
    
    Parameters:
    
    configurationFile - the configurationFile (uses default one if null)
    
    factory - the factory used to create the transpiler objects
    
    workingDir - the working directory (uses default one if null)
    
    tsOutputDir - the directory where TypeScript files are written
    
    jsOutputDir - the directory where JavaScript files are written
    
    extractedCandiesJavascriptDir - see getExtractedCandyJavascriptDir()
    
    classPath - the classpath as a string (check out system-specific requirements for Java classpaths)
- Method Detail
  - getEcmaTargetVersion
```
public static EcmaScriptComplianceLevel getEcmaTargetVersion(String targetVersion)
```
    Gets the target version from a user-friendly descriptive string.
  - setUsingJavaRuntime
```
public void setUsingJavaRuntime(boolean usingJavaRuntime)
```
    Manually sets the transpiler to use (or not use) a Java runtime.
    Calling this method is usually not needed since JSweet auto-detects the J4TS candy. Use only to manually force the transpiler in a mode or another.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - getWorkingDirectory
```
public File getWorkingDirectory()
```
    Gets this transpiler working directory (where the temporary files are stored).
  - initNode
```
public void initNode(TranspilationHandler transpilationHandler)
              throws Exception
```
    Throws:
    
    Exception
  - setTsDefDirs
```
public void setTsDefDirs(File... tsDefDirs)
```
    Sets one or more directories that contain TypeScript definition files (sub-directories are scanned recursively to find all .d.ts files).
    
    Parameters:
    
    tsDefDirs - a list of directories to scan for .d.ts files
  - addTsDefDir
```
public void addTsDefDir(File tsDefDir)
```
    Adds a directory that contains TypeScript definition files (sub-directories are scanned recursively to find all .d.ts files).
    
    Parameters:
    
    tsDefDir - a directory to scan for .d.ts files
  - clearTsDefDirs
```
public void clearTsDefDirs()
```
    Undo previous calls to setTsDefDirs(File...) and addTsDefDir(File).
  - eval
```
public EvaluationResult eval(TranspilationHandler transpilationHandler,
                             SourceFile... sourceFiles)
                      throws Exception
```
    Evaluates the given Java source files with the default JavaScript engine (Nashorn).
    This function automatically transpile the source files if needed.
    
    Parameters:
    
    transpilationHandler - the transpilation handler
    
    sourceFiles - the source files to be evaluated
    
    Returns:
    
    an object that holds the evaluation result
    
    Throws:
    
    Exception - when an internal error occurs
  - eval
```
public EvaluationResult eval(String engineName,
                             TranspilationHandler transpilationHandler,
                             SourceFile... sourceFiles)
                      throws Exception
```
    Evaluates the given source files with the given evaluation engine.
    If given engine name is "Java", this function looks up for the classes in the classpath and run the main methods when found.
    
    Parameters:
    
    engineName - the engine name: either "Java" or any valid and installed JavaScript engine.
    
    transpilationHandler - the log handler
    
    sourceFiles - the source files to be evaluated (transpiled first if needed)
    
    Returns:
    
    the evaluation result
    
    Throws:
    
    Exception - when an internal error occurs
  - setupCompiler
```
public com.sun.tools.javac.util.List<com.sun.tools.javac.tree.JCTree.JCCompilationUnit> setupCompiler(List<File> files,
                                                                                                      ErrorCountTranspilationHandler transpilationHandler)
                                                                                               throws IOException
```
    Throws:
    
    IOException
  - transpile
```
public void transpile(TranspilationHandler transpilationHandler,
                      SourceFile... files)
               throws IOException
```
    Transpiles the given Java source files. When the transpiler is in watch mode (setTscWatchMode(boolean)), the first invocation to this method determines the files to be watched by the Tsc process.
    
    Parameters:
    
    transpilationHandler - the log handler
    
    files - the files to be transpiled
    
    Throws:
    
    IOException
  - setUseTsserver
```
public void setUseTsserver(boolean useTsserver)
```
  - getWatchedFiles
```
public SourceFile[] getWatchedFiles()
```
    Returns the watched files when the transpiler is in watch mode. See setTscWatchMode(boolean). The watched file list corresponds to the one given at the first invocation of transpile(TranspilationHandler, SourceFile...) after the transpiler was set to watch mode. All subsequent invocations of transpile(TranspilationHandler, SourceFile...) will not change the initial watched files. In order to change the watch files, invoke resetTscWatchMode() and call transpile(TranspilationHandler, SourceFile...) with a new file list.
  - getWatchedFile
```
public SourceFile getWatchedFile(File javaFile)
```
    Gets the watched files that corresponds to the given Java file. See setTscWatchMode(boolean).
  - isTscWatchMode
```
public boolean isTscWatchMode()
```
    Tells if this transpiler is using a Tsc watch process to automatically regenerate the javascript when one of the source file changes.
    
    Specified by:
    
    isTscWatchMode in interface JSweetOptions
    
    Returns:
    
    true to enable tsc watch mode
  - setTscWatchMode
```
public void setTscWatchMode(boolean tscWatchMode)
```
    Enables or disable this transpiler watch mode. When watch mode is enabled, the first invocation to transpile(TranspilationHandler, SourceFile...) will start the Tsc watch process, which regenerates the JavaScript files when one of the input file changes.
    
    Parameters:
    
    tscWatchMode - true: enables the watch mode (do nothing is already enabled), false: disables the watch mode and stops the current Tsc watching process
    
    See Also:
    
    getWatchedFile(File)
  - isPreserveSourceLineNumbers
```
@Deprecated
public boolean isPreserveSourceLineNumbers()
```
    Deprecated.
    
    Description copied from interface: JSweetOptions
    
    Tells if the transpiler generates js.map files for Java debugging.
    
    Specified by:
    
    isPreserveSourceLineNumbers in interface JSweetOptions
  - isGenerateSourceMaps
```
public boolean isGenerateSourceMaps()
```
    Description copied from interface: JSweetOptions
    
    Tells if the transpiler generates js.map files for Java debugging.
    
    Specified by:
    
    isGenerateSourceMaps in interface JSweetOptions
  - setPreserveSourceLineNumbers
```
@Deprecated
public void setPreserveSourceLineNumbers(boolean preserveSourceLineNumbers)
```
    Deprecated. use setGenerateSourceMaps(boolean) instead
    
    Sets the flag that tells if the transpiler preserves the generated TypeScript source line numbers wrt the Java original source file (allows for Java debugging through js.map files).
  - setGenerateSourceMaps
```
public void setGenerateSourceMaps(boolean generateSourceMaps)
```
    Sets the flag that tells if the transpiler allows for Java debugging through js.map files.
  - getTsOutputDir
```
public File getTsOutputDir()
```
    Description copied from interface: JSweetOptions
    
    Gets the current TypeScript output directory.
    
    Specified by:
    
    getTsOutputDir in interface JSweetOptions
  - setTsOutputDir
```
public void setTsOutputDir(File tsOutputDir)
```
    Sets the current TypeScript output directory.
  - getJsOutputDir
```
public File getJsOutputDir()
```
    Description copied from interface: JSweetOptions
    
    Gets the current JavaScript output directory.
    
    Specified by:
    
    getJsOutputDir in interface JSweetOptions
  - setJsOutputDir
```
public void setJsOutputDir(File jsOutputDir)
```
    Sets the current JavaScript output directory.
  - isGenerateJsFiles
```
public boolean isGenerateJsFiles()
```
    Tells if the JavaScript generation is enabled/disabled.
    
    Specified by:
    
    isGenerateJsFiles in interface JSweetOptions
  - setGenerateJsFiles
```
public void setGenerateJsFiles(boolean generateJsFiles)
```
    Sets the flag to enable/disable JavaScript generation.
  - resetTscWatchMode
```
public void resetTscWatchMode()
```
    Resets the watch mode (clears the watched files and restarts the Tsc process on the next invocation of transpile(TranspilationHandler, SourceFile...)).
  - getCandiesProcessor
```
public CandyProcessor getCandiesProcessor()
```
    Gets the candies processor.
  - setEcmaTargetVersion
```
public void setEcmaTargetVersion(EcmaScriptComplianceLevel ecmaTargetVersion)
```
    Sets target ECMA script version for generated JavaScript
    
    Parameters:
    
    ecmaTargetVersion - The target version
  - getEcmaTargetVersion
```
public EcmaScriptComplianceLevel getEcmaTargetVersion()
```
    Description copied from interface: JSweetOptions
    
    The targeted ECMAScript version.
    
    Specified by:
    
    getEcmaTargetVersion in interface JSweetOptions
  - getModuleKind
```
public ModuleKind getModuleKind()
```
    Description copied from interface: JSweetOptions
    
    Gets the module kind when transpiling to code using JavaScript modules.
    
    Specified by:
    
    getModuleKind in interface JSweetOptions
  - setModuleKind
```
public void setModuleKind(ModuleKind moduleKind)
```
    Sets the module kind when transpiling to code using JavaScript modules.
  - getModuleResolution
```
public ModuleResolution getModuleResolution()
```
    Description copied from interface: JSweetOptions
    
    Determines how modules get resolved. Either "Node" for Node.js/io.js style resolution, or "Classic". See Tsc's Module Resolution documentation for more details.
    
    Specified by:
    
    getModuleResolution in interface JSweetOptions
    
    Returns:
    
    the current module resolution strategy
  - setModuleResolution
```
public void setModuleResolution(ModuleResolution moduleResolution)
```
    Sets the module strategy when transpiling to code using JavaScript modules.
  - setSkipTypeScriptChecks
```
public void setSkipTypeScriptChecks(boolean skipTypeScriptChecks)
```
    Tells tsc to skip some checks in order to reduce load time, useful in unit tests where transpiler is invoked many times
  - isSkipTypeScriptChecks
```
public boolean isSkipTypeScriptChecks()
```
    Specified by:
    
    isSkipTypeScriptChecks in interface JSweetOptions
  - isUsingModules
```
public boolean isUsingModules()
```
    Tells if this transpiler transpiles to code using JavaScript modules.
    
    Specified by:
    
    isUsingModules in interface JSweetOptions
    
    Returns:
    
    true if module is set to somethind else than ModuleKind.none
  - isBundle
```
public boolean isBundle()
```
    Description copied from interface: JSweetOptions
    
    Tells if this transpiler generates JavaScript bundles for running in a Web browser.
    
    Specified by:
    
    isBundle in interface JSweetOptions
  - setBundle
```
public void setBundle(boolean bundle)
```
    Sets this transpiler to generate JavaScript bundles for running in a Web browser.
  - getEncoding
```
public String getEncoding()
```
    Description copied from interface: JSweetOptions
    
    Gets the expected Java source code encoding.
    
    Specified by:
    
    getEncoding in interface JSweetOptions
  - setEncoding
```
public void setEncoding(String encoding)
```
    Sets the expected Java source code encoding.
  - isNoRootDirectories
```
public boolean isNoRootDirectories()
```
    Description copied from interface: JSweetOptions
    
    Tells if this transpiler skips the root directories (packages annotated with @jsweet.lang.Root) so that the generated file hierarchy starts at the root directories rather than including the entire directory structure.
    
    Specified by:
    
    isNoRootDirectories in interface JSweetOptions
  - setNoRootDirectories
```
public void setNoRootDirectories(boolean noRootDirectories)
```
    Sets this transpiler to skip the root directories (packages annotated with @jsweet.lang.Root) so that the generated file hierarchy starts at the root directories rather than including the entire directory structure.
  - isIgnoreAssertions
```
public boolean isIgnoreAssertions()
```
    Description copied from interface: JSweetOptions
    
    Tells if the transpiler should ignore the 'assert' statements or generate appropriate code.
    
    Specified by:
    
    isIgnoreAssertions in interface JSweetOptions
  - setIgnoreAssertions
```
public void setIgnoreAssertions(boolean ignoreAssertions)
```
    Sets the transpiler to ignore the 'assert' statements or generate appropriate code.
  - isIgnoreJavaFileNameError
```
public boolean isIgnoreJavaFileNameError()
```
    Description copied from interface: JSweetOptions
    
    Generates output code even if the main class is not placed within a file of the same name.
    
    Specified by:
    
    isIgnoreJavaFileNameError in interface JSweetOptions
  - setIgnoreJavaFileNameError
```
public void setIgnoreJavaFileNameError(boolean ignoreJavaFileNameError)
```
  - isGenerateDeclarations
```
public boolean isGenerateDeclarations()
```
    Description copied from interface: JSweetOptions
    
    Generates d.ts files along with the js files.
    
    Specified by:
    
    isGenerateDeclarations in interface JSweetOptions
  - setGenerateDeclarations
```
public void setGenerateDeclarations(boolean generateDeclarations)
```
  - getDeclarationsOutputDir
```
public File getDeclarationsOutputDir()
```
    Description copied from interface: JSweetOptions
    
    Gets the current .d.ts output directory (only if the declaration option is set).
    By default, declarations are placed in the JavaScript output directory.
    
    Specified by:
    
    getDeclarationsOutputDir in interface JSweetOptions
  - setDeclarationsOutputDir
```
public void setDeclarationsOutputDir(File declarationsOutputDir)
```
  - getExtractedCandyJavascriptDir
```
public File getExtractedCandyJavascriptDir()
```
    Description copied from interface: JSweetOptions
    
    The directory where the transpiler should put the extracted JavaScript files from candies. Candies can bundle one or more JavaScript files that will be extracted to this directory.
    
    Specified by:
    
    getExtractedCandyJavascriptDir in interface JSweetOptions
  - addJsLibFiles
```
public void addJsLibFiles(File... files)
```
    Add JavaScript libraries that are used for the JavaScript evaluation.
    
    See Also:
    
    eval(TranspilationHandler, SourceFile...)
  - clearJsLibFiles
```
public void clearJsLibFiles()
```
    Clears JavaScript libraries that are used for the JavaScript evaluation.
    
    See Also:
    
    eval(TranspilationHandler, SourceFile...)
  - transpile
```
public String transpile(ErrorCountTranspilationHandler handler,
                        com.sun.tools.javac.tree.JCTree tree,
                        String targetFileName)
                 throws IOException
```
    Transpiles the given Java AST.
    
    Parameters:
    
    transpilationHandler - the log handler
    
    tree - the AST to be transpiled
    
    targetFileName - the name of the file (without any extension) where to put the transpilation output
    
    Throws:
    
    IOException
  - isGenerateDefinitions
```
public boolean isGenerateDefinitions()
```
    Description copied from interface: JSweetOptions
    
    Generated definitions from def.* packages in d.ts files.
    
    Specified by:
    
    isGenerateDefinitions in interface JSweetOptions
  - setGenerateDefinitions
```
public void setGenerateDefinitions(boolean generateDefinitions)
```
  - getSourceRoot
```
public File getSourceRoot()
```
    Description copied from interface: JSweetOptions
    
    Gets the source root for the source map files. Use this option if the Java source is located in a different place at runtime.
    
    Specified by:
    
    getSourceRoot in interface JSweetOptions
  - setSourceRoot
```
public void setSourceRoot(File sourceRoot)
```
  - getConfiguration
```
public Map<String,Object> getConfiguration()
```
    Description copied from interface: JSweetOptions
    
    Returns the configuration from the configuration file.
    
    Specified by:
    
    getConfiguration in interface JSweetOptions
  - isIgnoreTypeScriptErrors
```
public boolean isIgnoreTypeScriptErrors()
```
    Description copied from interface: JSweetOptions
    
    If true, JSweet will ignore any message reported by TypeScript (including error) and the compilation will be successful if no Java error is raised.
    
    Specified by:
    
    isIgnoreTypeScriptErrors in interface JSweetOptions
  - setIgnoreTypeScriptErrors
```
public void setIgnoreTypeScriptErrors(boolean ignoreTypeScriptErrors)
```
  - getHeaderFile
```
public File getHeaderFile()
```
    Description copied from interface: JSweetOptions
    
    Gets the file containing the header to be added to the generated files.
    
    Specified by:
    
    getHeaderFile in interface JSweetOptions
    
    Returns:
    
    the header file, null if undefined
  - setHeaderFile
```
public void setHeaderFile(File headerFile)
```
  - isGenerateTsFiles
```
public boolean isGenerateTsFiles()
```
    Description copied from interface: JSweetOptions
    
    If false, do not generate TypeScript output (just validate the Java source code and do not transpile anything). Default is true.
    
    Specified by:
    
    isGenerateTsFiles in interface JSweetOptions
  - setGenerateTsFiles
```
public void setGenerateTsFiles(boolean generateTsFiles)
```
  - isIgnoreJavaErrors
```
public boolean isIgnoreJavaErrors()
```
    Description copied from interface: JSweetOptions
    
    If true, JSweet will ignore any message reported by Java (including error).
    
    Specified by:
    
    isIgnoreJavaErrors in interface JSweetOptions
  - setIgnoreJavaErrors
```
public void setIgnoreJavaErrors(boolean ignoreJavaErrors)
```
  - getContext
```
public JSweetContext getContext()
```
  - getOptions
```
public com.sun.tools.javac.util.Options getOptions()
```
  - isDebugMode
```
public boolean isDebugMode()
```
    Description copied from interface: JSweetOptions
    
    If true, the transpiler generates code that can be debugged with JavaScript.
    
    Specified by:
    
    isDebugMode in interface JSweetOptions
  - setDebugMode
```
public void setDebugMode(boolean debugMode)
```
  - isVerbose
```
public boolean isVerbose()
```
    Description copied from interface: JSweetOptions
    
    If true, JSweet has been launched in verbose mode.
    
    Specified by:
    
    isVerbose in interface JSweetOptions
  - setVerbose
```
public void setVerbose(boolean verbose)
```
  - isDisableSinglePrecisionFloats
```
public boolean isDisableSinglePrecisionFloats()
```
    Description copied from interface: JSweetOptions
    
    By default, for a target version >=ES5, JSweet will force Java floats to be mapped to JavaScript numbers that will be constrained with the Math.fround function. If this option is true, then the calls to Math.fround are erased and the generated program will use the JavaScript default precision (double precision).
    
    Specified by:
    
    isDisableSinglePrecisionFloats in interface JSweetOptions
  - setDisableSinglePrecisionFloats
```
public void setDisableSinglePrecisionFloats(boolean disableSinglePrecisionFloats)
```
  - getAdapters
```
public List<String> getAdapters()
```
    Description copied from interface: JSweetOptions
    
    A list of adapter class names (fully qualified) to be used to extend the transpiler behavior. As the name suggests, an adapter is an instance of PrinterAdapter that adapts the TypeScript default printer in order to tune the generated code. All the adapter classes must be accessible within the 'jsweet_extension' directory to be created at the root of the transpiled project. The adapter classes can be provided as Java class files (*.class) or Java source files (*.java). In the latter case, they will be on-the-fly compiled by JSweet.
    
    Specified by:
    
    getAdapters in interface JSweetOptions
    
    See Also:
    
    PrinterAdapter
  - setAdapters
```
public void setAdapters(List<String> adapters)
```
  - getConfigurationFile
```
public File getConfigurationFile()
```
    Description copied from interface: JSweetOptions
    
    The configuration file, which is by default the jsweetconfig.json file in the current project.
    
    Specified by:
    
    getConfigurationFile in interface JSweetOptions
  - getClassPath
```
public String getClassPath()
```
  - isIgnoreCandiesTypeScriptDefinitions
```
public boolean isIgnoreCandiesTypeScriptDefinitions()
```
  - setIgnoreCandiesTypeScriptDefinitions
```
public void setIgnoreCandiesTypeScriptDefinitions(boolean ignoreCandiesTypeScriptDefinitions)
```

Class JSweetTranspiler

Field Summary

Fields inherited from interface org.jsweet.transpiler.JSweetOptions

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

TSC_VERSION

TMP_WORKING_DIR_NAME

EXPORTED_VAR_BEGIN

EXPORTED_VAR_END

EXPORTED_VAR_REGEXP

TSCROOTFILE

Constructor Detail

JSweetTranspiler

JSweetTranspiler

JSweetTranspiler

JSweetTranspiler

JSweetTranspiler

Method Detail

getEcmaTargetVersion

setUsingJavaRuntime

toString

getWorkingDirectory

initNode

setTsDefDirs

addTsDefDir

clearTsDefDirs

eval

eval

setupCompiler

transpile

setUseTsserver

getWatchedFiles

getWatchedFile

isTscWatchMode

setTscWatchMode

isPreserveSourceLineNumbers

isGenerateSourceMaps

setPreserveSourceLineNumbers

setGenerateSourceMaps

getTsOutputDir

setTsOutputDir

getJsOutputDir

setJsOutputDir

isGenerateJsFiles

setGenerateJsFiles

resetTscWatchMode

getCandiesProcessor

setEcmaTargetVersion

getEcmaTargetVersion

getModuleKind

setModuleKind

getModuleResolution

setModuleResolution

setSkipTypeScriptChecks

isSkipTypeScriptChecks

isUsingModules

isBundle

setBundle

getEncoding

setEncoding

isNoRootDirectories

setNoRootDirectories

isIgnoreAssertions

setIgnoreAssertions

isIgnoreJavaFileNameError

setIgnoreJavaFileNameError

isGenerateDeclarations

setGenerateDeclarations

getDeclarationsOutputDir

setDeclarationsOutputDir

getExtractedCandyJavascriptDir

addJsLibFiles

clearJsLibFiles

transpile

isGenerateDefinitions

setGenerateDefinitions

getSourceRoot

setSourceRoot