cincheo/jsweet

A Java to JavaScript transpiler.

JSweet: a Java to JavaScript transpiler

JSweet leverages TypeScript to write rich and responsive Web applications in Java through the use of JavaScript libraries and frameworks. With JSweet, Java programs are transpiled (source-to-source compiled) to TypeScript and JavaScript for being run in browsers, mobile Web views, or in Node.js.

• JSweet is safe and reliable. It provides web applications with type-checking and generates fully type-checked JavaScript programs. It stands on Oracle's Java Compiler (javac) and on Microsoft's TypeScript (tsc).
• JSweet allows you to use your favorite JS library (JSweet+Angular2, JSweet+threejs, IONIC/Cordova, ...).
• JSweet enables code sharing between server-side Java and client-side JavaScript. JSweet provides implementations for the core Java libraries for code sharing and legacy Java migration purpose.
• JSweet is fast, lightweight and fully JavaScript-interoperable. The generated code is regular JavaScript code, which implies no overhead compared to JavaScript, and can directly interoperate with existing JavaScript programs and libraries.

How does it work? JSweet depends on well-typed descriptions of JavaScript APIs, so-called "candies", most of them being automatically generated from TypeScript definition files. These API descriptions in Java can be seen as headers (similarly to *.h header files in C) to bridge JavaSript libraries from Java. There are several sources of candies for existing libraries and you can easily build a candy for any library out there (see more details).

With JSweet, you take advantage of all the Java tooling (IDE's, Maven, ...) to program real JavaScript applications using the latest JavaScript libraries.

Java -> TypeScript -> JavaScript

Here is a first taste of what you get by using JSweet. Consider this simple Java program:

package org.jsweet;

import static jsweet.dom.Globals.*;

/**
 * This is a very simple example that just shows an alert.
 */
public class HelloWorld {
	public static void main(String[] args) {
		alert("Hi there!");
	}
}

Transpiling with JSweet gives the following TypeScript program:

namespace org.jsweet {
    /**
     * This is a very simple example that just shows an alert.
     */
    export class HelloWorld {
        public static main(args : string[]) {
            alert("Hi there!");
        }
    }
}
org.jsweet.HelloWorld.main(null);

Which in turn produces the following JavaScript output:

var org;
(function (org) {
    var jsweet;
    (function (jsweet) {
        /**
         * This is a very simple example that just shows an alert.
         */
        var HelloWorld = (function () {
            function HelloWorld() {
            }
            HelloWorld.main = function (args) {
                alert("Hi there!");
            };
            return HelloWorld;
        }());
        jsweet.HelloWorld = HelloWorld;
    })(jsweet = org.jsweet || (org.jsweet = {}));
})(org || (org = {}));
org.jsweet.HelloWorld.main(null);

More with the live sandbox.

Features

• Full syntax mapping between Java and TypeScript, including classes, interfaces, functional types, union types, tuple types, object types, string types, and so on.
• Extensive support of Java constructs and semantics added since version 1.1.0 (inner classes, anonymous classes, final fields, method overloading, instanceof operator, static initializers, ...).
• Over 1000 JavaScript libraries, frameworks and plugins to write Web and Mobile HTML5 applications (JQuery, Underscore, Angular, Backbone, Cordova, Node.js, and much more).
• A Maven repository containing all the available libraries in Maven artifacts (a.k.a. candies).
• Support for Java basic APIs as the J4TS candy (forked from the GWT's JRE emulation).
• An Eclipse plugin for easy installation and use.
• A Maven plugin to use JSweet from any other IDE or from the command line.
• A Gradle plugin to integrate JSweet with Gradle-based projects.
• A debug mode to enable Java code debugging within your favorite browser.
• A set of nice WEB/Mobile HTML5 examples to get started and get used to JSweet and the most common JavaScript APIs (even more examples in the Examples section).
• Support for bundles to run the generated programs in the most simple way.
• Support for JavaScript modules (commonjs, amd, umd). JSweet programs can run in a browser or in Node.js.
• Support for various EcmaScript target versions (ES3 to ES6).
• Support for async/await idiom
• ...

For more details, go to the language specifications (PDF).

Getting started

• Step 1: Install (or check that you have installed) Git, Node.js and Maven (commands git, node, npm and mvn should be in your path).
• Step 2: Clone the jsweet-quickstart project from Github:

$ git clone https://github.com/cincheo/jsweet-quickstart.git

• Step 3: Run the transpiler to generate the JavaScript code:

$ cd jsweet-quickstart
$ mvn generate-sources

• Step 4: Check out the result in your browser:

$ firefox webapp/index.html

• Step 5: Edit the project and start programming:
  • Checkout the examples to see various use cases
  • Get access to hundreds of libs (candies)
  • Refer to the language specifications to know more about programming with JSweet
  • Eclipse users: install the Eclipse plugin to get inline error reporting, build-on-save, and easy configuration UI

More info at http://www.jsweet.org.

Examples

• Simple examples illustrating the use of various frameworks in Java (jQuery, Underscore, Backbone, AngularJS, Knockout): https://github.com/cincheo/jsweet-examples
• Simple examples illustrating the use of the Threejs framework in Java: https://github.com/cincheo/jsweet-examples-threejs)
• Node.js + Socket.IO + AngularJS: https://github.com/lgrignon/jsweet-node-example
• Some simple examples to get started with React.js: https://github.com/cincheo/jsweet-examples-react
• JSweet JAX-RS server example (how to share a Java model between client and server): https://github.com/lgrignon/jsweet-jaxrs-server-example
• JSweet Cordova / Polymer example: https://github.com/lgrignon/jsweet-cordova-polymer-example
• JSweet Cordova / Ionic example: https://github.com/lgrignon/jsweet-cordova-ionic-example
• JSweet Angular 2 example: https://github.com/cincheo/jsweet-angular2-quickstart
• JSweet Angular 2 + PrimeNG: https://github.com/cincheo/jsweet-primeng-quickstart

Sub-projects

This repository is organized in sub-projects. Each sub-project has its own build process.

• JSweet transpiler: the Java to TypeScript/JavaScript compiler.
• JSweet core candy: the core APIs (JavaScript language, JavaScript DOM, and JSweet language utilities).
• JDK runtime: a fork from GWT's JRE emulation to implement main JDK APIs in JSweet/TypeScript/JavaScript.
• JSweet candy generator: a tool to generate Java APIs from TypeScript definition files, and package them as JSweet candies.
• JSweet documentation: JSweet documentation.

Additionally, some tools for JSweet are available in external repositories.

• Maven plugin
• Gradle plugin
• Eclipse plugin

How to build

Please check each sub-project README file.

Contributing

JSweet uses Git Flow. You can fork this repository. Default branch is develop. Please use git flow feature start myAwesomeFeature to start working on something great :) When you are done, you can submit a regular GitHub Pull Request.

License

Please read the LICENSE file.

jsweet's Issues

Subtle issue with generic interfaces/objects

The following code does not pass TSC:

package source.generics;
import java.util.function.Consumer;
import jsweet.lang.Interface;

public class GenericObjectStructure {
    <T> void m(MyInterface<T> i, Consumer<T> c) {
    }
    public static void main(String[] args) {
        new GenericObjectStructure().m(new MyInterface<String>() {
            {
                f = "test";
            }
        }, param -> { param.indexOf("c"); });
    }
}

@Interface
abstract class MyInterface<T> {
    String f;
}

That's because the new MyInterface<String>() {{ f = "test"; }} type is erased to { f : "test" } when transpiled... As a consequence, the T parameter actual value cannot be inferred and param is not considered as a String anymore.

Objects and interfaces constructions must be correctly typed to avoid this problem.

Lookup and add tools.jar automatically

tools.jar is to be found in the JDK libs. When not found a sound error must request the user to insall a JDK or to configure the java home.

Lookup should be done as follows:

• if the --jdkPath option is set look up there
• else or if not found use the java.home variable
• is still not found report error

Support for Java APIs [originally: Add support for java.lang.Math]

It'd be great to have as much support for java.lang.Math as possible.

This is not automatically added when calling a method with generics

Normally JSweet automatically adds a this target when calling a method defined on the current class... however, it does not work when the method has generics and defines it own generics. For example:

public class AddThisOnGenericMethods<T> {
    private <U> void m(AddThisOnGenericMethods<U> i) {
    }
    public <U> void m2(AddThisOnGenericMethods<U> i) {
        m(i);
    }
    public void m3(AddThisOnGenericMethods<String> i) {
        m(i);
    }
}

Support for inner classes.

In version 1.0, inner classes will not be supported. It would not be that hard to support them though.

The idea (to be validated) is to create a TypeScript module with the same name as the container class and create the inner class in the module.

Get JS from Jar files

The candy processor should be able to find and use the JS in the candies Jar files when available.

It should follow the Webjar conventions to package the JS code. So, programmers would be able to include the definitions and the JS code and it should work right away. Note that the JS file should probably be packaged for commonjs so that we can use the "bundle" option.

Support getters and setters of properties

Getters and setters are useful because:

• they follow Java conventions
• they allow the definition of interfaces with Java interfaces
• they allow the use of overloading instead of unions

Proposal: create a @Targetproperty("propertyName") annotation. When setters or getters are annotated with this annotation, the transpiler generates code using properties rather than invocations.

• targetExpr.setProperty(expr) => (targetExpr.property = expr) // see if this is valid in TS, otherwise wrap in a lambda
• targetExpr.getProperty() => targetExpr.property
• targetExpr.isProperty() => targetExpr.property

Support for custom string types

Programmers can define their own string types as follows:

import jsweet.lang.StringType;

public class CustomStringTypes {
    @Erased
    public interface abc {
    }
    @StringType
    public static final abc abc = null;
    void m2(abc arg) {
    }
    public static void main(String[] args) {
        new CustomStringTypes().m2(abc);
    }
}

Correct definition checks must be added to the transpiler:

• a string type interface is always an inner interface and a static field of the same name should be defined
• a string type interface is always empty and @Erased
• a string type field is always static final and its type must be of the same name

Eclipse Plugin + OSX : cannot find Node.js

From @tdebroc on December 22, 2015 9:2

I have node js in my path in my terminal but Eclipse can't find it:
cannot find Node.js: install first and make sure that the 'node' command is in your execution path jsweet-examples Unknown JSweet Problem

Copied from original issue: cincheo/jsweet-examples#11

Source quality improvements

Firstly congrats on putting together a very interesting project, nice work (and a lot of work looks like!).

I browsed the java source for jsweet to gauge the maturity/quality of the code (to see if I should use the project) and I just thought I'd share some impressions that you may or may not choose to act on.

Now that java.util.Optional is part of Java 8 and this is the compile level for the project then I'd suggest that null is not used anywhere and that where Optional items are passed as arguments that guava style Preconditions.checkNotNull checks are made on those arguments.

In companion with the Optional suggestion there is a lot of mutabiltity floating around and it's not needed. Any non-final field is a flag for closer inspection of usage for me and almost all your fields are non-final. For creating instances of something like JSweetTranspiler I'd suggest using a fluent builder that creates immutable instances.

I'd also avoid inheritance where possible (see composition vs inheritance discussions, e.g. in Josh Bloch's Essential Java) and default to marking classes as final so that you don't have to support inheritance yourselves. You could also move classes that have internal only function to an .internal package so it's clear what is in the public API and what is not.

That's my fifty cents for the moment, thanks for the project!

Globals classes should not allow non-static members

• no non-static members
• no super class
• cannot be extended (maybe force the final modifier?)
• cannot be used as types like regular classes
• no public constructor (empty private constructor is OK)
• cannot used $get, $set and $delete within the methods

Update docs

• update transpiler options in the specs + website.
• add ant build example (for ant users - cf developpez.com) and check that the getting started is up-to-date.
• rename core to jsweet-core on the website
• documentation for the "strict" mode

Invalid access to static method with this

Accessing a valid method through "this" is valid in Java (warning only). JSweet should either report an error, or remove the "this".

class My {
  private static Logger log; //...
  void x() {
    this.log.info(...);
  }
}

TypeScript delegation performance improvements

Currently, TypeScript is used through command line processes, which is very inefficient. We can use a Nodejs server to compile with TypeScript and communicate through web services. It will most probably improve performances a lot.

Generate source maps for modules

In module mode, JSweet programs cannot be debugged because they don't have source maps... It is important to have this feature because the module mode is the most comfortable mode to develop applications easily since we can generate bundles.

Report error when using wildcards in imports

Using wildcard will eventually pose problems (I am sure there are a lot of potential non-reported bugs here), so we will just forbid them for now... they are bad practice anyway.

Potential support is not completely out of question, but we should have an interesting use case.

Prettyprinter improvements in foreach loops

For loops variables should be humain-friendly when possible.
Array's forEach function shall be used when possible.

Fix pom.xml errors in Eclipse

Plugin execution not covered by lifecycle configuration: org.codehaus.mojo:exec-maven-plugin:1.4.0:exec (execution: doc-markdown, phase:
generate-sources)

=> Examples and Quickstart:
Plugin execution not covered by lifecycle configuration: org.apache.maven.plugins:maven-antrun-plugin:1.8:run (execution: generate-js, phase:
generate-sources)

=> makes it look like it does not work (but it actually does)

Unit testing in JSweet

Find a way to provide unit tests in JSweet. Jasmine / Karma are standard candies so there is no reason why we could not write unit tests using those tools. It is important to check it though.

Build instructions

I did mvn install and build failed due to the absence of an executable pandoc, node.

Can you document the build instructions/dependencies in the README.md please.

All seemed to work for me after I did the following:

sudo apt-get install pandoc nodejs
## sort out an executable name conflict with another package by opting for nodejs
sudo ln -s /usr/bin/nodejs /usr/bin/node

JSON global variable is useless

API improvement: jsweet.lang.Globals.JSON variable is useless because all the members of JSON are static and can thus be accessed directly.

Preserve Javadoc comments

The transpiler should preserve Javadoc comments in the generated code. Optionally inlined comment should be also preserved.

file extension - change from *.java to *.jsweet

To be inline with other languages ("native" or "transpiled") it would be better, to change *.java to *.jsweet! So it should also be easier write plugins for different IDEs or editors like Sublime.

typeof support

There is currently no equivalent of "typeof myvar" in JSweet, we could have an utility method, statically imported (like union / function / ...) and call String theType = typeof(myvar); in JSweet.
It would also be possible to transpile getClass() to typeof but it doesn't feel like JSweet spirit.

Thanks.

Could not find artifact org.jsweet:jsweet-maven-plugin:jar:1.0.0-SNAPSHOT

From @tdebroc on December 22, 2015 9:4

I have a maven Build Failure:
[ERROR] Plugin org.jsweet:jsweet-maven-plugin:1.0.0-SNAPSHOT or one of its dependencies could not be resolved: Could not find artifact org.jsweet:jsweet-maven-plugin:jar:1.0.0-SNAPSHOT

Copied from original issue: cincheo/jsweet-examples#12

Make the transpiler check that the candy version is compatible

When Candies are generated, the TSD translator sets its version as the last digit of the build number.

For instance, if the TSD translator version is 12, then:

• jQuery 1.10.0 becomes jQuery 1.10.12 (case when build number == 0)
• jQuery 1.10.3 would becomes jQuery 1.10.300012 (case when build number != 0)

The transpiler should be able to refuse candies that will not be supported with a sound message so that users don't believe that it is an API or transpiler bug.

Todo:

1. Each candy set in the META_INF the version of the transpiler it is compatible with
2. The transpiler reports a warning when its version is not equal to the one declared by the candy

Static special method should be named differently

To avoid name clashes between static and non static:

• $getStatic
• $setStatic
• $deleteStatic

Error when a class with a main method is declared in the default package

In the sandbox:

import static jsweet.util.Globals.array;
import static jsweet.dom.Globals.console;

public class C {
public static void main(String[] args) {
String[] strings = { "a", "b", "c" };
console.log(strings);
array(strings).push("d");
assert strings[3] == "d";
console.log(strings);
}
}

=> Line 12: Declaration or statement expected.

But it works if the class does not contain a main method (for instance rename main to m).

Fail to transpile a parameterized method application if target is not specified (this or class name not added)

Normally JSweet adds the missing "this" automatically. Not in that case it seems:

private <T> void installXMLHttpRequestListeners(XMLHttpRequest xhr,Consumer<T> resolve, Consumer<Object> reject) {
        xhr.onload = (Event ev) -> {
            // TODO bug
            //onXMLHttpRequestComplete(xhr, resolve, reject); bug
            // what we must write to avoid the bug
            this.<T>onXMLHttpRequestComplete(xhr, resolve, reject);

            return null;
        };
    }

It looks like an unusual case so we can probably fix it in the next release.

allow private constructors

private constructors raise an error with JSweet, I think it would be better to permit it and delete it at transpilation time, so we could enjoy the private constructor feature at least in our IDE.

window.setTimeout() function

[I report here a question from Satguru for sharing with the community]

Not sure how to use the window.setTimeout() function.

Jsweet defines it as

native public double setTimeout(Object handler, Object timeout, Object... args);

This does not allow me to pass a java function to it

For example
window.setTimout(this::aMethod,0,"abc");

gives following error
The target type of this expression must be a functional interface

Add support for java.lang.String.length()

The Java String's length method should be transpiled to the JS length property.

More efficient Getting Started

We need a project template so that developers can start with JSweet very quickly through Maven... the getting started doc needs to be rewritten to reflect this change.

Support for asm.js

It should be possible in JSweet to write asm.js modules.

The good news is that Java, by supporting integers and floats, could be a good environment to generate type-checked asm code (so is C++). Of course there would be the limitations imposed by asm.js (only numbers, no strings, no objects, ...). NOTE: on contrary, TypeScript, with its sole number is not well armed to type check asm.js, as said here.

So, the idea would be to have an annotation to generate the "use asm" directive. That could be a specific annotation or a generic one. Let us imagine a generic @StringDirective annotation. We could have something like:

@StringDirective("use asm")
class MyAsmModule {
    public void static m() {
        int first = 5;
        int second = first;
        float f = first;
   }
}

Which would generate as the following TypeScript code:

class MyAsmModule {
    "use asm"
    m() : void {
        var first = 5;
        var second = first | 0;
        var f = first | 0.0;
   }
}

NOTE: my knowledge of asm.js being still quite recent, I may be getting some things wrong so please correct me if it is the case.

Add an exclude option for the transpiler

Users should be able to exclude some files from the transpilation

Issue with the Clone method of Babylon.js

Ran into the following issue with "candies/babylonjs--babylon/2.2.2-SNAPSHOT"

"babylon.d.ts" has a

class Mesh

with method

clone(name: string, newParent?: Node, doNotCloneChildren?: boolean): Mesh;

JSweet coompiles this to

Clone(....)

that is clone with capital C

See https://jsweet.org/apidocs/snapshots/org/jsweet/candies/babylonjs--babylon/2.2.2-SNAPSHOT/def/babylonjs/babylon/Mesh.html#Clone-java.lang.String-

The TS compiler fails with this error

ERROR: Property 'Clone' does not exist on type 'Mesh'. at org\ssatguru\babylonjs\TestIt.ts(73)

Problem with wildcards in generics

Wildcards are not transpiled correctly. The following code fails:

public class Wildcards {
    public void m(I<?> i) {
    }
}

class I<T> {
}

Constructor overloading is not allowed

Currently, constructors cannot be overloaded... the following code will not work (raises invalid overload):

class C {
    public C(String s) {
        [...]
    }

    public C() {
        this("default value");
    }
}

However, it would be easy to support this kind of overloading (similarly to method overloading).

Pure Java candies

Currently, candies are extracted from TSD definition files. The JSweet transpiler relies both on the Java definitions and on the TypeScript ones to transpile (double check). Programmers can submit to TSD new definition files and can also write @Ambiant definitions to support new APIs, however, they cannot write candies directly in Java (in theory they could, but the tsc compiler will complain because it cannot find the TypeScript definition file).

We probably need a way to support pure Java definition so that programmers can write their own candies in Java.

Troubleshooting: This feature can become a problem if people start writing definitions in parallel of the TSD (which should remain the reference). In the future, we also need to sort out this issue by proposing a full equivalence between JSweet and TypeScript definitions (maybe automatize the publication of both format at once).

packaging a JSweet jar (candy) issue

Good news - If the jar is packaged properly it works, I am able to successfully share the jar with another project.
And that is so great.
This makes it so easy to share JS libraries. No complicated includes, requires, references. Just add a jar to your classpath and you are good to go :)

Bad news - There seems to be some issue with the maven-plugin. It recognizes the "declaration" option but not the "dtsout" option. The ".d.ts" file is created but in default "target/js" folder.
I tried various things but wasn't successful.Ended up moving the file manually.
Attached is the pom file I was trying.
pom.zip

Ignore annotations in the Java source (such as @XmlRootElement)

I am trying to use jSweet to translate DTOs (data transfer objects) from Java to Typescript so that I can easily serialize the same object on both ends (Java server and - currently - Typescript client).

I have a DTO tagged with javax.xml.bind.annotation.XmlRootElement annotation so that it can be serialized in JSON using Jackson.
I also have some methods that do not translate (equals/hashCode for instance).

It would be nice to simply ignore things that do not translate to Typescript (such as Java annotations - although now it starts existing in the latest Typescript).

And it would be nice to add a ignore annotation on methods/fields, etc... that do not need to be translated.

What do you guys think?

annotation mapped method overloading

It would be great for existing implementations/libraries (even though this is not the main purpose of JSweet) which cannot be structurally changed, to have the option of mapping diffrent method overloadings to diffrent method names. I know, it is not so easily implemented. Especially if it is done with some covenience considered. But would greatly benefit migrators.

IntelliJ plugin?

Is a plugin for IntelliJ on the roadmap? Would be great!

if then else bug

following

package org.ssatguru.babylonjs;
import static jsweet.dom.Globals.console;
public class CodeSnippet {
    public static void main(String args[]){
        int i =1;
        if (i==1)console.log("is true");
        else console.log("is false");
    }
}

gives following error during TS compile

[INFO] JSweet transpiler version 1.0.0-SNAPSHOT (build date: 2016-01-16 10:30:13)
ERROR: ';' expected. at org\ssatguru\babylonjs\CodeSnippet.ts(6)
[ERROR] transpilation failed

Add an option to report Java errors

Currently, JSweet prints out Java errors bud does not go through the actual error reporting API (see the bad looking TranspilationHandler.reportSilentError() method). This is bad for reporting compilation errors in a consistent way.

We need a solution for reporting or ignoring Java errors depending on if the reporting of Java errors is needed or not (for instance, in the Eclipse plugin, it is not needed because Eclipse will report the errors).

Possible solutions are:

• add an option to the transpiler, so that it can ignore Java errors
• add a category to errors so that the handler can ignore some of them

The second solution is probably better... clearly more generic and flexible.

Proposal for decorator support

We need to support decorators: microsoft/TypeScript#2249

To support decorators, I propose a meta annotation @decorator.

For instance (this is still approximate code):

@Decorator
public @interface readonly {
}

@Decorator
public @interface enumerable {
     boolean value();
}

public class C {
  @readonly
  @enumerable(false)
  void method() { }
}

public static Globals {
    public static <T> void readonly(Function target, String key, TypedPropertyDescriptor<T> descriptor) {
        descriptor.writable = false;
    }

    public static <T> TypedPropertyDescriptor<T> function enumerable(value) {
        return function ((Function target, String key, TypedPropertyDescriptor<T> descriptor) =>  {
           descriptor.enumerable = value;
        });
    }
}

Would transpile to (approximate code also):

class C {
  @readonly
  @enumerable(false)
  method() { }
}

function readonly(target, key, descriptor) {
    descriptor.writable = false;
}

function enumerable(value) {
  return function (target, key, descriptor) {
     descriptor.enumerable = value;
  }
}

This this just a proposal that needs to be refined. In particular, the definition of the global decoration methods could be improved and the overall pattern needs to be validated.

Report sound error when a class is created in a parent of a @Root package

@root packages and their parents are not part of the module hierarchy and should not conain any classes

Problem with jsweet.util.Global cast methods

number(n/2).toFixed(0) generates n/2.toFixed(0) but it should actually generated (n/2).toFixed(0).

Calls to cast methods should always be parenthesized.

Issue with "candies/babylonjs--babylon/2.2.2-SNAPSHOT"

"babylon.d.ts" has a

class Mesh

with method

clone(name: string, newParent?: Node, doNotCloneChildren?: boolean): Mesh;

JSweet coompiles this to

Clone(....)

that is clone with capital C

See https://jsweet.org/apidocs/snapshots/org/jsweet/candies/babylonjs--babylon/2.2.2-SNAPSHOT/def/babylonjs/babylon/Mesh.html#Clone-java.lang.String-

The TS compiler fails with this error

ERROR: Property 'Clone' does not exist on type 'Mesh'. at org\ssatguru\babylonjs\TestIt.ts(73)

Here's a small program to Test

import def.babylonjs.babylon.Mesh;

public class Test {

    public static void main(String args[]){
        Mesh mesh = new Mesh();
        Mesh mesh2 = mesh.Clone("cloned mesh"); 
    }

}

Static methods invocation in Globals fail when Globals is in @Root package

Create a test from the Angular example and fix it