java-bridge 2.1.3 → 2.1.4

package/dist/ts-src/TypescriptDefinitionGenerator.d.ts

@@ -0,0 +1,81 @@
+export interface MethodDeclaration {
+    returnType: string;
+    parameters: string[];
+    isStatic: boolean;
+}
+/**
+ * A java class declaration converted to typescript
+ */
+export interface ModuleDeclaration {
+    /**
+     * The fully-qualified class name
+     */
+    name: string;
+    /**
+     * The generated typescript code
+     */
+    contents: string;
+}
+/**
+ * A TypescriptDefinitionGenerator progress callback method
+ */
+export declare type ProgressCallback = (classname: string) => void;
+/**
+ * A class to generate typescript definitions for java classes.
+ * Converts the given class and all of its dependencies to typescript.
+ *
+ * ## Example
+ * ```ts
+ * import { TypescriptDefinitionGenerator } from 'java-bridge';
+ *
+ * const generator = new TypescriptDefinitionGenerator('java.lang.String');
+ * // Generate the typescript definitions
+ * const definitions = await generator.generate();
+ *
+ * // Save the definitions to a directory
+ * await TypescriptDefinitionGenerator.save(definitions, './project');
+ * ```
+ */
+export default class TypescriptDefinitionGenerator {
+    private readonly classname;
+    private readonly progressCallback;
+    private readonly resolvedImports;
+    private usesBasicOrJavaType;
+    private readonly additionalImports;
+    private readonly importsToResolve;
+    /**
+     * Create a new `TypescriptDefinitionGenerator` instance
+     *
+     * @param classname the fully-qualified name of the class to generate a typescript definition for
+     * @param progressCallback a callback method to be called every time a java class is
+     *                         converted to typescript
+     * @param resolvedImports a list of imports that have already been resolved.
+     *                        This is used to prevent converting a class multiple times
+     */
+    constructor(classname: string, progressCallback?: ProgressCallback | null, resolvedImports?: string[]);
+    private static convertMethods;
+    private convertConstructors;
+    private javaTypeToTypescriptType;
+    private convertParameter;
+    private convertParameters;
+    private static createMethodComment;
+    private createMethod;
+    private convertMethod;
+    private getAdditionalImports;
+    private getImports;
+    private getExportStatement;
+    private getText;
+    /**
+     * Generates the typescript definition for the given class.
+     *
+     * @returns the generated typescript definitions
+     */
+    generate(): Promise<ModuleDeclaration[]>;
+    /**
+     * Save the converted classes to the given directory.
+     *
+     * @param declarations the declarations to save
+     * @param sourceDir the directory to save the files to
+     */
+    static save(declarations: ModuleDeclaration[], sourceDir: string): Promise<void>;
+}

package/{ts-src/definitions.ts → dist/ts-src/definitions.d.ts}

@@ -4,45 +4,39 @@
  * may differ if you use a different
  * version of the jvm shared library.
  */
-export enum JavaVersion {
+export declare enum JavaVersion {
     /** Java version 1.1 */
-    VER_1_1 = '1.1',
+    VER_1_1 = "1.1",
     /** Java version 1.2 */
-    VER_1_2 = '1.2',
+    VER_1_2 = "1.2",
     /** Java version 1.4 */
-    VER_1_4 = '1.4',
+    VER_1_4 = "1.4",
     /** Java version 1.6 */
-    VER_1_6 = '1.6',
+    VER_1_6 = "1.6",
     /** Java version 1.8 */
-    VER_1_8 = '1.8',
+    VER_1_8 = "1.8",
     /** Java version 9 */
-    VER_9 = '9',
+    VER_9 = "9",
     /** Java version 10 */
-    VER_10 = '10',
+    VER_10 = "10"
 }
-
-Object.freeze(JavaVersion);
-
 /**
  * Any basic javascript type accepted by this library.
  */
 export declare type BasicType = string | number | boolean | BigInt | null;
-
 /**
  * Any java type accepted by this library, except arrays.
  */
-export type BasicOrJavaType = BasicType | JavaObject | JavaConstructor;
-
+export declare type BasicOrJavaType = BasicType | JavaObject | JavaClass | JavaClassType;
 /**
  * All types accepted by java
  */
-export type JavaType = BasicOrJavaType | BasicOrJavaType[];
-
+export declare type JavaType = BasicOrJavaType | BasicOrJavaType[];
 /**
  * A dummy java object class
  */
-export abstract class JavaObject {}
-
+export declare abstract class JavaObject {
+}
 /**
  * A java class proxy class.
  * This only exists for temporarily storing
@@ -55,90 +49,71 @@ export declare class JavaClassProxy {
     /**
      * The class name
      */
-    public 'class.name': string;
-
+    'class.name': string;
     /**
      * Get the class's constructor
      *
      * @return the java instance proxy constructor
      */
-    public getClassConstructor<
-        T extends JavaClassType = JavaClassType
-    >(): JavaConstructor<T>;
+    getClassConstructor<T extends JavaClassType = UnknownJavaClassType>(): T;
 }
-
-export type JavaClassType = typeof JavaClassInstance;
-
+export declare type JavaClassType = typeof JavaClass;
+export declare type UnknownJavaClassType = typeof UnknownJavaClass;
+export declare type JavaClassConstructorType = typeof JavaClassConstructor;
 /**
- * A java class's constructor
+ * @inheritDoc UnknownJavaClass
  */
-export type JavaConstructor<T extends JavaClassType = JavaClassType> = T &
-    ImportedMembers;
-
+export declare class JavaClassInstance extends UnknownJavaClass {
+}
 /**
- * Any class member imported from java
+ * A java class constructor class
+ *
+ * @see JavaClass
  */
-export interface ImportedMembers {
-    /**
-     * Get the java class instance
-     */
-    get class(): JavaClassInstance;
-
-    /**
-     * Any class member imported.
-     * We'll need to use 'any' as any is callable.
-     * The actual type would be JavaType | ((...args: JavaType[]) => JavaType | Promise<JavaType>)
-     */
-    [member: string]: any;
+export declare class JavaClassConstructor extends JavaClass {
+    constructor(...args: BasicOrJavaType[]);
 }
-
 /**
  * A constructor type.
  */
-export type Constructor<T> = { new (): T };
-
+export declare type Constructor<T> = {
+    new (): T;
+};
 /**
- * The java instance proxy class.
- * This class actually does all the magic.
- * After it is created, this will just be a constructor
- * with all static methods and properties (the accessible ones)
- * stored in it and ready for use. Once the actual instance
- * using the new operator is created, a new
- * java_instance_proxy instance is created, containing
- * the actual java instance (that thing isn't visible though)
- * and all (visible) non-static class member methods and properties.
+ * A class to be extended for custom class definitions.
+ * This does not allow for any methods to be called if not
+ * defined in the class definition.
+ *
+ * ## Example
+ * ```ts
+ * import { importClass } from 'java-bridge';
+ *
+ * declare class PersonClass extends JavaClass {
+ *     public constructor(name: string, age: number);
+ *     public newInstanceAsync(name: string, age: number): Promise<Person>;
+ *
+ *     public getName(): Promise<string>;
+ *     public getNameSync(): string;
+ *     public getAge(): Promise<number>;
+ *     public getAgeSync(): number;
+ * }
+ *
+ * class Person extends importClass<typeof PersonClass>('com.test.Person') {}
+ *
+ * const person = new Person('John', 20);
+ * console.log(person.getNameSync()); // John
+ * console.log(person.getAgeSync()); // 20
+ * ```
  */
-export declare class JavaClassInstance extends JavaObject {
+export declare class JavaClass extends JavaObject {
     /**
-     * The class proxy class instance
-     */
-    public static readonly 'class.proxy': JavaClassProxy;
-
-    /**
-     * Create a new java class instance.
-     * Async version.
-     *
-     * @template T the type of this class as a new instance of this class will be returned
-     * @param args the arguments to create the instance
-     * @return the java_instance_proxy instance
+     * Get the java class instance
      */
-    public static newInstanceAsync(
-        this: never,
-        ...args: BasicOrJavaType[]
-    ): Promise<unknown>;
-    public static newInstanceAsync<T extends JavaClassInstance>(
-        this: Constructor<T>,
-        ...args: BasicOrJavaType[]
-    ): Promise<T>;
-
+    static get class(): UnknownJavaClass;
     /**
-     * Create a new java instance of type
-     * java_instance_proxy["class.proxy.instance"]
-     *
-     * @param args the arguments to create the instance
+     * The class proxy class instance
      */
-    public constructor(...args: BasicOrJavaType[]);
-
+    static readonly 'class.proxy': JavaClassProxy;
     /**
      * Check if this is an instance of another class.
      * Pass either the name of the other class or the class itself
@@ -162,10 +137,7 @@ export declare class JavaClassInstance extends JavaObject {
      * @param other the class to check if this is an instance of
      * @return true if this is instance of `other`
      */
-    public instanceOf<T extends typeof JavaClassInstance>(
-        other: string | T
-    ): boolean;
-
+    instanceOf<T extends JavaClassConstructorType>(other: string | T): boolean;
     /**
      * Default java equals implementation.
      * Async call.
@@ -173,8 +145,7 @@ export declare class JavaClassInstance extends JavaObject {
      * @param o the object to compare this to
      * @returns true if this matches o
      */
-    public equals(o: JavaClassInstance): Promise<boolean>;
-
+    equals(o: JavaClass): Promise<boolean>;
     /**
      * Default java equals implementation.
      * Sync call.
@@ -182,24 +153,51 @@ export declare class JavaClassInstance extends JavaObject {
      * @param o the object to compare this to
      * @returns true if this matches o
      */
-    public equalsSync(o: JavaClassInstance): boolean;
-
+    equalsSync(o: JavaClass): boolean;
     /**
      * Java default toString method.
      * Async call.
      *
      * @returns this as a string
      */
-    public toString(): Promise<string>;
-
+    toString(): Promise<string>;
     /**
      * Java default toString method.
      * Sync call.
      *
      * @returns this as a string
      */
-    public toStringSync(): string;
-
+    toStringSync(): string;
+}
+/**
+ * The java instance proxy class.
+ * This class actually does all the magic.
+ * After it is created, this will just be a constructor
+ * with all static methods and properties (the accessible ones)
+ * stored in it and ready for use. Once the actual instance
+ * using the new operator is created, a new
+ * java_instance_proxy instance is created, containing
+ * the actual java instance (that thing isn't visible though)
+ * and all (visible) non-static class member methods and properties.
+ */
+export declare class UnknownJavaClass extends JavaClass {
+    /**
+     * Create a new java class instance.
+     * Async version.
+     *
+     * @template T the type of this class as a new instance of this class will be returned
+     * @param args the arguments to create the instance
+     * @return the java_instance_proxy instance
+     */
+    static newInstanceAsync(this: never, ...args: BasicOrJavaType[]): Promise<unknown>;
+    static newInstanceAsync<T extends JavaClass>(this: Constructor<T>, ...args: BasicOrJavaType[]): Promise<T>;
+    /**
+     * Create a new java instance of type
+     * java_instance_proxy["class.proxy.instance"]
+     *
+     * @param args the arguments to create the instance
+     */
+    constructor(...args: BasicOrJavaType[]);
     /**
      * Any class member imported.
      * We'll need to use 'any' as any is callable.
@@ -207,4 +205,10 @@ export declare class JavaClassInstance extends JavaObject {
      * Just throwing it out there.
      */
     [member: string]: any;
+    /**
+     * Any static class member imported.
+     * We'll need to use `any` as `any` is callable.
+     * The actual type would be JavaType | ((...args: JavaType[]) => JavaType | Promise<JavaType>)
+     */
+    static [member: string]: any;
 }

package/{ts-src/index.ts → dist/ts-src/index.d.ts}

@@ -1,16 +1,4 @@
-export {
-    JavaVersion,
-    JavaObject,
-    JavaClassInstance,
-    JavaClassProxy,
-    JavaType,
-    JavaConstructor,
-    BasicOrJavaType,
-    BasicType,
-    ImportedMembers,
-    JavaClassType,
-    Constructor,
-} from './definitions';
+export { JavaVersion, JavaObject, JavaClassInstance, JavaClassProxy, JavaClass, JavaClassConstructor, JavaType, BasicOrJavaType, BasicType, JavaClassType, Constructor, UnknownJavaClassType, JavaClassConstructorType, } from './definitions';
 import type * as internal from '../native';
 /**
  * A namespace containing any internal type definitions.
@@ -24,8 +12,4 @@ export default java;
 export { getJavaLibPath } from '../native';
 import TypescriptDefinitionGenerator from './TypescriptDefinitionGenerator';
 export { TypescriptDefinitionGenerator };
-export {
-    ModuleDeclaration,
-    MethodDeclaration,
-    ProgressCallback,
-} from './TypescriptDefinitionGenerator';
+export { ModuleDeclaration, MethodDeclaration, ProgressCallback, } from './TypescriptDefinitionGenerator';