This is problematic on a number of fronts, e.g. if the Java class exposes important constants one needs to use.

Add support of GenericArrayType (at least doesn’t throw not implemented exception)

Since the Nashorn seems going to be deprecated (refer to JEP335 ) decision that I really don't understand and seems to me more strategical than technical, we have to identify alternative solutions

One suitable solution is to move on Rhino (refer issue #8 )

Another one seems to use Graal.JS that should be available as independent module on top of JVM 9

I'm trying to setup this lib on my project, but when i map a class from my project it gives me class not found exception.

i made this repo with a reproduction of the problem: https://github.com/eloyleonardo/test-d-ts.

If i remove the the line with my custom class all pass.

It looks like the processor doesn't have access to the project classes (classpath), but i can't find any tricks to make this works.

Is this expected ? Or is there any change on gradle to the processor find my class ?

As explained in the documentation https://www.graalvm.org/reference-manual/js/Options/#to-the-launcher

--js.foreign-object-prototype: provide JavaScript’s default prototype to foreign objects that mimic JavaScript’s own types (foreign Arrays, Objects and Functions). Boolean value, default is false.

So, for example, List could extend Array and so on.

See BiFunction declaration below

class ConcurrentHashMap<K, V>/* extends java.util.AbstractMap<K, V> implements ConcurrentMap<K, V>, java.io.Serializable*/ {

reduceEntries( arg0:long, arg1:BiFunction<java.util.Map$Entry<K, V>, java.util.Map$Entry<K, V>, ? extends java.util.Map$Entry<K, V>> ):java.util.Map$Entry<K, V>;

} // end ConcurrentHashMap

Would it be possible to add Gradle support? Or if it's a lot of work could you maybe give some pointers so i can take a look at porting?

Thanks!

Processing enum java.lang.management.MemoryType produced a strange code:

interface MemoryTypeStatic {

Heap memory:java.lang.management.MemoryType;
Nonheap memory:java.lang.management.MemoryType;

readonly class:any;
valueOf( arg0:string ):java.lang.management.MemoryType;
valueOf<T>( arg0:java.lang.Class<T>, arg1:string ):T;
values(  ):[java.lang.management.MemoryType];
}

This is extremely problematic because classes (or their static dependencies) may have static initializers that outright fail in a compilation / annotation processor environment. This is a big motivator for the Java javax.lang.model packages.

Would it be possible to generate the definitions from the whole JVM itself? Nashorn allows one to use all the Java classes inside your javascripts, so having the types for the whole JVM would be nice to help writing it in typescript.

This requires that all methods be repeated in each class/interface, which is not ideal.

Generate class definition / declaration using the special notation with char $

Add support for Rhino java script interpreter

If one has a Java package name like "com.acme.delete" or "com.acme.export" then the resulting TypeScript will not work due to "delete" and "export" being reserved words.

Idea is to generate a definition that will have one constructor that accept one parameter that is declaration of functional interface itself

Example

package-info.java

@Type(value=java.lang.Iterable.class)

<types>-types.ts

interface IterableStatic {
  new<T>( arg0:java.lang.Iterable<T> ):java.lang.Iterable<T>;
}

const Iterable:IterableStatic  = Java.type("java.lang.Iterable");

Idea is to allow to increase project modularisation

this feature implies that for definitions we will have the possibility to define a custom namespace for each Java2TS annotation

It is ... unfortunate that we end up having 2 Xxx names for every given Java class for which we want to access contructors (or enum values). So I get that these don't really fall nicely into a single namespace.

Elevating all "exported" classes to the same global namespace does not seem like an appropriate solution, though.